¡El poder de los datos!

1

¡El poder de los datos!

Introducción a las bases de datos relacionales

2

Buenas prácticas de bases de datos con SQL

3

Tipos de datos en SQL

4

¿Cómo crear una base de datos en SQL?

5

Práctica: Tu primera consulta en bases de datos

6

Historia y Evolución de SQL

7

Práctica: Creación de Tablas en SQL (CREATE TABLE)

Manipulación de Datos

8

Insertando Datos con SQL (INSERT)

9

Consultas y Selecciones en SQL (SELECT)

10

Práctica: SELECT en SQL

11

Actualización de Datos con SQL (UPDATE)

12

Eliminación de Datos con SQL (DELETE)

13

Práctica: CRUD con SQL

Manipulación Avanzada de Datos

14

Instalación de MySQL Server y MySQL Workbench

15

¿Qué es la cláusula WHERE de SQL?

16

Filtrar y Ordenar Datos en SQL (LIKE)

17

Práctica: Filtrar Datos con WHERE en SQL

18

Cláusulas de Comparación Textual en SQL (AND, NULL, IN, NOT)

19

Funciones de Aritmética Básica en SQL (COUNT, SUM, AVG)

20

Funciones de Aritmética Básica en SQL (MIN, MAX)

Agrupación de Datos

21

Agrupación de Datos en SQL: GROUP BY, HAVING y CASE para Análisis Avanzado

22

Práctica: Agrupamiento y Ordenamiento de Datos

23

Tipos de JOIN en SQL

24

¿Cómo funciona INNER JOIN, LEFT JOIN, RIGHT JOIN y FULL JOIN?

25

Práctica: LEFT JOIN en SQL

Transformación de Datos

26

Vistas Materializadas en SQL: Como optimizar tus consultas y reportes.

27

Práctica: Crear Vistas Materializadas en SQL

28

Optimización de Bases de Datos con SQL: CREATE INDEX y TRIGGER

29

Vistas Materializadas y Temporales en SQL

30

Expresiones de Tablas Comunes (CTE) en SQL

Procedimientos Almacenados

31

Procedimientos Almacenados en SQL

32

Procedimientos Almacenados en SQL: Gestión de Variables y Manejo de Excepciones

Administración de Base de Datos

33

Respaldos y Restauración de Bases de Datos

34

Seguridad en Bases de Datos SQL

Análisis de Datos Avanzados

35

Potenciando los Datos en la Nube: Data Science, Big Data, ML e AI

36

SQL para Análisis de Datos: Primeros pasos con Power BI

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

No se trata de lo que quieres comprar, sino de quién quieres ser. Aprovecha el precio especial.

Antes: $249

Currency
$209

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Suscríbete

Termina en:

13 Días
5 Hrs
1 Min
52 Seg

Cláusulas de Comparación Textual en SQL (AND, NULL, IN, NOT)

18/36
Recursos

El uso de operadores lógicos es esencial en el análisis de datos para refinar las consultas y obtener resultados precisos. Al mezclar estos operadores, podemos aplicar múltiples criterios simultáneamente, lo cual es una práctica común para los ingenieros de datos en procedimientos almacenados y vistas.

## ¿Cómo utilizamos los operadores lógicos en una consulta?

Para ilustrar el uso de operadores lógicos, tomemos la tabla de instructores y apliquemos varios criterios. Primero, podemos filtrar los instructores cuyo salario sea mayor a 50 mil dólares. Luego, añadimos el operador AND para especificar que el primer nombre debe empezar con la letra J. Observamos que los resultados disminuyen ya que los criterios se están anidando.

## ¿Qué hacemos si queremos criterios excluyentes?

Si queremos criterios excluyentes, utilizamos el operador OR. Por ejemplo, podemos mostrar instructores con un salario mayor a 50 mil dólares o cuyo primer nombre comience con J. Los resultados aumentan porque cualquiera de las dos condiciones puede cumplirse.

## ¿Cómo añadimos múltiples condiciones?

Podemos añadir más condiciones para refinar aún más nuestra consulta. Por ejemplo, si además queremos incluir nombres que comiencen con D, combinamos los operadores lógicos. Así, obtenemos una lista más extensa que incluye nombres como Jessica, Jane, Daniel y James.

## ¿Cómo manejamos valores nulos?

En el día a día de un ingeniero de datos, los valores nulos son cruciales. Utilizamos la cláusula WHERE con IS NOT NULL para obtener registros donde el primer nombre no sea nulo. Si queremos la información de registros con nombres nulos, cambiamos a IS NULL. Esto nos permite manejar datos incompletos de manera efectiva.

## ¿Cómo excluimos ciertos valores?

Para excluir valores específicos, usamos el operador NOT IN. Por ejemplo, si no queremos ver estudiantes de 20 años, utilizamos NOT IN (20). Así, obtenemos todos los estudiantes excepto los que tienen 20 años.

Estas técnicas permiten a los ingenieros de datos manipular y consultar información de manera efectiva. ¿Sabes cómo consultar información de dos tablas a la vez aplicando condiciones? Deja tu respuesta en los comentarios y comparte tus conocimientos con tus compañeros.

