🖥️

SQL: de lo básico a lo complejo

Comentarios preliminares
1. Queries
USE, SELECT, FROM
WHERE
AND/OR
WHERE NOT
IN
BETWEEN
LIKE
REGEXP (regular expression)
ORDER BY
IS NULL
IS NOT NULL
LIMIT
USING
UNION
2. Subqueries
Subquery básica
Subquery + IN
JOIN vs Subquery
ALL

SQL: de lo básico a lo complejo 1

 ANY
Queries Correlacionados
EXIST
Queries dentro de SELECT
Queries dentro de FROM
3. JOINS
JOIN en multiples tablas
JOIN con diferentes SCHEMAS (varias bases de datos)
SELF JOIN
CROSS JOIN
JOIN NATURAL
4. Funciones de SQL
Funciones numéricas https://dev.mysql.com/doc/refman/8.0/en/numeric-functions.html
ROUND (redondear)
TRUNCATE (elimina decimales)
CEILING (redondear para arriba)
FLOOR (redondear para abajo)
ABS (muestra el valor absoluto)
RAND (crea valores decimales aleatorios)
Funciones STRING https://dev.mysql.com/doc/refman/8.0/en/string-functions.html
LENGTH (muestra la cantidad de caracteres incluye espacios)
UPPER (convierte el texto a mayúscula)
LOWER (convierte el texto a minúscula)
LTRIM/RTRIM (borrar todos los espacios a la izquierda/derecha de un texto)
LEFT (extrae x cantidad de caracteres de una palabra por la izquierda y luego los
muestra)
RIGHT (extrae x cantidad de caracteres de una palabra por la derecha y luego los
muestra)
TRIM (quita todos los espacios de más al principio y al final)
SUBSTRING (quita caracteres fuera del rango indicado y muestra el resultado)
LOCATE (muestra la posición de una letra en una palabra)
REPLACE (reemlaza un caracter o una cadena de caracteres buscado por uno nuevo)
CONCAT (une dos cadenas)
Funciones de Tiempo y Fechas: https://dev.mysql.com/doc/refman/8.0/en/date-and-time-
functions.html
NOW (muestra fecha y hora)
CURDATE (muestra la fecha actual)
CURTIME (muestra la hora actual)
YEAR (extrae el año a partir de una fecha dada)

SQL: de lo básico a lo complejo 2

 MONTH (extrae el número de mes en una fecha dada)
DAY (extrae el número de día de una fecha dada)
HOUR (extrae la hora de una fecha dada)
MINUTE (muestra el minuto de una fecha dada)
SECOND (muestra el segundo de una fecha dada)
DAYNAME/MONTHNAME (devuelve el nombre de un día de la semana/mes para una
fecha dada)
EXTRACT (extrae una parte de una fecha dada, indicado por su primer parámetro)
IFNULL (devuelve un valor especificado si la expresión resultado es NULL)
COALESCE (devuelve el primer valor nulo de una columna y lo reemplaza por el de
otra columna del mismo registro)
IF (se cumple una condición u otra)
CASE (se cumplen varias condiciones)
5. Filas, Columnas y Tablas
Insertar una fila - INSERT INTO
Insertar varias filas en una misma columna - INSERT INTO
Insertar una fila con contenido en varias columnas - INSERT INTO
Insertar varias filas con contenido en varias columnas - INSERT INTO
Insertar una columna - ALTER TABLE & ADD
Modificar/actualizar el contenido de una fila - UPDATE
Duplicar una tabla - CREATE TABLE
Borrar una fila - DELETE
6. Agregaciones
MAX
SUM
COUNT
COUNT DISTINCT
AVERAGE
GROUP BY
HAVING
WITH ROLLUP
7. Atributos de columnas
Atributos de Columna
8. Vistas
Descripción
CREATE VIEW
DROP VIEW con código
CREATE OR REPLACE VIEW (modificar una VIEW)
DELETE + VIEW (borra contenido de una vista)

SQL: de lo básico a lo complejo 3

 9. Stored Procedures (Procesos almacenados)
Descripción
CREATE PROCEDURE
CALL (llama a un Stored Procedure)
Diferencia VIEW y STORE PROCEDURE
Crear un Stored Procedure desde la sección de SCHEMAS
Borrar procesos almacenados
Parámetros
Modificar los parámetros de un SP
Parámetros DEFAULT (que se muestre un valor cuando no se especifica un parámetro)
Actualizar tablas con SP
Restricciones en SP
Parámetro de salida (generan un resultado específico para una entrada)
Variables en SP y DECLARE
10. Funciones
Descripción
Ejemplo:
11. TRIGGERS
Descripción
Ejemplo
SHOW TRIGGERS
Modificar y borrar TRIGGERS
TRIGGERS COMO AUDITORÍA
12. EVENT
Descripción
Ejemplo
SHOW EVENTS
DROP EVENT IF EXIST nombre_de_evento;
13.Transacciones y concurrencia
Descripción
Ejemplo:
Concurrencia
14.Tipos de datos
Descripción
STRING
INTEGER
FLOAT
Booleanos: 0,1 o True/false.

SQL: de lo básico a lo complejo 4

 DATE
TIME
DATETIME
TIMESTAMP
YEAR
MONTH
DAY
ENUM
JSON
15. Modelando bases de datos
Etapas
¿Cómo se crea un modelo nuevo?
Normalización
Forward engineering
Sincronizar el modelo de datos
Reverse engineering
Agregar tablas desde código.
Modificar tablas desde código.
Crear conexiones con código
CHARSET y colación
Motores de almacenamiento (Store engine)
16. INDEX
Descripción
Ejemplo
SHOW INDEXES
EXPLAIN
DROP INDEX
INDEX con Texto
FULLTEXT INDEX
17. Permisos y privilegios de usuarios.
Dar permisos a usuarios
Administración de privilegios y usuarios

Comentarios preliminares
Si bien es cierto que herramientas como Excel cumplen con los requerimientos
básicos para manejar datos en la mayoría de las empresas, poco ha poco, y

SQL: de lo básico a lo complejo 5

 conforme se profundiza más en el mundo del análisis de datos, se llega a
necesitar de algo más especializado, capaz de administrar una mayor carga de
trabajo de forma más eficiente. Ese algo es SQL, específicamente para interactuar
con bases de datos relacionales (esto es, en términos sencillos, que están
almacenadas en forma de tablas).
Luego de varios años de aprendizaje y práctica he compilado en un solo
documento lo que considero básico, intermedio y avanzado en el dominio de SQL,
pasando de queries sencillos hasta temas más complejos como triggers,
concurrencias y modelado de bases de datos.
Con esto pretendo facilitarle la tarea tanto a los que están iniciando su carrera
profesional como analistas o científicos de datos como a los más experimentados
que podrían encontrar aquí un recurso debidamente estructurado que les permita
refrescar o consultar una que otra fórmula.
Como siempre, todo estudio debe ir acompañado de practica, así que ¡Manos a la
obra!
PD: en el siguiente enlace pueden realizar prácticas en línea, sin necesidad de
instalar SLQ en sus equipos. Es una gran forma de aprender sobre la marcha y de
aprovechar los tiempos muertos: https://sqlbolt.com/

José Pablo Sanabria C.

Máster en business analytics.

1. Queries
USE, SELECT, FROM
Seleccionar la librería de datos, seleccionar las columnas indicadas (incluyendo
una nueva calculada), desde la tabla de ventas.

Use datos;
SELECT clave_productos, fecha, venta, venta*1.16 AS venta_iva
FROM ventas

SQL: de lo básico a lo complejo 6

 WHERE

SELECT ID_local, clave_producto, venta

FROM ventas
WHERE clave_producto = "pzz"

De la tabla ventas, en donde clave_producto sea igual a pzz.

WHERE funciona con operadores ><, =, != (no es x), texto (ponerlo entre "").

AND/OR

SELECT ID_local, clave_producto, venta

