diff --git a/.obsidian/graph.json b/.obsidian/graph.json index 7e86a65..2099b06 100644 --- a/.obsidian/graph.json +++ b/.obsidian/graph.json @@ -88,6 +88,6 @@ "repelStrength": 10, "linkStrength": 1, "linkDistance": 250, - "scale": 0.08233250397982278, + "scale": 0.2778722009319019, "close": true } \ No newline at end of file diff --git a/.obsidian/plugins/languagetool/data.json b/.obsidian/plugins/languagetool/data.json index cf1d9f0..6e0a03a 100644 --- a/.obsidian/plugins/languagetool/data.json +++ b/.obsidian/plugins/languagetool/data.json @@ -21,5 +21,5 @@ "pickyMode": false, "longCheckNotification": true, "staticLanguage": "es-ES", - "disabledRules": "AGREEMENT_POSTPONED_ADJ" + "disabledRules": "AGREEMENT_POSTPONED_ADJ,WRONG_IMPERATIVE" } \ No newline at end of file diff --git a/.obsidian/workspace.json b/.obsidian/workspace.json index f71aad7..75d9501 100644 --- a/.obsidian/workspace.json +++ b/.obsidian/workspace.json @@ -4,35 +4,21 @@ "type": "split", "children": [ { - "id": "1abce41154c71bfc", + "id": "fad51cc483fae111", "type": "tabs", "children": [ { - "id": "34eecf2b06cedd2e", + "id": "f680d743f846f5b9", "type": "leaf", "state": { "type": "markdown", "state": { - "file": "BDD/SQL/Notas para clase.md", + "file": "BDD/SQL/Apuntes generales de SQL.md", "mode": "source", "source": false }, "icon": "lucide-file", - "title": "Notas para clase" - } - }, - { - "id": "e7ba4197370c55cb", - "type": "leaf", - "state": { - "type": "markdown", - "state": { - "file": "BDD/SQL/Tecnicismos/Tipos de datos.md", - "mode": "source", - "source": false - }, - "icon": "lucide-file", - "title": "Tipos de datos" + "title": "Apuntes generales de SQL" } } ] @@ -92,7 +78,8 @@ } ], "direction": "horizontal", - "width": 248.50260543823242 + "width": 248.50260543823242, + "collapsed": true }, "right": { "id": "519d5773673c1040", @@ -191,13 +178,13 @@ "state": { "type": "outline", "state": { - "file": "BDD/SQL/Notas para clase.md", + "file": "BDD/SQL/Apuntes generales de SQL.md", "followCursor": false, "showSearch": false, "searchQuery": "" }, "icon": "lucide-list", - "title": "Esquema de Notas para clase" + "title": "Esquema de Apuntes generales de SQL" } } ], @@ -222,7 +209,7 @@ } ], "direction": "horizontal", - "width": 480.5 + "width": 388.5 }, "left-ribbon": { "hiddenItems": { @@ -236,10 +223,13 @@ "obsidian-git:Open Git source control": false } }, - "active": "34eecf2b06cedd2e", + "active": "f680d743f846f5b9", "lastOpenFiles": [ "BDD/SQL/Tecnicismos/Tipos de datos.md", - "BDD/SQL/Notas para clase.md", + "BDD/SQL/Apuntes generales de SQL.md", + "Imagenes/SQL/Mezcla-cartesiana_(CROSS_JOIN).png", + "Imagenes/SQL", + "Imagenes", "BDD/SQL/Uso general/Importación y exportación de base de datos.md", "BDD/SQL/SQL.md", "BDD/SQL/Uso general", @@ -271,9 +261,6 @@ "Servidores/M5/M5 - ASIX.md", "Documentación personal/Mecanica de Unix/1. Bash Scripting Avanzado/Patrones de diseño en Bash.md", "Documentación personal/Mecanica de Unix/1. Bash Scripting Avanzado/Procesos hijos y paralelismo.md", - "conflict-files-obsidian-git.md", - "Programación/PHP/PHP", - "Documentación personal/Mecanica de Unix/Sin nombre", "Documentación personal/Seguridad-Informatica/Vista General 1.canvas", "Documentación personal/Seguridad-Informatica/1_Imagenes/tools/software/specops.svg", "Documentación personal/Seguridad-Informatica/1_Imagenes/tools/software/satan.png", @@ -283,7 +270,6 @@ "Documentación personal/Seguridad-Informatica/1_Imagenes/tools/hardware/usbkiller.jpg", "Documentación personal/Seguridad-Informatica/1_Imagenes/tools/hardware/rubberducky.png", "Documentación personal/Seguridad-Informatica/1_Imagenes/tools/hardware/pico_tpm_sniffer.webp", - "Documentación personal/Seguridad-Informatica/1_Imagenes/tools/hardware/omgcable.webp", - "Documentación personal/Seguridad-Informatica/1_Imagenes/tools/hardware/Flipper Zero.jpg" + "Documentación personal/Seguridad-Informatica/1_Imagenes/tools/hardware/omgcable.webp" ] } \ No newline at end of file diff --git a/BDD/SQL/Apuntes generales de SQL.md b/BDD/SQL/Apuntes generales de SQL.md new file mode 100644 index 0000000..be52bd0 --- /dev/null +++ b/BDD/SQL/Apuntes generales de SQL.md @@ -0,0 +1,595 @@ +--- + +--- +#SQL-ASIX - Structured Query Language +Proveniente de [[SQL]] +- Autor: [Lil_Carpi](https://github.com/Lil-Carpi) +- Fecha de creación: 13-14/12/2025 +--- +```table-of-contents +``` + +--- +#### Video de referencia: +![Aprende SQL](https://youtu.be/uUdKAYl-F7g) +[Aprende SQL](https://youtu.be/uUdKAYl-F7g) + +--- +## Notas a tener en cuenta +- TODOS los comandos terminan en `;`. +- Para hacer un UPDATE y DELETE, se recomienda usar la PK(`id`) para evitar errores, pero no es obligatorio. +- Todo lo que sale aquí va orientado para MariaDB por terminal, aunque sirve igual para MySQL Workbench, ya que los comandos son los mismos. +- Los ejemplos de este documento son simples, por lo que se usan VARCHAR y INT. Por favor, usad datos correspondientes indicados en [[Tipos de datos]]. +- `user` Es una palabra reservada. NO LA USÉIS NUNCA POR USAR. En este caso, están porque facilita el entendimiento y la simplificación. En caso de tener que crear una tabla de usuarios, usad algo como `allusers` o similar, pero NUNCA `user`. +- La sensibilidad a las mayúsculas y minúsculas en MariaDB depende del `collation`. Normalmente, es **case-insensitive**, PERO NO SIEMPRE. +- En producción, el `SELECT *` se ha de listar columnas especificas para evitar problemas de rendimientro y cambios de esquema. +### Tipos de datos +- **INT (INTEGER)**: Números enteros. +- **Float**: Decimales. Cuidado con los errores de precisión. +- **Varchar**: Strings o letras. +- Es recomendable usar mas tipos de datos. +Más información en [[Tipos de datos]] + +![[Tipos de datos]] + +--- +# Bases de datos +## Creación de base de datos: + +```SQL +CREATE DATABASE nombre; +``` + +--- +Ver bases de datos + +```SQL +SHOW DATABASES; +``` + +--- +### Seleccionar base de datos +```SQL +USE basededatos; +``` + +--- +### Comentarios +```SQL +-- Cualquier cosa que sea escrita despues de "--" será ignorado. +``` +--- +### Crear tablas: +```SQL +CREATE TABLE animales ( + id INT NOT NULL AUTO_INCREMENT, + tipo VARCHAR(255) DEFAULT NULL, + estado VARCHAR(255) DEFAULT NULL, + PRIMARY KEY (id) +); +``` +> Entre paréntesis se colocan los datos que se van a almacenar en la tabla. +> Es recomendable separarlos entre espacios y seleccionar el tipo de dato que se va a usar con esa sección. También, se ha de seleccionar la clave primaria e indicarla entre paréntesis. + + +--- +### Insertar datos en tablas: +```SQL +INSERT INTO animales (tipo, estado) VALUES ('Chanchito', 'Feliz'); +``` +> De la tabla `animales`, se le insertan a las columnas `tipo` y `estado` los valores `'Chanchito'` y `'Feliz'`, en ese orden. + + +--- +### Modificación de tablas: +```SQL +ALTER TABLE animales MODIFY COLUMN id INT NOT NULL AUTO_INCREMENT; +``` +> Caso hipotético en el cual la tabla que hemos creado antes no ha tenido la variable `AUTO_INCREMENT` desde un inicio. +> Nota: Se ha de indicar de nuevo el tipo de valor que se le da a la columna `id`, en este caso, `INT`. + +--- +#### Renombrar tablas +```SQL +RENAME TABLE user TO users; +``` +>Renombra la tabla user a users + +--- +### Listar elementos de una tabla +```SQL +SELECT * FROM animales; +``` +> Lista TODAS las columnas de la tabla animales + +```SQL +SELECT * FROM ANIMALES WHERE ID = 1; +``` +> Lista todas las columnas de la tabla animales donde el ID sea 1 + +```SQL +SELECT * FROM animales WHERE estado = 'Feliz'; +``` +> Lista todas las columnas de la tabla animales donde el estado sea 'Feliz' +> Nota: Los strings se pasan entre comillas simples (`''`). + +```SQL +SELECT * FROM animales WHERE estado = 'Feliz' AND tipo = 'Chanchito'; +``` +>Lista todas las columnas de la tabla animales donde el estado sea 'Feliz' Y tipo sea 'Chanchito'. +> Nota: También se puede usar la variable `OR`. + +También podemos hacer selecciones con condiciones más, menos, igual, etc: +```SQL +SELECT * FROM users WHERE edad > 20; +``` +> Se puede cambiar el `>` por `<`, `>=`, `<=` y `!=`. + +Se pueden filtrar también por strings de datos: +```SQL +SELECT * FROM users WHERE email = 'Antonio@fulano.com'; +``` +> Lista todas las columnas de la tabla users donde el email sea ' Antonio@fulano.com' +#### `BETWEEN` +También se le pueden buscar ENTRE dos valores: +```SQL +SELECT * FROM users WHERE edad BETWEEN 15 and 30; +``` +>Lista todas las columnas de la tabla users donde la edad se encuentre entre 15 y 30. +#### `LIKE` +Podemos buscar por valores que "se parece a", con los `%%`: +```SQL +SELECT * FROM users WHERE email LIKE '%gmail%'; +``` +> Lista todas las columnas de la tabla users donde el email se parezca a ' `%gmail%`'. +> Nota: En este caso, lo único que busca va a ser el valor '`gmail`'. Todo lo que se encuentre alrededor de ese valor será ignorado. También podemos hacer búsquedas como '`fulano%`', que sirve cuando sabemos el nombre del usuario, pero no sabemos que apellido tiene. +> Las búsquedas con `%` al inicio, no usan índices. + +#### `ORDER BY` +Se pueden ordenar las consultas por orden ASCENDENTE (`ASC`) y DESCENDENTE (`DESC`): +```SQL +SELECT * FROM users ORDER BY edad ASC; +-- TAMBIEN +SELECT * FROM users ORDER BY edad DESC; +``` + + +#### `max()` y `min()` +Las funciones `max()` y `min()` nos permiten filtrar por la cantidad máxima y mínima entre valores de INT: +```SQL +SELECT max(edad) AS mayor FROM users; +-- Tambien +SELECT min(edad) AS menor FROM users; +``` +> +> Nota: `AS` Se utiliza para dar nombre a la consulta que estamos dando. + + +#### Listar columnas específicas +Podemos filtrar directamente por columnas que nos interesen ver: +```SQL +SELECT id, name FROM users; +``` +> Lista la columna id y name de la tabla users. + + +#### Listar con aliases (`AS`): +En caso de que tengamos un nombre de una columna que queramos ver con otro nombre sin modificarlo, podemos usar `AS`: +```SQL +SELECT id, name AS nombre FROM users; +``` +> Lista la columna id y name como nombre de la tabla users. +> Nota: Las PRIMARY KEYS son inmutables ante esta condición. + +--- +### Update de registros + +```SQL +UPDATE animales SET estado = 'Feliz' WHERE id = 3; +``` +> Actualiza la tabla animales y pon el estado `'Feliz'` al registro que tenga un `id` de 3. +> Nota: Para hacer un UPDATE y DELETE, se ha de indicar el `id` de lo que se va a borrar o actualizar, aunque no es obligatorio. Se recomienda usar condiciones especificas (normalmente la PK) para evitar modificar/borrar múltiples filas por error. + +--- +### Borrar registros + +```SQL +DELETE FROM animales WHERE id = 3; +``` +> Borra el registro de la tabla animales en donde el `id` sea 3. +> Nota: Para hacer un UPDATE y DELETE, se ha de indicar el `id` de lo que se va a borrar o actualizar, aunque no es obligatorio.Se recomienda usar condiciones especificas (normalmente la PK) para evitar modificar/borrar múltiples filas por error. + + +--- +### `LIMIT` +```SQL +SELECT * FROM users LIMIT 2; +``` +> Lista todas las columnas de la tabla users y devuelve las primeras 2 líneas que encuentres. +> Nota: Se pueden cambiar por la cantidad de líneas que queramos ver. + +--- +## Joins (Relacionar tablas, conocido como Llaves Foraneas) + +Tengo una tabla, la cual es: +```SQL +MariaDB [empresa]> SELECT * FROM users; ++----+---------+------+------------------+ +| id | name | edad | email | ++----+---------+------+------------------+ +| 1 | Juan | 25 | juan@juan.com | +| 2 | Alberto | 19 | alberto@juan.com | +| 3 | Leyre | 22 | Leyre@juan.com | +| 4 | Antonio | 52 | Antonio@juan.com | +| 5 | Ariel | 31 | Ariel@juan.com | ++----+---------+------+------------------+ +``` + +Y quiero hacer un join de una tabla, la cual relacione él id de cada usuario con la creación de un producto en otra tabla llamada `products`. Se ha de hacer: +```SQL +CREATE TABLE products( + id INT NOT NULL AUTO_INCREMENT, + name VARCHAR(50) NOT NULL, + created_by INT NOT NULL, + marca VARCHAR(50) NOT NULL, + PRIMARY KEY(id), + FOREIGN KEY(created_by) REFERENCES `users`(id) +) ENGINE=InnoDB; +``` +> En la parte de la llave foranea, describimos: +> La llave foranea será la columna `created_by` y su referencia se encuentra en la tabla `users` y la columna es `id`. +> Nota: Hay que usar BACKTICKS para seleccionar la tabla con nombres especiales, en este caso, `user` es un nombre especial en MariaDB. En una situación real, NO UTILICEIS `user` COMO NOMBRE DE TABLA. Tambien, el `ENGINE` es IMPORTANTE ponerlo. Sin `ENGINE`, no hay FK. + +--- +#### Insercion de multiples datos con un solo `INSERT` +Ahora, podemos añadir productos en la tabla products creadas por los usuarios de la tabla users: +```SQL +INSERT INTO products (name, created_by, marca) +VALUES + ('ipad', 1, 'apple'), + ('iphone', 1, 'apple'), + ('watch', 2, 'apple'), + ('macbook', 1, 'apple'), + ('imac', 3, 'apple'), + ('ipad mini', 2, 'apple'); +``` +> Inserta a la tabla productos dentro de las columnas name, created_by y marca... + +Resultado: +```SQL +MariaDB [empresa]> SELECT * FROM products; ++----+-----------+------------+-------+ +| id | name | created_by | marca | ++----+-----------+------------+-------+ +| 1 | ipad | 1 | apple | +| 2 | iphone | 1 | apple | +| 3 | watch | 2 | apple | +| 4 | macbook | 1 | apple | +| 5 | imac | 3 | apple | +| 6 | ipad mini | 2 | apple | ++----+-----------+------------+-------+ +``` + +--- +## LEFT JOIN +Trae todos los registros dentro de la tabla de usuarios. En el caso de que se encuentren registros que se encuentren dentro de la tabla de productos que hayan sido creados por los usuarios que se encuentren en la tabla usuarios, aparecerán dentro de la consulta. En caso de que salgan usuarios que no hayan creado productos en la tabla de productos, simplemente márcamelos como `null`. + + +```SQL +SELECT u.id, u.email, p.name FROM users u LEFT JOIN products p ON u.id = p.created_by; +``` +> Selecciona de la tabla de usuario, reconócelo con el alias `u`, y tráeme las columnas de id y email. Ahora, haz un LEFT JOIN con la tabla users como principal de producto, reconócelo como `p`, y tráeme la columna name y junta las columnas id de la tabla de usuario y created_by de la tabla de productos. + +Resultado: +```SQL ++----+------------------+-----------+ +| id | email | name | ++----+------------------+-----------+ +| 1 | juan@juan.com | ipad | +| 1 | juan@juan.com | iphone | +| 2 | alberto@juan.com | watch | +| 1 | juan@juan.com | macbook | +| 3 | Leyre@juan.com | imac | +| 2 | alberto@juan.com | ipad mini | +| 4 | Antonio@juan.com | NULL | +| 5 | Ariel@juan.com | NULL | ++----+------------------+-----------+ +``` + +--- +## RIGHT JOIN +Mismo que `LEFT JOIN`, pero al revés. +Nos trae el producto y en caso de que exista, nos va a traer un usuario asociado. +```SQL +SELECT u.id, u.email, p.name FROM users u RIGHT JOIN products p ON u.id = p.created_by; +``` +> Selecciona de la tabla de usuario, reconócelo con el alias `u`, y tráeme las columnas de id y email. Ahora, haz un RIGHT JOIN con la tabla de producto, reconócelo como `p`, y tráeme la columna name y junta las columnas id de la tabla de usuario y created_by de la tabla de productos. + +Resultado: +```SQL ++------+------------------+-----------+ +| id | email | name | ++------+------------------+-----------+ +| 1 | juan@juan.com | ipad | +| 1 | juan@juan.com | iphone | +| 2 | alberto@juan.com | watch | +| 1 | juan@juan.com | macbook | +| 3 | Leyre@juan.com | imac | +| 2 | alberto@juan.com | ipad mini | ++------+------------------+-----------+ +``` + +--- +## INNER JOIN +Nos trae tanto usuarios como productos, pero siempre y cuando estos dos puedan ser asociados entre sí. +```SQL +SELECT u.id, u.email, p.name FROM users u INNER JOIN products p ON u.id = p.created_by; +``` +> Selecciona de la tabla de usuario, reconócelo con el alias `u`, y tráeme las columnas de id y email. Ahora, haz un INNER JOIN con la tabla de producto, reconócelo como `p`, y tráeme la columna name y junta las columnas id de la tabla de usuario y created_by de la tabla de productos. + +Resultado: +```SQL ++----+------------------+-----------+ +| id | email | name | ++----+------------------+-----------+ +| 1 | juan@juan.com | ipad | +| 1 | juan@juan.com | iphone | +| 2 | alberto@juan.com | watch | +| 1 | juan@juan.com | macbook | +| 3 | Leyre@juan.com | imac | +| 2 | alberto@juan.com | ipad mini | ++----+------------------+-----------+ +``` + +--- +## CROSS JOIN +Devuelve el producto cartesiano entre dos tablas. +Básicamente: +![[Mezcla-cartesiana_(CROSS_JOIN).png]] + +```SQL +SELECT u.id, u.name, p.id, p.name FROM users u CROSS JOIN products p; +``` +>Nota: No es recomendado hacerlo, y si se ha de hacerlo, hay que tener cuidado por la cantidad insana de datos que nos puede escupir. Puede bloquear la BD si los datos que escupen son grandes, así que, repito, MUCHO CUIDADO. + +Resultado: +```SQL ++----+---------+----+-----------+ +| id | name | id | name | ++----+---------+----+-----------+ +| 1 | Juan | 1 | ipad | +| 2 | Alberto | 1 | ipad | +| 3 | Leyre | 1 | ipad | +| 4 | Antonio | 1 | ipad | +| 5 | Ariel | 1 | ipad | +| 1 | Juan | 2 | iphone | +| 2 | Alberto | 2 | iphone | +| 3 | Leyre | 2 | iphone | +| 4 | Antonio | 2 | iphone | +| 5 | Ariel | 2 | iphone | +| 1 | Juan | 3 | watch | +| 2 | Alberto | 3 | watch | +| 3 | Leyre | 3 | watch | +| 4 | Antonio | 3 | watch | +| 5 | Ariel | 3 | watch | +| 1 | Juan | 4 | macbook | +| 2 | Alberto | 4 | macbook | +| 3 | Leyre | 4 | macbook | +| 4 | Antonio | 4 | macbook | +| 5 | Ariel | 4 | macbook | +| 1 | Juan | 5 | imac | +| 2 | Alberto | 5 | imac | +| 3 | Leyre | 5 | imac | +| 4 | Antonio | 5 | imac | +| 5 | Ariel | 5 | imac | +| 1 | Juan | 6 | ipad mini | +| 2 | Alberto | 6 | ipad mini | +| 3 | Leyre | 6 | ipad mini | +| 4 | Antonio | 6 | ipad mini | +| 5 | Ariel | 6 | ipad mini | ++----+---------+----+-----------+ +``` + +--- +### Esquema de todos los JOIN: +- **LEFT**: Usuarios aunque no tengan producto. +- **INNER**: Solo relaciones validas. +- **RIGHT**: Casi nunca se usa en práctica. + +--- +## GROUP BY +Se utilizan con instrucciones que, por lo general, tienden a agrupar elementos. + +```SQL +SELECT count(id), marca FROM products GROUP BY marca; +``` +> Lista de la tabla products la cantidad de productos de las marcas que existan + +Resultado: +```SQL ++-----------+-------+ +| count(id) | marca | ++-----------+-------+ +| 6 | apple | ++-----------+-------+ +``` + +También podemos hacer lo mismo mezclándolo con un LEFT JOIN con la tabla de usuarios, donde la tabla primaria será la tabla de products: +```SQL +SELECT count(p.id), u.name FROM products p LEFT JOIN users u on u.id = p.created_by GROUP BY p.created_by; +``` + +Resultado: +```SQL ++-------------+---------+ +| count(p.id) | name | ++-------------+---------+ +| 3 | Juan | +| 2 | Alberto | +| 1 | Leyre | ++-------------+---------+ +``` + + +### `HAVING` +Podemos añadir condiciones. Por ejemplo, que el conteo sea mayor a 2: +```SQL +SELECT count(p.id), u.name FROM products p LEFT JOIN users u on u.id = p.created_by GROUP BY p.created_by HAVING count(p.id) >= 2; +``` + +Resultado: +```SQL ++-------------+---------+ +| count(p.id) | name | ++-------------+---------+ +| 3 | Juan | +| 2 | Alberto | ++-------------+---------+ +``` + +--- +## `DROP` +Sirve para eliminar tablas enteras. +```SQL +DROP TABLE products; +``` +> Elimina la tabla de products. +> Nota: ¡CUIDADO CON ESTO! ¡LOS CAMBIOS SON IRREVERSIBLES! + +--- +## `ON DELETE` / `ON UPDATE` +Se utilizan en **llaves foráneas** para definir que ocurre cuando el registro referenciado cambia o se elimina. +```SQL +FOREIGN KEY (created_by) REFERENCES users(id) +ON DELETE +ON UPDATE +``` +> Nota: Si NO se especifica nada, el comportamiento por defecto suele ser `RESTRICT`. + +--- +### `ON DELETE` +Define qué pasa cuando se elimina un registro de la tabla padre. +```SQL +ON DELETE RESTRICT --Restrict por defecto. +``` +> No permite borrar el registro padre si hay hijos asociados. Es la opción más segura. + +Ejemplo: +- No se puede borrar un usuario si tiene productos creados. +Uso recomendado: +- Datos críticos. +- Integridad estricta. +- Producción. + +--- +### `CASCADE` +Al borrar el padre, se borran automáticamente los hijos. Es peligroso si no sabes lo que estás haciendo. CUIDADO CON ESTO. +```SQL +ON DELETE CASCADE +``` + +Ejemplo: +- Borras un usuario -> Se borran todos sus productos. +Usos: +- Datos temporales +- Relaciones dependientes al 100% + +>[!Warning] +>Un `DELETE` mal hecho PUEDE BORRAR MEDIA BASE DE DATOS. + +--- +### `SET NULL` +Al borrar el padre, la FK del hijo pasa a `null`. La columna **DEBE PERMITIR `NULL`**. +```SQL +ON DELETE SET NULL +``` + +Ejemplo: +- El producto sigue existiendo, pero ya no tiene creador. +Usos: +- Históricos +- Logs +- Datos que deben conservarse. + +--- +### `NO ACTION` +En MariaDB/MySQL se comporta igual que `RESTRICT` (aunque internamente SQL define `NO ACTION`). Existe por la compatibilidad con SQL. +```SQL +ON DELETE NO ACTION +``` + +Usos: +- En MariaDB, ninguno xd. + +--- +## `ON UPDATE` +Define qué pasa si cambia el valor de la **clave primaria referenciada**. Cambiar un PK en producción **NO es buena practica**, aunque exista el `ON UPDATE CASCADE`. + +### `CASCADE` +Si cambia el `id` del padre, se actualiza el de los hijos. Es poco común, pero es correcto. +```SQL +ON UPDATE CASCADE +``` + +Ejemplo: +- Cambia el id de un usuario -> se actualiza en la tabla products. + +--- +### `RESTRICT`/`NO ACTION` +Impide cambiar la PK si hay relaciones. +```SQL +ON UPDATE RESTRICT +``` + +Uso: +- Lo normal en producción. + +--- +### `SET NULL` +Si cambia la PK, la FK pasa a NULL. Esto es muy raro de ver en la práctica. +```SQL +ON UPDATE SET NULL +``` + +--- +## Ejemplo realista +```SQL +CREATE TABLE products ( + id INT NOT NULL AUTO_INCREMENT, + name VARCHAR(50) NOT NULL, + created_by INT NULL, + marca VARCHAR(50) NOT NULL, + PRIMARY KEY(id), + FOREIGN KEY (created_by) REFERENCES users(id) + ON DELETE SET NULL + ON UPDATE CASCADE +) ENGINE=InnoDB; +``` + +Explicación: +- Si se borra el usuario -> el producto se conserva +- Si cambia el id -> se actualiza automáticamente. + +--- +### Ejemplo ESTRICTO +```SQL +FOREIGN KEY (created_by) REFERENCES users(id) +ON DELETE RESTRICT +ON UPDATE RESTRICT +``` + +Explicación: +- En este caso, no se borra ni se cambia nada sin limpiar antes dependencias. +- Es lo ideal para los sistemas serios, como en producción. + +--- +## Resumen rápido +- `RESTRICT`: Seguridad +- `CASCADE`: Automatismo (peligroso) +- `SET NULL`: Conservar datos +- `NO ACTION`: Igual que `RESTRICT` en MariaDB + +>[!note] +>Si no sabes qué usar, `RESTRICT`. +>Si usas `CASCADE`, es porque sabes lo que haces y lo has pensado dos veces. + diff --git a/BDD/SQL/Notas para clase.md b/BDD/SQL/Notas para clase.md deleted file mode 100644 index 661ab58..0000000 --- a/BDD/SQL/Notas para clase.md +++ /dev/null @@ -1,115 +0,0 @@ ---- - ---- - ---- -#### Video de referencia: -![Aprende SQL](https://youtu.be/uUdKAYl-F7g) -[Aprende SQL](https://youtu.be/uUdKAYl-F7g) - ---- -## Notas a tener en cuenta -TODOS los comandos terminan en `;`. -### Tipos de datos -- **INT (INTEGER)**: Números enteros. -- **Float**: Decimales -- **Varchar**: Strings o letras. -Más información en [[Tipos de datos]] - -![[Tipos de datos]] - ---- -# Bases de datos -## Creación de base de datos: - -```SQL -CREATE DATABASE nombre; -``` - ---- -Ver bases de datos - -```SQL -SHOW DATABASES; -``` - ---- -### Seleccionar base de datos -```SQL -USE basededatos; -``` - ---- -### Comentarios -```SQL --- Cualquier cosa que sea escrita despues de "--" será ignorado. -``` ---- -### Crear tablas: -```SQL -CREATE TABLE animales ( - id INT NOT NULL AUTO_INCREMENT, - tipo VARCHAR(255) DEFAULT NULL, - estado VARCHAR(255) DEFAULT NULL, - PRIMARY KEY (id) -); -``` -> Entre paréntesis se colocan los datos que se van a almacenar en la tabla. -> Es recomendable separarlos entre espacios y seleccionar el tipo de dato que se va a usar con esa sección. También, se ha de seleccionar la clave primaria e indicarla entre paréntesis. - - ---- -### Insertar datos en tablas: -```SQL -INSERT INTO animales (tipo, estado) VALUES ('Chanchito', 'FELIZ'); -``` -> De la tabla `animales`, se le insertan a las columnas `tipo` y `estado` los valores `'Chanchito'` y `'Feliz'`, en ese orden. - - ---- -### Modificación de tablas: -```SQL -ALTER TABLE animales MODIFY COLUMN id INT AUTO_INCREMENT; -``` -> Caso hipotético en el cual la tabla que hemos creado antes no ha tenido la variable `AUTO_INCREMENT` desde un inicio. -> Nota: Se ha de indicar de nuevo el tipo de valor que se le da a la columna `id`, en este caso, `INT`. - ---- -### Listar elementos de una tabla -```SQL -SELECT * FROM animales; -``` -> Lista TODAS las columnas de la tabla animales - -```SQL -SELECT * FROM ANIMALES WHERE ID = 1; -``` -> Lista todas las columnas de la tabla animales donde el ID sea 1 - -```SQL -SELECT * FROM animales WHERE estado = 'Feliz'; -``` -> Lista todas las columnas de la tabla animales donde el estado sea 'feliz' -> Nota: Los strings se pasan entre comillas simples (`''`). - -```SQL -SELECT * FROM animales WHERE estado = 'Feliz' AND tipo = 'Chanchito'; -``` ->Lista todas las columnas de la tabla animales donde el estado sea 'Feliz' Y tipo sea 'Chanchito'. -> Nota: También se puede usar la variable `OR`. - ---- -### Update de registros - -```SQL -UPDATE animales SET estado = 'Feliz' WHERE id = 3; -``` -> Actualiza la tabla animales y pon el estado `'Feliz'` al registro que tenga un `id` de 3. - ---- -### Borrar registros - -```SQL -DELETE FROM animales WHERE estado = 'Feliz'; -``` - diff --git a/BDD/SQL/Tecnicismos/Tipos de datos.md b/BDD/SQL/Tecnicismos/Tipos de datos.md index 351690e..3880625 100644 --- a/BDD/SQL/Tecnicismos/Tipos de datos.md +++ b/BDD/SQL/Tecnicismos/Tipos de datos.md @@ -1,4 +1,4 @@ -#SQL-ASIX - Structure Query Language +#SQL-ASIX - Structured Query Language Proveniente de [[SQL]] --- @@ -8,16 +8,19 @@ Algunos de los tipos de datos basicos de SQL son: --- ## Numeros enteros: -- **TINYINT(Tamaño)**: -128 a 127 normal. 0 a 255 sin signo. La cantidad maxima de digitos se puede especificar entre parentesis. -- **SMALLINT(Tamaño)**: -32768 a 32767 normal. 0 a 65535 sin signo. La cantidad maxima de digitos se pueden especificar entre parentesis. -- **MEDIUMINT(Tamaño)**: -8388608 a 8388607 normal. 0 a 16777215 sin signo. La cantidad maxima de digitos se pueden especificar entre parentesis. -- **INT(Tamaño)**: -2147483648 a 2147483647 normal. 0 a 4294967295 sin signo. La cantidad maxima de digitos se pueden especificar entre parentesis. -- **BIGINT(Tamaño)**: -9223372036854775808 a 9223372036854775807 normal. 0 a 18446744073709551615 sin signo. La cantidad maxima de digitos se pueden especificar entre parentesis. +- **TINYINT**: -128 a 127 normal. 0 a 255 sin signo. +- **SMALLINT**: -32768 a 32767 normal. 0 a 65535 sin signo. +- **MEDIUMINT**: -8388608 a 8388607 normal. 0 a 16777215 sin signo. +- **INT**: Da al valor el tipo INTEGER. Entero de 32 bits. Rango: -2147483648 a 2147483647 (signed) +- **BIGINT**: -9223372036854775808 a 9223372036854775807 normal. 0 a 18446744073709551615 sin signo. --- ## Numeros en punto flotante - **FLOAT(tamaño, d)**: Un pequeño numero con un punto decimal flotante. La cantidad maxima de digitos puede especificar en el parametro de tamaño. El numero maximo de digitos a la derecha del punto decimal se especifica en el parametro d. -- **DECIMAL(tamaño, d)**: Un DOBLE almacenado como una cadena, lo que permite un punto decimal fijo. La cantidad maxima de digitos se puede especificar en el parametro de tamaño. El numero maximo de digitos a la derecha del punto decimal se especifica en el parametro d. +- **DECIMAL(tamaño, d)**: Un número exacto almacenado internamente en formato decimal fijo. La cantidad maxima de digitos se puede especificar en el parametro de tamaño. El numero maximo de digitos a la derecha del punto decimal se especifica en el parametro d. + +>[!bug] +>FLOAT es un tipo aproximado y puede introducir errores de precisión. --- ## Fechas y tiempos @@ -37,7 +40,7 @@ Algunos de los tipos de datos basicos de SQL son: --- ## Cadena de caracteres: - **CHAR (Tamaño)**: Cadena de longitud fija (puede contener letras, numeros y caracteres especiales), El tamaño fijo se especifica entre parentesis. Puede almacenar hasta 255 caracteres. -- **VARCHAR(Tamaño)**: Tiene una cadena de longitud variable (puede contener letras, numeros y caracteres especiales). El tamaño maximo se especifica entre parentesis. Puede almacenar hasta 255 caracteres. +- **VARCHAR(Tamaño)**: Tiene una cadena de longitud variable (puede contener letras, numeros y caracteres especiales). El tamaño maximo se especifica entre parentesis. Puede almacenar hasta 255 caracteres dependiendo del charset con `utf8mb4` puede almacenar hasta 65535 bytes (~16383 caracteres), aunque 255 es una práctica común. - **TINYTEXT**: Tiene una cadena con una longitud maxima de 255 caracteres - **TEXTO**: Tiene una cadena con una longitud maxima de 65535 caracteres. - **BLOB**: Para BLOB (Objetos grandes binarios). Almacena hasta 65535 bytes de datos. @@ -47,13 +50,16 @@ Algunos de los tipos de datos basicos de SQL son: - **LONGBLOB**: Para BLOB (Objetos grandes binarios). Tiene una capacidad para 4294967295 bytes de datos. >[!bug] -> Nota: Si, en VARCHAR, agregas un valor mas grande que 255, este se convertira en tipo TEXTO. +> Nota: Si, en VARCHAR, agregas un valor mas grande que 255, MySQL rechaza el INSERT. --- ## ENUM y SET -- **Enum (x, y, z, etc.)**: Permite ingresar una lista de valores posibles. Puede enumerar hasta 65535 valores en una lista ENUM. Si se inserta un valor que no esta en la lista, se insertará un valor en blanco. +- **Enum (x, y, z, etc.)**: Permite ingresar una lista de valores posibles. Puede enumerar hasta 65535 valores en una lista ENUM. Inserta el primer valor del ENUM, o `''` si existe. - **Set**: Similar a Enum, excepto que SET puede contener hasta 64 elementos de una lista y puede almacenar mas de opcion +>[!bug] +>Nota: Si se inserta un valor no permitido, MariaDB inserta el primer valor del ENUM o una cadena vacía y lanza un warning. + --- ## Binarios: -- **bit** Entero que puede ser 0, 1 o NULL. +- **bit**: Tipo binario para almacenar Bits. No equivalente a BOOLEAN. Poco usado. diff --git a/Imagenes/SQL/Mezcla-cartesiana_(CROSS_JOIN).png b/Imagenes/SQL/Mezcla-cartesiana_(CROSS_JOIN).png new file mode 100644 index 0000000..1c08c04 Binary files /dev/null and b/Imagenes/SQL/Mezcla-cartesiana_(CROSS_JOIN).png differ