Aportes 26

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

![](https://static.platzi.com/media/user_upload/code%20%285%29%20%281%29-79c4931d-74b4-44c1-98e1-cfd6b0afc25d.jpg)
Mi apunte de la clase📝 ![](https://static.platzi.com/media/user_upload/Aporte18BD1-e7182ce9-45ea-4157-8a3d-ba972a2d32ee.jpg)
```js SELECT * FROM students WHERE city IN ('New York', 'Los Angeles') AND firstname != 'John' AND email IS NOT NULL; SELECT * FROM students WHERE firstname = 'John' AND lastname = 'Doe'; ```
Podemos hacer uso de los JOINS En este caso inner join `select l.id_local,` `v.ventas_id, ` ` v.fecha,` ` v.clave_producto,` ` v.venta` `from local l` `inner join` `ventas v on v.id_local = l.id_local` `where v.venta > 1000;` sintaxis SELECT c1.columna c2.columna FROM tabla1 c1 INNER JOIN tabla2 c2 ON c1.columnaId = c2.columnaId2 WHERE condicion
* **AND**: Se usa en condiciones `WHERE` para combinar múltiples criterios y devolver solo aquellos registros que cumplen todas las condiciones especificadas. Ejemplo: `SELECT * FROM empleados WHERE edad > 30 AND departamento = 'Ventas';`. * **NULL**: Se refiere a un valor desconocido o inexistente en una columna. Se usa para filtrar registros que tienen un valor `NULL`. Ejemplo: `SELECT * FROM clientes WHERE direccion IS NULL;`. * **IN**: Permite verificar si un valor está dentro de un conjunto de valores específicos, simplificando la consulta con múltiples `OR`. Ejemplo: `SELECT * FROM productos WHERE categoria IN ('Electrónica', 'Ropa', 'Juguetes');`. * **NOT**: Se utiliza para negar una condición. Puede aplicarse junto con otros operadores, como `IN` o `NULL`. Ejemplos: `SELECT * FROM empleados WHERE edad NOT IN (25, 30);` o `SELECT * FROM clientes WHERE direccion IS NOT NULL;`. * **OR**: Se usa para combinar múltiples condiciones en una consulta `WHERE` y devolver registros que cumplen al menos una de las condiciones especificadas. Ejemplo: `SELECT * FROM empleados WHERE departamento = 'Ventas' OR departamento = 'Marketing';`. * **LIKE**: Se utiliza para buscar patrones en columnas de tipo `VARCHAR` o `TEXT`. Se combina con caracteres comodín (`%` para cualquier cadena de longitud, `_` para un solo carácter). Ejemplo: `SELECT * FROM clientes WHERE nombre LIKE 'Juan%';` (busca nombres que comiencen con 'Juan').
ERROR profesora Carolina Castañeda, si es excluyente, no tienden a ser más, tienden a ser menos. Y el OR no es excluyende, e Incluyente, mezclo los conceptos de AND y OR
select \* from instructors, students where salary > 50 and studentid in (20,25,30,40);yo lo realize asi ```js select * from instructors, students where salary > 50 and studentid in (20,25,30,40); ```
Los operadores lógicos son palabras clave que permiten combinar condiciones en una consulta para obtener resultados más específicos AND: Se utiliza para combinar dos o más condiciones y todas deben ser verdaderas para que se cumpla la condición general ejemplo: SELECT \* FROM INSTRUCTORS WHERE SALARY > 50000 AND FIRSTNAME LIKE 'J%'; OR: Se usa para combinar dos o más condiciones y al menos una de ellas debe ser verdadera para que se cumpla la condición general ejemplo: SELECT \* FROM INSTRUCTORS WHERE SALARY > 50000 OR FIRSTNAME LIKE 'J%'; NOT: Se usa para negar una condición. Cambia una condición verdadera a falsa y viceversa. ejemplo: SELECT \* FROM COURSES WHERE NOT COURSENAME = 'Introduction to programming'; esta me va dar el resto de cursos excepto el curso con ese nombre. IN: se usa para especificar múltiples valores en una condición. Permite verificar si una columna coincide con cualquiera de los valores de una lista especificada. por ejemplo: SELECT \* FROM COURSES WHERE DURATIONHOURS IN (40,50); esto me selecciona a todos los cursos con una duracion de 40 o 50 horas. Tambien IN es usado para hacer una subconsulta para obtener resultados más dinámicos y complejos por ejemplo: SELECT \* FROM STUDENTS WHERE STUDENTID IN(SELECT STUDENTID FROM STUDENT\_COURSE WHERE COURSEID = 1 ); esta me muestra los estudiantes que hacen el curso con id = 1 Espero mi explicación les sirva.
Tocaria utilizar una nueva clausula (inner join)
Comparto mis practicas en clas SELECT \* FROM INSTRUCTORS WHERE SALARY > 50000 AND FIRSTNAME LIKE 'J%'; -- USANDO OPERADOR LOGICO AND SELECT \* FROM INSTRUCTORS WHERE SALARY > 50000 OR FIRSTNAME LIKE 'J%'; -- USANDO OPERADOR LOGICO OR SELECT \* FROM INSTRUCTORS WHERE SALARY > 50000 AND FIRSTNAME LIKE 'J%' OR -- USANDO OPERADOR LOGICO AND Y OR AL TIEMPO FIRSTNAME LIKE 'D%'; SELECT \* FROM students WHERE FIRSTNAME IS NOT NULL; -- VALIDANDO LOS QUE NO TIENEN NULOS (EN BLANCO) EN EL PRIMER NOMBRE SELECT \* FROM students -- VALIDANDO LOS QUE TIENEN NULOS (EN BLANCO) EN EL PRIMER NOMBRE WHERE FIRSTNAME IS NULL; SELECT \* FROM students -- MANIPULANDO DATOS CON NOT IN, AQUI NO SEA TRAEN LAS EDADES 20 AÑOS WHERE AGE NOT IN (20);
![](https://static.platzi.com/media/user_upload/image-a7e654b7-18f2-4e09-a88c-be36d60926f5.jpg)
```js -- Para los valores NULL se tiene que usar IS NULL y IS NOT NULL. SELECT column_names FROM table_name WHERE column_name IS NULL; SELECT column_names FROM table_name WHERE column_name IS NOT NULL; -- Para excluir valores espeficos utilizamos el NOT IN. SELECT column_names FROM table_name WHERE coulumn_name NOT IN (x) ```
Con respecto a la union de 2 tablas, se puede usar el codigo de "inner join" el cual une el nombre de la tabla y esta se encarga de unir ambos elementos. Solo funcionara si hay algun id igual en ambas tablas para que el metodo funcione. Aqui les mando mi ejemplo. ```js SELECT C.COURSEID, I.FIRSTNAME, I.LASTNAME, C.COURSE_NAME, C.DESCRIPTION, C.DURATIONS_HOURS FROM COURSES AS C INNER JOIN INSTRUCTOR AS I WHERE I.INSTRUCTORID = C.INSTRUCTORID; ```SELECT C.COURSEID, I.FIRSTNAME, I.LASTNAME, C.COURSE\_NAME, C.DESCRIPTION, C.DURATIONS\_HOURS FROM COURSES AS C INNER JOIN INSTRUCTOR AS I WHERE I.INSTRUCTORID = C.INSTRUCTORID;
Alguien sabe el costo de consultar con * o se detalla las columnas en el select
![](https://static.platzi.com/media/user_upload/image-cba9f956-2295-44ef-a599-8e1eeeb19fca.jpg) el reto.
`SELECT ` `tabla_uno.nombre, tabla_uno.apellido, tabla_dos.nombre, tabla_dos.apellido ` `FROM ` `tabla_uno, tabla_dos` `WHERE ` `tabla_uno.age IS NOT NULL` `AND ` `taba_dos.age IS NOT NULL;`
SELECT \* FROM instructors where SALARY > 5000 AND FIRSTNAME LIKE 'J%' OR FIRSTNAME LIKE 'D%'
En la subsección del resumen que comienza con: "*¿Qué hacemos si queremos criterios excluyentes?*"... De acuerdo a la explicación ¿No se refiere más bien a si queremos criterios **incluyentes**? Porque cuando usar el operador lógico OR estás permitiendo incluir aún más contenido de respuesta que si usas el AND (Que sí es excluyente).
Reto select s.studentid, i.instructorid, s.firstname as Estudiante, i.firstname as Instructor from students s, instructors i where s.studentid = i.instructorid and i.firstname like '%e%';
![](https://static.platzi.com/media/user_upload/image-f2c248cd-ab40-4fea-9c11-cdd9fc0b5c31.jpg)![](https://static.platzi.com/media/user_upload/image-98735d26-6298-4d43-ac25-6201d7beecda.jpg) JOINS
![](https://static.platzi.com/media/user_upload/code%20%283%29%20%281%29-9e883536-0ed0-407c-ad35-55a6f242e2c3.jpg)
![](https://static.platzi.com/media/user_upload/image-8ab9ec58-c941-4638-9711-04d4b6e4bc62.jpg) Muy interesante para saber donde se nos olvido capturar algun campo
Me gusto la manera de manipular los datos con `SELECT * FROM STUDENTS` `WHERE AGE NOT IN (20)`
![]()```js SELECT * FROM INSTRUCTORS,ESTUDIANTE WHERE ESTUDIANTE.AGE<50 OR INSTRUCTORS.AGE<30;-- SELECCIONAR DOS TABLAS Y REALIZAR LA BUSQUEDA ```SELECT \* FROM INSTRUCTORS,ESTUDIANTE WHERE ESTUDIANTE.AGE<50 OR INSTRUCTORS.AGE<30;-- SELECCIONAR DOS TABLAS Y REALIZAR LA BUSQUEDA
En cuanto a la respuesta de la pregunta final, el trabajar con "joins" es una buena opción.