FROM ventas
WHERE clave_producto = "pzz" AND ID_local = 2 OR venta > 1000

Se debe de poner primero el AND y luego el OR.

WHERE NOT
Muestra todo lo que “no es” según lo especificado.

SELECT ID_local, clave_producto, venta

FROM ventas
WHERE NOT clave_producto = "pzz" AND ID_local = 2 OR venta > 1000

En este caso se específica que traiga todo lo que no es pizza, además que el
ID_local sea 2
o que las ventas sean mayores a 1000.

IN
Selecciona los valores especificados entre ().

SELECT *
FROM ventas

SQL: de lo básico a lo complejo 7

 WHERE clave_producto = "pzz" OR clave_producto = "brr" OR clave_producto =

Lo anterior se puede simplificar usando IN

SELECT *
FROM ventas
WHERE clave_producto IN ("pzz", "brr", "qsd")

BETWEEN
Selecciona valores dentro de un rango.

SELECT *
FROM ventas
WHERE venta BETWEEN 1000 AND 2000

LIKE

SELECT *
FROM ventas
WHERE clave_producto LIKE "%z"

% significa cualquier cantidad de caracteres antes de. Si se pone % significa

cualquier cantidad de caracteres luego de el valor especificado.
También se puede utilizar _ que hace referencia a un único espacio.Por ejemplo
"__z" buscaría
todo lo que tenga dos letras antes de la letra z.
Tambien funciona con números. Las comillas solo se usan con texto. WHERE
ID_local LIKE 2

REGEXP (regular expression)

Es como LIKE pero funciona mejor para textos.

SQL: de lo básico a lo complejo 8

 SELECT *
FROM empleados
WHERE apellido REGEXP "ez"

Se pueden combinar varios de los anteriores:

Busca todos los apellidos que contengan "ez".
REGEXP "^lo" busca todo lo que empieza con "lo".
REGEXP "ez$" busca todo lo que termine con "ez".
REGEXP "ez|iz" busca todo lo que tenga "ez" o "iz".Se pueden agregar más de
dos |

SELECT *
FROM empleados
WHERE apellido REGEXP "^ez|iz|za$"

ORDER BY

SELECT *
FROM empleados
ORDER BY apellido

ORDER BY apellido DESC ordena por apellido en forma descendente

ORDER BY nombre, apellido ordena por dos criterios: primero nombre y luego
apellido.
ORDER by EDAD * 2 ordena según el resultado de una operación. Se le puede
agregar un DESC luego del 2

IS NULL
Muestra todos los resultados para cuando el domicilio de la tabla empleados es
nulo.

SELECT *
FROM empleados

SQL: de lo básico a lo complejo 9

 WHERE domicilio IS NULL

IS NOT NULL
Muestra todos los valores en donde domicilio de la tabla empleados no es nulo.

SELECT *
FROM empleados
WHERE domicilio IS NOT NULL

LIMIT
Limita la cantidad de resultados a un número.
LIMIT 5,9 muestra los 9 registros siguientes luego del quinto.

SELECT *
FROM
LIMIT 5

USING
Using sirve para hacer un JOIN entre tablas cuyas columnas en común tienen el
mismo nombre.

SELECT *
FROM ventas v
JOIN local l
USING(ID_local);

UNION

SQL: de lo básico a lo complejo 10

 Une dos queries en una tabla. Es el equivalente a Anexar en Power Query. Deben
de tener la misma cantidad de columnas, de lo contrario no funciona.

SELECT Producto
FROM productos
UNION
SELECT ingredientes
FROM ingredientes;

El resultado es una sola columna con todos los productos seguido de todos
los ingredientes.

Si en producto se tienen 4 productos y en ingredientes 6, el resultado sería

una tabla de 24 líneas.

El siguiente ejemplo daría como resultado un error porque en el primer query

se tienen dos columnas y en el segundo solo una.

Un ejemplo de un uso correcto con varias columnas sería el siguiente:

SELECT Nombre, Estado_Civil, Edad

FROM vendedor
WHERE Estado_Civil ="Casado" AND Edad>50
UNION
SELECT Nombre, Estado_Civil, Edad
FROM vendedor
WHERE Estado_Civil ="Soltero" AND Edad<30

2. Subqueries
Subquery básica
Primero se corre el subquery, en este caso es un valor de 32.09. Luego busca los
valores que sean mayores a este valor y así completa el query.

SQL: de lo básico a lo complejo 11

 SELECT *
FROM empleados
WHERE edad>
(SELECT AVG(edad) FROM empleados);

Otro ejemplo sería:

UPDATE historico_ventas
SET venta= venta*1.16
WHERE ID_local=
(SELECT ID_local
FROM local
WHERE letra_zona="D");

Modifica la tabla historico ventas multiplicando los valores de la columna

ventas *1.16 en donde la columna ID_local de la tabla local se tenga como valor
"D".

Es posible elegir un segundo valor diferente a "D" agregando IN en dos partes:

UPDATE historico_ventas
SET venta= venta*1.16
WHERE ID_local IN
(SELECT ID_local
FROM local
WHERE letra_zona IN ("D","C"));

Subquery + IN
Muestra toda la información de la tabla empleados para cada empleado, haciendo
uso del subquery para buscar primero por valores únicos de venta_empleado.

SELECT *
FROM empleados
WHERE id_empleado IN (

SQL: de lo básico a lo complejo 12

 SELECT DISTINCT venta_empleado
FROM ventas);

Ejemplo de un subquery complejo + IN:

SELECT *
FROM cientes
WHERE ID_cliente IN (
SELECT v.ID_cliente
FROM ventas v
JOIN producto p USING (ID_producto)
WHERE p.producto = "remates" AND Fecha_venta BETWEEN "2016-01-01" AN
ORDER BY ID_cliente ASC

JOIN vs Subquery
Un subquery no permite hacer consultas de valores nulos por lo que es necesario
hacer JOINs.

SELECT *
FROM empleados e
LEFT JOIN ventas v
ON v.venta_empleado = e.ID_empleado
WHERE v.ventas_id IS NULL

ALL
Toma en cuenta todos los datos de una columna en una consulta.

Se usa para comparar el valor de una lista contra el valor máximo de otra lista.

Por ejemplo buscar la edad de un alumno que sea mayor a ALL maestros.
Trae la edad del alumno mayor al MAX de los maestros.

Cambia dependiendo de >< por lo que puede traer el valor mayor o menor de
una lista.

SQL: de lo básico a lo complejo 13

 SELECT *
FROM ventas
WHERE venta > ALL(
SELECT venta
FROM ventas
WHERE id_local = 2);

Busca el valor MAX en la tabla ventas donde el ID_local sea = 2 y luego trae toda
la información en donde la venta sea mayor al valor buscado anteriormente (el
MAX).
Otro ejemplo sería el siguiente en donde se busca el valor máximo en la tabla
ventas en donde el ID_local=4 y luego trae todo lo que sea menor al valor mínimo
encontrado anteriormente.

SELECT *
FROM ventas
WHERE venta < ALL(
SELECT venta
FROM ventas
WHERE ID_local = 4);

ANY
Toma en cuenta todos los datos de una columna en una consulta para comparar lo
que haya en una tabla contra cualquier valor de otra. Por ejemplo, devolver todos
los alumnos cuya edad es mayor a la de cualquier maestro.

SELECT *
FROM ventas
WHERE ventas > ANY (
SELECT venta
FROM ventas
WHERE id_local = 2);

SQL: de lo básico a lo complejo 14

 Muestra todos los valores que son mayores a cualquier venta del local 2.

Queries Correlacionados

SELECT *
FROM ventas v
WHERE ventas > (
SELECT AVG(Venta)
FROM ventas
WHERE Id_local= v.id_local)

Muestra todas las ventas mayores al promedio de las ventas para cada local.

La cláusula "WHERE Id_local = v.id_local" en la consulta original hace

referencia a la misma tabla "ventas".

En SQL, cuando se utiliza una subconsulta dentro de la cláusula WHERE, como

en este caso, la tabla externa (ventas v) y la tabla interna (ventas) son la
misma tabla, solo que se utiliza una sintaxis de correlación para referirse a la
tabla externa desde la subconsulta.

EXIST
Operador lógico que se utiliza para determinar si una subconsulta devuelve algún
resultado o no.

SELECT *
FROM empleados e
WHERE EXISTS(
SELECT venta_empleado
FROM ventas
WHERE venta_empleado = e.ID_empleado);

Muestra todos los empleados que realizaron una venta. Si se agrega un WHERE
NOT EXISTS entonces muestra los empleados que no vendieron nada.

La cláusula EXISTS en SQL se utiliza para verificar la existencia de registros en

una subconsulta.

SQL: de lo básico a lo complejo 15

 Proporciona un resultado booleano (verdadero o falso) basado en si la
subconsulta devuelve algún resultado o no. La cláusula EXISTS se utiliza
comúnmente en combinación con otras cláusulas de SQL, como WHERE o
HAVING, para filtrar los resultados de una consulta principal en función de la
existencia de registros en una tabla relacionada.

También se puede encontrar algo que no se encuentra en una lista de la

siguiente forma:

SELECT*
FROM producto
WHERE ID_producto NOT IN (
SELECT ID_producto
FROM ventas
WHERE fecha_venta BETWEEN "2017-03-01" AND "2017-03-31");

Nótese que básicamente son dos queries aparte que se unen. El primero busca
traer todo de la tabla producto cuando el ID_producto no esté en el resultado de
otro query: ID_producto de la tabla ventas en donde la fecha esté entre el 1 y 31 de
marzo 2017. Así muestra la información de los productos que no se vendieron
durante este periodo.

Queries dentro de SELECT

Se usa cuando se quiere hacer referecia a una columna que se creó en el mismo
query, en el ejemplo se crea promedio_venta y luego se referencia para hacer un
cálculo.

SELECT
ventas_id,
venta,
(SELECT AVG(venta) FROM ventas) AS promedio_venta,
venta - (SELECT promedio_venta
FROM ventas;

Muestra ventas id, la venta, el promedio de la venta y la resta de la venta menos el

promedio venta.

SQL: de lo básico a lo complejo 16

 Nótese cómo al hacer la resta es necesario incluir el (SELECT promedio_venta)
para que funcione correctamente.

Queries dentro de FROM

Se usa cuando se quiere hacer referecia a una columna que se creó en el mismo
query, en el ejemplo se crea promedio_venta y luego se referencia para hacer un
cálculo.

SELECT*
FROM (SELECT ventas_id, venta,
(SELECT AVG(venta) FROM ventas) AS promedioventa,
venta-(SELECT promedioventa) FROM ventas AS promedio
WHERE delta >100

3. JOINS
JOIN en multiples tablas

SELECT *
FROM ventas v
JOIN local l
ON v.ID_local = l.ID_local
JOIN empleados e
ON v.venta_empleado = ID_empleado

Une la tabla ventas por medio del v.ID_local con la tabla local por medio de
l.ID_local.
Luego une también la tabla empleados por medio de v.venta_empleado y
ID_empleado

JOIN con diferentes SCHEMAS (varias bases de datos)

SQL: de lo básico a lo complejo 17

 SELECT *
FROM periodo_1 p
JOIN datos.local l
ON p.local = l.letra_zona
De la tabla periodo_1 conocida como p, se une con la tabla "local" del Schema "d
p.local = l.letra_zona

SELF JOIN
Combina registros de una misma tabla utilizando alias, lo que permite relacionar
datos entre sí
para consultas más complejas y comparaciones internas.

SELECT
e.ID_Empleado,
e.Nombre,
e.ID_Gerente
p.Nombre AS gerente
FROM empleados e
LEFT JOIN empleados p
ON e.ID_Gerente = p.ID_Empleado

CROSS JOIN
Imaginemos dos conjuntos de datos, uno llamado "A" y otro llamado "B". Estos
conjuntos de datos no tienen una columna en común para relacionarse
directamente.

El CROSS JOIN (producto cartesiano) combina cada fila de la tabla "A" con cada
fila de la tabla "B".
Es decir, cada fila de "A" se combinará con todas las filas de "B", creando un
conjunto de resultados que es el resultado de todas las posibles combinaciones
entre las filas de ambos conjuntos de datos.

SQL: de lo básico a lo complejo 18

 SELECT*
FROM productos p
CROSS JOIN ingredientes i;

JOIN NATURAL
Une tablas que cuyas columnas en común comparten el mismo nombre. Es similar
o igual a USING. No se recomienda porque es mejor ser explícito.

SELECT *
FROM ventas v
NATURAL JOIN empleados e;

4. Funciones de SQL
Funciones numéricas
https://dev.mysql.com/doc/refman/8.0/en/numeric-
functions.html
ROUND (redondear)

SELECT(2.4567,2);

El resultado sería 2.45

TRUNCATE (elimina decimales)

SELECT TRUNCATE(2.3789,1);

El resultado sería 2.3

CEILING (redondear para arriba)

SQL: de lo básico a lo complejo 19

 SELECT CEILING(2.134);

FLOOR (redondear para abajo)

SELECT FLOOR(2.3413);

ABS (muestra el valor absoluto)

SELECT ABS(-5);

RAND (crea valores decimales aleatorios)

Si se quiere que no sea deciman se *100.

SELECT RAND()*100;

Se puede envolver en un TRUNCATE para eliminar los decimales

SELECT TRUNCATE(RAND()*100,0);

Funciones STRING
https://dev.mysql.com/doc/refman/8.0/en/string-
functions.html
LENGTH (muestra la cantidad de caracteres incluye espacios)

SELECT LENGTH ("ejemplo");

UPPER (convierte el texto a mayúscula)

SELECT UPPER ("ejemplo");

SQL: de lo básico a lo complejo 20

 LOWER (convierte el texto a minúscula)

SELECT LOWER ("EJEMPLO");

LTRIM/RTRIM (borrar todos los espacios a la izquierda/derecha de

un texto)

SELECT LTRIM(" EJEMPLO");

SELECT RTRIM("EJEMPLO ");

LEFT (extrae x cantidad de caracteres de una palabra por la

izquierda y luego los muestra)

SELECT LEFT ("ejemplo", 3);

El resultado sería: eje

RIGHT (extrae x cantidad de caracteres de una palabra por la

derecha y luego los muestra)

SELECT RIGHT("ejemplo",3);

El resultado sería: plo

TRIM (quita todos los espacios de más al principio y al final)

SELECT TRIM(" EJEMPLO ");

SUBSTRING (quita caracteres fuera del rango indicado y muestra

el resultado)

SELECT SUBSTRING("ejemplo",2,4);

SQL: de lo básico a lo complejo 21

 En este casi se indica que comienza en 2 y se detiene en 4.El espacio 1 es a la
izquierda de le primera "e".
El resultado sería: jemp

LOCATE (muestra la posición de una letra en una palabra)

SELECT LOCATE("j", "ejemplo");

El resultado sería: 2
Otro ejempo es el siguiente:

SELECT LOCATE("mp", "ejemplo");

SELECT LOCATE("mp", "ejemplo");

REPLACE (reemlaza un caracter o una cadena de caracteres

buscado por uno nuevo)

SELECT REPLACE("ejemplo","jemplo","xample");

El resultado sería: example

CONCAT (une dos cadenas)

SELECT CONCAT("Ejemplo", "SQL")

El resultado sería: EjemploSQL

Si se modifica por CONCAT("Ejemplo"," ","SQL") el resultado sería: Ejemplo SQL
Ejemplo: encuentre el nombre y apellido más largos.

SELECT CONCAT(NOMBRE," ", APELLIDO) AS NOMBRE_COMPLETO,

LENGTH(CONCAT (NOMBRE," ",APELLIDO)) AS LARGO
FROM vendedor
ORDER BY LARGO DESC

SQL: de lo básico a lo complejo 22

 Funciones de Tiempo y Fechas:
https://dev.mysql.com/doc/refman/8.0/en/date-and-
time-functions.html
NOW (muestra fecha y hora)

SELECT NOW();

CURDATE (muestra la fecha actual)

SELECT CURDATE();

CURTIME (muestra la hora actual)

SELECT CURTIME();

YEAR (extrae el año a partir de una fecha dada)

SELECT YEAR(NOW());

MONTH (extrae el número de mes en una fecha dada)

SELECT MONTH(NOW());

DAY (extrae el número de día de una fecha dada)

SELECT DAY(NOW());

HOUR (extrae la hora de una fecha dada)

SQL: de lo básico a lo complejo 23

 SELECT HOUR(NOW());

MINUTE (muestra el minuto de una fecha dada)

SELECT MINUTE(NOW());

SECOND (muestra el segundo de una fecha dada)

SELECT SECOND(NOW(9);

DAYNAME/MONTHNAME (devuelve el nombre de un día de la

semana/mes para una fecha dada)

SELECT DAYNAME(NOW());
SELEC MONTHNAME(NOW());

EXTRACT (extrae una parte de una fecha dada, indicado por su

primer parámetro)

SELECT EXTRACT(DAY FROM NOW());

El resultado sería el número de día. Lo mismo aplica para EXTRACT con MONTH o
YEAR.

IFNULL (devuelve un valor especificado si la expresión resultado

es NULL)

SELECT nombre, IFNULL(ID_gerente,"Gerente") AS Nivel_gerencial

FROM empleados

COALESCE (devuelve el primer valor nulo de una columna y lo

reemplaza por el de otra columna del mismo registro)

SQL: de lo básico a lo complejo 24

 SELECT Nombre, COALESCE(ID_gerente, Nombre, "Gerente") AS gerente_nuevo
FROM empleados
Busca en el ID_gerente, si es NULL pon el Nombre, si ese también es NULL pon "

IF (se cumple una condición u otra)

SELECT venta_empleado, venta, IF(venta>1300,"bono","-") AS bono

FROM ventas;

CASE (se cumplen varias condiciones)

SELECT *, CASE
WHEN venta > 1300 THEN "Bono grande"
WHEN venta > 1000 THEN "Bono medio"
WHEN venta > 500 THEN "Bono pequeño"
ELSE "Ponle ganas"
END AS BONO
FROM ventas;

Se crea una consulta a la que no se le puede hacer referencia luego. Además, si

se usa un “Mayor que” debe de ir en orden descendente. Si es “menor que”, lo
opuesto.

5. Filas, Columnas y Tablas

Insertar una fila - INSERT INTO
Se usa INSERT INTO tabla(nombre_de_columna)

SELECT * FROM ingredientes;

INSERT INTO ingredientes(Ingredientes)
VALUES ("Banana");

SQL: de lo básico a lo complejo 25

 Insertar varias filas en una misma columna - INSERT
INTO

SELECT * FROM ingredientes;

INSERT INTO ingredientes(Ingredientes)
VALUES ("Banana", "Jocote", "Cacao");

Insertar una fila con contenido en varias columnas -

INSERT INTO

SELECT * FROM ingredientes;

INSERT INTO ingredientes(Ingredientes, clave_ingrediente, precio_porcion)
VALUES ("Manzana", "mzn", 5);

Insertar varias filas con contenido en varias columnas

- INSERT INTO

SELECT * FROM ingredientes;

INSERT INTO ingredientes(Ingredientes, clave_ingrediente, precio_porcion)
VALUES ("Champiñon", "cpn", 2),("Queso de cabra", "qdc",7);

Insertar una columna - ALTER TABLE & ADD

ALTER TABLE nombre_tabla

ADD nombre_columna tipo_de_dato;

Modificar/actualizar el contenido de una fila - UPDATE

Se usa UPDATE tabla, SET columna= valor nuevo, otra columna = valor nuevo

UPDATE ingredientes
SET Ingredientes = "Pina", clave_ingrediente = "pin"

SQL: de lo básico a lo complejo 26

 WHERE ID_ingrediente = 5;

Es posible modificar el contenido de varias filas a la vez, sim embargo es

necesario un permiso (EDIT, Preferences, SQL Editor, bajar hasta Safe Updates.
!!!Se debe tener mucho cuidado porque algunos cambios son irreversibles, es
mejor hacer cambios de una fila a la vez o crear un duplicado de la tabla primero.

Duplicar una tabla - CREATE TABLE

CREATE TABLE historico_ventas AS

SELECT * FROM ventas;

En este caso se crea una tabla nueva identica a la tabla ventas.

Luego hay que hacer Refresh en la sección de Schemas para poder ver la
tabla nueva.

Si se le da Click derecho a la tabla nueva en SCHEMAS y luego Truncate se

borran todos los registros, pero se mantiene la estructura de la tabla.

Luego de haber truncado la tabla ya se le pueden agregar datos:

SELECT * FROM datos.historico_ventas;

INSERT INTO historico_ventas

SELECT *
FROM ventas
WHERE venta>1000;

Borrar una fila - DELETE

DELETE FROM ingredientes

SQL: de lo básico a lo complejo 27

 WHERE ID_ingrediente=8;

Se pueden borrar varias filas a la vez

DELETE FROM ingredientes

WHERE ID_ingrediente BETWEEN 15 AND 17;

6. Agregaciones
MAX
Trae el valor máximo de las ventas como Venta_maxima, la venta por empleado y
la fecha.

SELECT MAX(venta) AS Venta_maxima, venta_empleado, Fecha

FROM ventas;

SUM
Muestra la suma de todas las ventas como total_ventas

SELECT SUM(venta) AS total_ventas

FROM ventas;

COUNT
Muestra la cantidad de ventas. COUNT NO CUENTA LOS VALORES "NULL".

SELECT COUNT(venta) AS conteo_ventas

FROM ventas;

COUNT DISTINCT

SQL: de lo básico a lo complejo 28

 Muestra todos los empleados distintos de la columna venta_empleado como
empleados_diferentes.

SELECT COUNT(DISTINCT venta_empelado) AS empleados_diferentes

FROM ventas;

AVERAGE
Muestra el monto promedio de todas las ventas.

SELECT AVG(venta)
FROM ventas;

GROUP BY
Muestra la suma de las ventas para cada local. Si no se pone el GROUP BY solo
muestra el primer valor de los ID (no sirve de nada) y lo mismo pasaría si no se
usan agregaciones, por ejemplo venta en lugar de SUM(venta).

SELECT SUM(venta),ID_local
FROM ventas
GROUP BY ID_local

HAVING
Es un filtro que se usa para sustituir a WHERE cuando se usen agregaciones en
SELECT. Se usa después de un GROUP BY.

SELECT id_local, clave_producto, SUM(venta) AS venta_total

FROM ventas
GROUP BY ID_local, clave_producto
HAVING venta_total > 1500

WITH ROLLUP

SQL: de lo básico a lo complejo 29

 Muestra los subtotales de alguna agrupación.

Por lo general se usa para realizar calculos rápidos en SQL, no se recomienda

para archivos que luego se vana a exportar a Excel, PBI u otros porque crea
valores que general ruido y leugo hay que limpiarlos.

SELECT id_local, SUM(venta) AS venta_total

FROM ventas
GROUP BY id_local WITH ROLLUP

Muestra las ventas totales por local y al final la suma de estas.

Aquí hay otro ejemplo utilizando un segundo elemento en GROUP BY.

SELECT id_local,clave_producto, SUM(venta) AS venta_total

FROM ventas
GROUP BY id_local,clave_producto WITH ROLLUP

Muestra las ventas totales por local desglozada por clave producto y al final la
suma para el local.

7. Atributos de columnas
Atributos de Columna
PK: primary key

NN: not null, si se marca no se permite que hayn valores null. Sirve con PK.

UQ: unique index garantiza que las columnas de PK no tengan valores

duplicados.

B: Is Binary, datos binarios como TREUE/FALSE.

UN: Unsigned Data Type, el valor solo puede ser positivo.

ZF: Zero Fill uprellena los valores con 0 si el tipo de dato es numérico.

SQL: de lo básico a lo complejo 30

 AI: Auto Incremental, valores que aumentan automáticamente en caso de
colocar registros nuevos. Se genera sola. Funciona con PK para crear por
ejemplo IDs de forma automática.

G: Generated Column, no se pueden modificar sus valores manualmente.

8. Vistas
Descripción
Una vista en SQL es una consulta predefinida almacenada en la base de datos que
actúa como una tabla virtual.
Es una representación de los datos de una o más tablas que se puede utilizar y
manipular como si fuera una tabla real, pero en realidad no contiene datos físicos
en sí misma. Las vistas son creadas con una consulta SQL y se almacenan en la
base de datos para ser utilizadas posteriormente.

CREATE VIEW
Cuando se crea una columna calculada solo existe dentro de una consulta. Las
vistas permiten guardar una columna calculada en una tabla para luego poder
llamarla.

CREATE VIEW ventas_empelados AS

SELECT
l.letra_zona,l.telefono,v.venta,v.venta_empleado,e.nombre
FROM local l
LEFT JOIN ventas v
ON l.ID_local = v.ID_local
LEFT JOIN empleados e
ON v.venta_empleado = e.ID_empleado;

Hay que refrescar desde SCHEMA para poder ver la vista, la cual no aparece
en la sección de tablas, sino en la de Views. También se puede hacer una
consulta sencilla con SELECT ventas_empleados.

Para eliminarla se hace click derecho desde Views y Drop view.

SQL: de lo básico a lo complejo 31

 Para modificar una vista o recuperar el código con el que se creó se hace click
derecho desde Views y Alter View.

DROP VIEW con código

DROP VIEW ventas_empleados;

CREATE OR REPLACE VIEW (modificar una VIEW)

En este caso se usa la misma consulta de VIEW, pero se agrega un WHERE
venta>1000;

CREATE OR REPLACE VIEW ventas_empelados AS

SELECT
l.letra_zona,l.telefono,v.venta,v.venta_empleado,e.nombre
FROM local l
LEFT JOIN ventas v
ON l.ID_local = v.ID_local
LEFT JOIN empleados e
ON v.venta_empleado = e.ID_empleado
WHERE venta>1000;

DELETE + VIEW (borra contenido de una vista)

Si se borra contenido de una lista con DELETE también se borra de la tabla de la
que se
hizo la consulta.

DELETE FROM ventas_mayores_800

WHERE venta >1000;

9. Stored Procedures (Procesos

almacenados)

SQL: de lo básico a lo complejo 32

 Descripción
Es código creado en SQL y que se guarda para correrlo varias veces y así
ahorrarse el tiempo.

Se les pueden poner parámetros.

Es reutilizable y se puede compartir con otros usuarios.

Es fácil de modificar, como cualquier query.

Se pueden poner procesos almacenados para evitar que otros accedan a la

tabla y que solo tengan acceso a lo que les sirve.

Disminuye el tráfico de la red:el servidor solo para el nombre del PA, no toda la
query.

CREATE PROCEDURE

DELIMITER $$
CREATE PROCEDURE sp_pizza()
BEGIN
SELECT*
FROM ventas
WHERE clave_producto = "pzz";
END $$

DELIMITER permite crear algo para finalizar el código. En este caso $$ esto
porque después de "pzz" hay un ; lo que confunde a SQL. Al terminar con el SP se
tiene que volver a establecer ; como el delimitador: DELIMITER ;

CALL (llama a un Stored Procedure)

CALL sp_pizza()

También se puede abrir el SP desde la sección de SCHEMAS, Stored Procedures.

Diferencia VIEW y STORE PROCEDURE

SQL: de lo básico a lo complejo 33

 Las vistas son más limitadas, permiten guardar una consulta y mostrarla. Un SP
permite hacer actualizaciones, borrar, crear nuevos datos, ejecutarse a diario para
limpiar datos, entre otros en automático.

Crear un Stored Procedure desde la sección de

SCHEMAS
Click derecho sobre Stored Procedure, Create SP.

Se escribe el nombre y la consulta. El sistema crea y luego elimina el

DELIMITER.

Borrar procesos almacenados

Desde la sección de SCHEMAS, se busca Stored Procedures, click derecho, DROP
PROCEDURE.
Con código sería:

DROP PROCEDURE sp_pizza

Parámetros
Los parámetros permiten que los procedimientos almacenados sean más flexibles
y reutilizables, ya que pueden aceptar diferentes valores cada vez que son
llamados.

Los parámetros se definen en la declaración del procedimiento almacenado y

actúan como variables que se utilizan dentro del cuerpo del procedimiento.

CREATE PROCEDURE 'sp_ventas_producto' (productos VARCHAR(3))

BEGIN
SELECT*
FROM ventas
WHERE clave producto = producto;
END

SQL: de lo básico a lo complejo 34

 -- El SP se puede ejecutar desde la sección de SCHEMAS o por medio de código
CALL sp_ventas_producto("pzz")

Modificar los parámetros de un SP

Desde la sección de SCHEMAS, click derecho al SP que se quiere modificar, Alter
SP.
En este caso se agrega un segundo parámetro:

CREATE DEFINER=`root`@`%` PROCEDURE `sp_ventas_producto`(productos VAR

BEGIN
SELECT*
FROM ventas
WHERE clave_producto = producto AND ID_local = local.usuario;
END

El SP se puede ejecutar desde la sección de SCHEMAS o por medio de código:

CALL sp_ventas_producto("pzz",1);

Parámetros DEFAULT (que se muestre un valor cuando

no se especifica un parámetro)
CREATE DEFINER=`root`@`%` PROCEDURE `sp_ventas_producto`(productos VAR
BEGIN
SELECT*
FROM ventas
WHERE clave_producto = IFNULL(productos,clave_producto) AND ID_local = lo
END

CALL sp_ventas_producto(NULL,1);

Si el valor del parámetro 1(productos) es NULL entonces muestra todos los valores
para el parámetro 2 especificado.
Ahora se agrega un default para el segundo parámetro:

SQL: de lo básico a lo complejo 35

 CREATE DEFINER=`root`@`%` PROCEDURE `sp_ventas_producto`(productos VAR
BEGIN
SELECT*
FROM ventas
WHERE clave_producto = IFNULL(productos,clave_producto) AND ID_local = IF
END

CALL sp_ventas_producto(NULL,NULL);

En este caso cuando los parámetros son NULL, trae las ventas de todos los
productos para todos los locales.
Si se quiere que se muestre un valor por default cuando el valor de un parámetro
es NULL, se hace lo siguiente:

CREATE DEFINER=`root`@`%` PROCEDURE `sp_ventas_producto`(productos VAR

BEGIN
IF productos IS NULL THEN
SET productos = "pzz";
END IF;
SELECT*
FROM ventas
WHERE clave_producto = productos AND ID_local = IFNULL(local_usuario,ID_lo
END

CALL sp_ventas_producto(NULL,NULL);

Muestra las ventas de pizza para todos los locales.

Actualizar tablas con SP

CREATE DEFINER=`root`@`%` PROCEDURE `actualizar_empleado`(para_emplead

BEGIN
UPDATE empleados e
SET

SQL: de lo básico a lo complejo 36

 e.Edad = para_edad,
e.Telefono = para_telefono
WHERE e.ID_empleado = para_empleado;
END

CALL actualizar_empleado("1111222","63","01234567");

Restricciones en SP
En este caso se va a especificar que las edades deben estar entre 18 y 60 años.

CREATE DEFINER=`root`@`%` PROCEDURE `actualizar_empleado`(para_emplead

BEGIN
IF para_edad < 18 OR para_edad > 60 THEN
SIGNAL SQLSTATE "22003"
SET MESSAGE_TEXT = "Edad fuera del Rango";
END IF;
UPDATE empleados e
SET
e.Edad = para_edad,
e.Telefono = para_telefono
WHERE e.ID_empleado = para_empleado;
END

CALL actualizar_empleado("1111222","68","01234567");

Esta línea de código daría un error porque 68 está fuera del rango.
SIGNAL SQLSTATE es una lista con los errores de SQL y sus códigosrespectivos.
Sirve para que cuando una persona cometa el error, este
alerte. Además se incluye el SET MESSAGE_TEXT para personalizar el mensaje.

https://www.ibm.com/docs/en/i/7.4?topic=codes-listing-sqlstate-values

SQL: de lo básico a lo complejo 37

 Parámetro de salida (generan un resultado específico
para una entrada)

CREATE DEFINER=`root`@`%` PROCEDURE `sp_ventas_local`(IN parametro_local_

BEGIN
SELECT
SUM(venta)
INTO
parametro_suma_venta
FROM ventas
WHERE ID_local = parametro_local_id;
END;

IN: se define el nombre del parámetro de entrada y su tipo.

OUT: se define el nombre del parámetro de salida y su tipo.

INTO: los dos parámetros en donde se van a guardar los datos.

El ID_local del SELECT se guarda en el parametro_local_id del INTO.

El SUM(venta) del SELECT se guarda en el parametro_suma_venta del INTO.

Cuando un usuario llama este SP, introduce un número de local, que se asigna
a IN parametro_local_id, el cual se guarda se relaciona a SELECT ID_local y se
guarda en INTO parametro_local_id.

El resultado está relacionado a OUT parametro_suma_venta que a su vez se

relaciona a SELECT SUM(venta) y se guarda en
INTO parametro_suma_venta.

CALL sp_ventas_local(1,0);

Aunque el segundo parámetro es de salida es necesario incluirlo en el CALL. Sin

embargo, ambos parametros deben de crearse como variables primero y ser
ejecutadas.

SET @param_local = 1;
SET @suma_ventas = 0;

SQL: de lo básico a lo complejo 38

 CALL sp_ventas_local(@param_local, @suma_ventas);

Para ver los resultados es necesario llamar a la variable.

SELECT @suma_ventas;

Luego se puede modificar el valor de la variable @param_local=1 para así obtener

los valores correspondientes.

Variables en SP y DECLARE
DECLARE se utiliza para declarar variables locales dentro de un proceso
almacenado. Estas variables locales solo existen dentro del contexto del bloque
en el que se declaran, y su vida útil está limitada a la ejecución del bloque de
código. Una vez que el bloque ha terminado de ejecutarse, las variables locales se
eliminan de la memoria.

CREATE PROCEDURE sp_proceso_mejora()

BEGIN
DECLARE factor_mejora DECIMAL(9,1) DEFAULT 0;
DECLARE ventas_conteo INT;
DECLARE ventas_totales DECIMAL(9,1);
SELECT
COUNT(*),
SUM(venta)
INTO
ventas_conteo,
ventas_totales
FROM ventas;
SET factor_mejora=ventas_totales/ventas_conteo*1.10;
SELECT factor_mejora;
END

CALL SP_proceso_mejora(); ----> Muestra el porcentaje de mejora

SQL: de lo básico a lo complejo 39

 10. Funciones
Descripción
Las funciones son similares a los Stored Procedures pero no se llaman con CALL,
sino se se incluyen desde un SELECT. Además iteran en toda una columna, o sea
que lo resultados se muestran en cada línea. Hay 4 tipos de funciones:

Determinísticas: siempre devuelven el mismo resultado.

Modifica datos SQL: usados para modificar las tablas: UPDATE, INSERT,
DELETE o ALTER.

Lectura de datos SQL: usado para resumir los datos, es decir, hacer
operaciones. No modifica.

No SQL: indica que la rutina no contiene sentencias SQL.

Ejemplo:
Se quiere calcular las ventas objetivos del otro año para diferentes vendedores.
Cada
uno tiene su propio ID. El monto debe ser un 10% mayor al actual.

CREATE FUNCTION fn_mejora_empleado (parametro_empleado VARCHAR(7))

RETURNS INTEGER
READS SQL DATA
BEGIN
DECLARE factor_mejora DECIMAL(9,1) DEFAULT 0;
DECLARE ventas_conteo INT;
DECLARE ventas_total DECIMAL(9,1);

SELECT
COUNT(*),
SUM(venta)
INTO
ventas_conteo,
ventas_total

SQL: de lo básico a lo complejo 40

 FROM ventas
WHERE venta_empleado = parametro_empleado;

SET factor_mejora = ventas_total/ventas_conteo * 1.10;

RETURN factor_mejora;
END

Para ver el resultado se incluye en un SELECT:

SELECT ID_empleado, Nombre, fn_mejora_empleado(ID_empleado) AS Objetivo_v

FROM empleados;

11. TRIGGERS
Descripción
Son como procesos almacenados que se ejecutan automáticamente al insertar
nuevos datos, actualizar datos o eliminar datos.

Ejemplo

DELIMITER $$

CREATE TRIGGER pago_after_insert

AFTER INSERT ON pago_orden
FOR EACH ROW
BEGIN
UPDATE orden
SET balance = balance + NEW.cantidad
WHERE orden = NEW.orden;
END $$

DELIMITER ;

SQL: de lo básico a lo complejo 41

 El comando NEW hace referencia a la última fila insertada previamente en una
tabla.
Luego se agrega un valor a la tabla pago_orden para verificar que funciona:

INSERT INTO pago_orden

VALUES(CURDATE(),499,6792,100);

Luego se verifica que efectivamente el trigger realizó la actualización automática:

SELECT *
FROM proveedores.orden;

SHOW TRIGGERS
Muestra los TRIGGERS existentes

Modificar y borrar TRIGGERS

Si se sabe la ubicación se puede ver desde el SCHEMA, click derecho a el nombre
de la tabla, Maintenance, TRIGGERS.
La siguiente línea de código borra un TRIGGER:

DROP TRIGGER nombre_de_trigger

TRIGGERS COMO AUDITORÍA

Descripción

Es importante crear tablas relacionadas a triggers para registrar los cambios

que se hacen por estos.
Se puede dejar un registro de quién, cuándo y cómo modificaron una tabla.

Ejemplo:
En este ejemplo se tiene una tabla en donde va a quedar registrado cualquier
modificación que se haga en "pago_orden".

SQL: de lo básico a lo complejo 42

 DELIMITER $$

DROP TRIGGER IF EXISTS pago_after_insert;

CREATE TRIGGER pago_after_insert

AFTER INSERT ON pago_orden
FOR EACH ROW

BEGIN
UPDATE orden
SET balance = balance + NEW.cantidad
WHERE orden = New.orden;

INSERT INTO auditoria_pagos

VALUES(NEW.ID_pago,NEW.ORDEN,NEW.FECHA, NEW.Cantidad,"INSERT",
END$$

DELIMITER ;

12. EVENT
Descripción
Es un bloque de código que se ejecuta cada cierto tiempo.Se recomienda que la
primer palabra en el
nombre del Evento haga referencia a la periocidad del mismo.
Se debe verificar que los Eventos estén activos con la siguiente línea de código:

SHOW VARIABLES LIKE "event%";

Si esta OFF se usa lo siguiente:

SET GLOBAL EVENT.scheduler = ON

SQL: de lo básico a lo complejo 43

 Ejemplo

DELIMITER $$

CREATE EVENT anual_borrar_filas_auditoria

ON SCHEDULE
EVERY 1 YEAR STARTS "2023-12-25" ENDS "2026-12-25"

DO BEGIN
DELETE FROM auditoria_pagos
WHERE fecha < NOW()-INTERVAL 1 YEAR;
END $$

DELIMITER ;

El evento anterior comienza el "2023-12-25" y deja de aplicarse el "2026-12-25".

Borra de la tabla auditoria_pagos lo que sea mayor a 1 año con respecto a la fecha
de ejecución del evento.

SHOW EVENTS
Muestra todos los eventos

DROP EVENT IF EXIST nombre_de_evento;

Borra un evento.

13.Transacciones y concurrencia
Descripción
Una transacción es un conjunto de órdenes que se ejecutan formando una
unidad de trabajo, en donde ninguna de ellas puede fallar.

Las transacciones se usan cuando muchas personas acceden a la base de

datos y la modifican, que se puedan meter datos de manera estructurada y
por turnos.

SQL: de lo básico a lo complejo 44

 Las transacciones deben ser ACID:

Atomicidad: son todo o nada.

Consistencia:solo se guardan datos válidos.

Isolated(aisladas): no se afectan entre si.

Durabilidad: los datos escritos no se perderán.

Ejemplo:

SELECT * FROM orden;

START TRANSACTION;

INSERT INTO orden

VALUES (curdate(),9999,51344,"Verdura Mix",150,0);

INSERT INTO pago_orden

VALUES(curdate(),4444,9999,150);

COMMIT;

1. Se inicia una transacción con START TRANSACTION .

2. Se inserta un nuevo registro en la tabla "orden".

3. Se inserta un nuevo registro en la tabla "pago_orden" relacionado con el

registro recién insertado en la tabla "orden".

4. Se confirma la transacción con COMMIT , lo que aplica permanentemente los

cambios realizados en ambas tablas.

Concurrencia
Característica que permite que se puedan ejecutar varias sentencias a la vez en
una base de datos, llevando un orden específico para evitar que se rompa la
integridad de la misma.

SQL: de lo básico a lo complejo 45

 14.Tipos de datos
Descripción
Atributo que indica al ordenador cómo interpretar los datos.

STRING
Candenas de texto. Letras números, Entre otros.

Hay dos tipos:

CHAR:de longitud fija según lo que se especifique.

VARCHAR: hasta 100 caracteres. Cada caracter pesa 1 byte. Caracteres

como chino ocupan 3 bytes.

INTEGER
Solo números enteros. Si se le pone un número como 3.14, solo toma el 3.

Hay dos tipos:

INT: enteros desde -2 billomes hasta 2 billones. 4 bytes.

TINYINT: enteros de -128 a 127. 1 byte.

UNSIGNED TINYINT: enteros de 0 a 255.1 byte.

SMALLINT: -32,768 a 32,767.2 bytes.

Función ZEROFILL: coloca 0 adicionales a un número para dejar un largo

estandar establecido. Por ejemplo si se usa INT 3:

Con ZEROFILL quedaría como 001.

Sin ZEROFILL sería 1.

FLOAT
Decimales.

Son de la forma Decimal(p,e) en dónde:

SQL: de lo básico a lo complejo 46

 p de precisión representa la cantidad total de valores almacenados.

e de escala representa la cantidad de decimales almacenados.

Por ejemplo:123.4567 si se especifica de la forma (5,2) sería 123,45. 5

valores incluyendo 2 decimales.

Booleanos: 0,1 o True/false.

DATE
Es de la forma YYYY-MM-DD (year, month, day).

TIME
Es de la forma HH:MM:SS (hora, minuto segundo).

DATETIME
Fecha y hora. Es de la forma YYYY-MM-DD HH:MM:SS

TIMESTAMP
Fecha y tiempo. Se usa para mantener controles de cuándo se modifica un
registro. Es de
la forma YYYY-MM-DD HH:MM:SS.

YEAR

MONTH

DAY

ENUM

SQL: de lo básico a lo complejo 47

 Es una lista de valores de donde se puede seleccionar (como una lista
validada).No permite
introducir valores que no están dentro de la lista.

ENUM("verde", "blanco", "rojo")

JSON
Descripción
Sirve para almacenar datos no estructurados. Se puede importar a SQL. La
mayoría de datos en la web están en este formato. Es posible tener una tabla y
agregarle una columna en formato JSON para incluir, por ejemplo, la
descripción del producto.

Ejemplo
En este ejemplo se agrega un nuevo producto a la tabla de productos. Se crea
una nueva fila y se asigna el nombre de producto, en este caso "Mix Pack",
clave de producto "MIX".
Para agregar la columna: se va a la tabla en Schemas, opciones, en Column
Name se hace click debajo de la última columna que aparece para poder
agregar otra y luego en Datatype se selecciona JSON.

UPDATE Productos
SET Caracteristicas = '{"dimension":[5,10,20],"productos":["pizza","burrito"],
WHERE productos_id=5;

JSON_EXTRACT
Sirve para extraer datos de JSON.

SELECT productos_id, producto, JSON_EXTRACT(caracteristicas,"$.dimensio

FROM productos;

FUNCIONES JSON

SQL: de lo básico a lo complejo 48

 JSON_OBJECT: evalúa los pares etiqueta-valor y devuelve un objeto
JSON.

JSON_ARRAY: evalúa una lista y devuelve un objeto JSON.

UPDATE productos
SET caracteristicas = JSON_OBJECT("dimension",JSON_ARRAY(10,4,40),"pro
WHERE productos_id = 6;

JSON_SET
Permite insertar o actualizar datos en el objeto JSON.

Por ejemplo, se quiere hacer una corrección, que en lugar de cantidad 3,

sea igual a 4.

UPDATE productos
SET caracteristicas = JSON_SET(caracteristicas,"$.cantidad",4);

JSON_REMOVE

Elimina una o varias etiquetas en un objeto JSON.

UPDATE productos
SET caracteristicas = JSON_REMOVE(caracteristicas,"$.cantidad")

Modificar el contenido de un objeto

UPDATE productos
SET caracteristicas = JSON_SET(caracteristicas,"$.productos",JSON_ARR
WHERE producto_id = 6;

Esta consulta actualiza el registro con "producto_id" igual a 6, agregando

tres elementos al arreglo "productos" dentro de la columna
"caracteristicas" del objeto JSON en la tabla "productos".

SQL: de lo básico a lo complejo 49

 15. Modelando bases de datos
Etapas
1.Entender el negocio: preguntar a stakeholders y usuarios qué información
captan, generan o necesitan. ¿Cómo influyen las variables del negocio (el
proceso para obtener/generar los datos)?

2.Modelo conceptual: se hace con lápiz y papel o LucidChart. Es abstracto,

fácil de entender, con muchos puntos de mejora y solo se ven las entidades
(tablas) y sus conexiones. Sirve para entender qué se va a tener en el modelo y
como se podrían relacionar.

3.Modelo lógico: aquí se definen los atributos (nombres de columnas) y llaves

primarias. Identificar la relación entre llaves primarias y llaves foráneas dentro de
cada tabla. Asignar nombres de columnas amigables con el usuario. Es
independiente a cualquier tipo de programa de bases de datos.

4.Modelo físico: cuando ya se crea el modelo en un programa. Aquí ya se

crean las tablas como tal, ahora son columnas y no atributos. Las columnas
deben tener un nombre compatible con las bases de datos (sin acentos, entre
otros). Se especifica el tipo de dato. Es difícil de mover entre bases de datos (de
SQL a Oracle).

¿Cómo se crea un modelo nuevo?

1.File, New model.En donde dice Phisical Schemas, debajo dice mydb. Click
derecho, Edit Schema, se le cambia el nombre.
2. Add diagram: aquí se agregan las tablas y se hacen las conexiones según se
hizo en el modelo lógico. Además se agregan las columnas y se especifica el tipo
de dato, llaves primarias y foráneas.

Normalización
Serie de reglas que se aplican a las tablas con el objetivo de asegurar
eficiencia,facilitar gestión y evitar redundancias. Hay varias reglas:

SQL: de lo básico a lo complejo 50

 1FN

1.Las columnas tienen un solo valor(por ejemplo guardar 3 teléfonos en

una sola celda).

2.El dominio del atributo no puede cambiar. Si es String se guardan

Strings.

3.Nombre único para cada columna.

4.No importa el orden de los datos.

2FN: se construye a partir de la primera FN.

1. Cumplir con la 1FN.

2. No debe haber dependencia parcial. La dependencia parcial ocurre

cuando un atributo en una tabla depende solo de una parte de la clave
primaria en lugar de la clave completa. Esto puede generar problemas de
redundancia y anomalías en la base de datos, lo que hace que sea menos
eficiente y más difícil de mantener.

3FN: se construye sobre la segunda FN.

Que no exista dependencia transitiva/temporal. Esto significa que no se

puede tener una columna no primaria dependiendo de otra columna no
primaria.

Se puede resolver dividiendo una tabla en varias.

Forward engineering
Toma el modelo físico y crea las tablas. El proceso es el siguiente:
Database,Forward engineering, Stored coneection (seleccionar la conexión),
Next, Next, marcar Export MySQL Table Objects, Next, Next.

Luego se va a SCHEMAS, refresh para ver las tablas.

Sincronizar el modelo de datos

Si se hacen modificaciones desde el modelo físico se debe sincronizar el modelo
para que se actualicen los cambios.

SQL: de lo básico a lo complejo 51

 El proceso es el siguiente:
Database, Synchronize model, Next,Next,Next,Next,Next,Execute, Close.

Reverse engineering
Sirve para cuando se tiene un esquema listo y se quiere convertir en un modelo.

El proceso es el siguiente: Database,Reverse engineering. Luego se modifica a

partir del modelo físico.

Agregar tablas desde código.

CREATE DATABASE IF NOT EXISTS ejemplo_datos;

USE ejemplo_datos;
CREATE TABLE IF NOT EXIST clientes(
cliente_id INT PRIMARY KEY auto_increment,
nombre VARCHAR(30) NOT NULL,
email VARCHAR(100) NOT NULL UNIQUE);

Luego se va a SCHEMAS, refrescar para ver la tabla.

Modificar tablas desde código.

LATER TABLE clientes
ADD ciudad VARCHAR(50) NOT NULL,
MODIFY COLUMN nombre VARCHAR(80) DEFAULT " ",
DROP email,

Esta consulta agrega una nueva columna "ciudad" a la tabla "clientes", modifica la
columna "nombre" cambiando su tamaño y estableciendo un valor
predeterminado, y finalmente elimina la columna "email" de la tabla "clientes".

Crear conexiones con código

CREATE TABLE IF NOT EXISTS compras(

compra_id INT PRIMARY_KEY AUTO_INCREMENT,

SQL: de lo básico a lo complejo 52

 cliente_id INT NOT NULL,
total INT NOT NULL,
FOREIGN KEY fk_clientes_compras (cliente_id)
REFERENCES clientes (cliente_id)
ON UPDATE CASCADE
ON DELETE NO ACTION);

CHARSET y colación
Descripción

CHARSET es el set de símbolos y codificaciones que se van a aceptar en la

base de datos.El default es UTF-8, que acepta caracteres para occidentales.
Para cada CHARSET hay una colación que es el set de reglas para comparar
caracteres en un CHARSET.

SHOW CHARTSET

Muestra todos los CHARSET en el sistema.

Si aparece un _ci en Default collation sisgnifica que no diferencia entre
mayúsculas y minúsculas.
Es importante asegurarse de que haya compatibilidad entre los CHARSETS de
las diferentes tablas, lo cuál tiene mayor importancia cuando se busca obtener
datos de una fuente nueva.

Motores de almacenamiento (Store engine)

Descripción

Sofware que se utiliza para crear, ver o actualizar los datos entre el disco duro
y la memoria ram. El motor que se usa por default en SQL se llama InnoDB.

SHOW ENGINES
Muestra todos los SE disponibles.

ALTER TABLE

SQL: de lo básico a lo complejo 53

 Modifica el SE.

ALTER TABLE clientes

ENGINE = MyISAM;

16. INDEX
Descripción
Sirve para crear una especie de catálogo. Primero se deben cargar las tablas a
SQL.Son especialmente útiles cuando se trabajo con millones de filas.
Básicamente crea tablas fantasma para tener la información disponible más
rápido. Dependen de la memoria RAM.

Ejemplo

CREATE INDEX idx_producto ON ventas_idx (clave_producto);

Crea el índice idx_producto en la tabla ventas_idx filtrando en la columna

(clave_producto).

SHOW INDEXES
Muestra los índices disponibles.

SHOW INDEXES IN ventas_idx;

Esto muestra varios índices, no solo el que se creó. Verificar que Key_name sea
Primary y esté compuesto sobre la llave primaria.

Luego ver Collation, si está organizado de forma ascendente o descendente.

Luego la cardinalidad (cuántos valores diferentes hay o cuántas formas diferentes
de organizarlo hay).

SQL: de lo básico a lo complejo 54

 Index_type muestra cómo se hizo el índice, por lo general BTREE.

EXPLAIN
Muestra los detalles de una consulta.

EXPLAIN SELECT venta_empelado FROM ventas_idx WHERE clave_producto = "c

DROP INDEX
Eliminar un índice.

DROP INDEX idx_producto ON ventas_idx;

INDEX con Texto

CHAR, VARCHAR, BLOB...Los STRING necesitan mas bytes, si se hace un index
muy pesado va a durar igual o más que una consulta normal, por lo que ni tendría
sentido hacerla. Se puede hacer un índice con una cantidad
determinada de caracteres. Por ejemplo los primeros 3 caracteres de un apellido.
Se debe considerar cuántos caracteres son necesario para crear un índice que no
sea muy pesado pero que cumpla su función.
El procedimiento sería el siguiente:
Averiguar cuántos elementos diferentes hay. Luego ir viendo con cuántos
caracteres se logra llegar a un número que se acerque.

SELECT COUNT(DISTINCT apellido) FROM empleados;

Muestra que hay 10 apellidos diferentes.

SELECT COUNT(DISTINCT LEFT (apellido,1)) FROM empleados;

Muestra cuántos diferentes hay si solo se considera el primera caracter. El result

SQL: de lo básico a lo complejo 55

 SELECT COUNT(DISTINCT LEFT (apellido,2)) FROM empleados;

En este caso el resultado es: 10.

Cuando se está satisfecho con el resultado se crea el index. Luego se puede
verificar con EXPLAIN cuál es su eficiencia.

FULLTEXT INDEX
Indexa textos enteros como descripción de un producto, entre otros.

17. Permisos y privilegios de usuarios.

Dar permisos a usuarios
El siguiente código crea un usuario que solo puede acceder con la contraseña
asignada.

CREATE USER rodrigo IDENTIFIED BY "ABCD1234"

El siguiente código crea un usuario que solo puede acceder desde esa dirección
IP. También se puede hacer con un dominio en particular cambiando el IP por un
dominio: [email protected]

CREATE USER [email protected]

Administración de privilegios y usuarios

El siguiente código muestra todos los usuarios disponibles. ROOT es el usuario
propio. Los que dicen Localhost en la columna de Host solo pueden acceder a la
base de datos desde esa computadora. Aquí también se pueden ver los privilegios
de los usuarios.

SQL: de lo básico a lo complejo 56

 SELECT * FROM mysql.USER.

Para modificar a los usuarios y privilegios se va a la pestaña de

Administración, junto a la de Schemas. Luego usuarios y privilegios, se
selecciona el usuario que se quiere modificar. Aquí hay varias pestañas:

Login: se puede forzar al usuario a que cambie la contraseña con Expire

password.

Administrative roles: DBA tiene todos los permisos. Se puede elegir un rol
predefinido o customizar uno haciendo click en la columna de la derecha.

Schema privileges: aquí se otorgan privilegios sobre un schema.

Los privilegios que se crean en Administrative roles son sobre todos

los Schemas, mientras que los que se crean en Schema privileges solo
sobre el que se especifica.

Para quitar los privilegios se hace click en Revoke provileges.

SQL: de lo básico a lo complejo 57