¡El poder de los datos!
¡El poder de los datos!
Introducción a las bases de datos relacionales
Buenas prácticas de bases de datos con SQL
Tipos de datos en SQL
¿Cómo crear una base de datos en SQL?
Práctica: Tu primera consulta en bases de datos
Historia y Evolución de SQL
Práctica: Creación de Tablas en SQL (CREATE TABLE)
Manipulación de Datos
Insertando Datos con SQL (INSERT)
Consultas y Selecciones en SQL (SELECT)
Práctica: SELECT en SQL
Actualización de Datos con SQL (UPDATE)
Eliminación de Datos con SQL (DELETE)
Práctica: CRUD con SQL
Manipulación Avanzada de Datos
Instalación de MySQL Server y MySQL Workbench
¿Qué es la cláusula WHERE de SQL?
Filtrar y Ordenar Datos en SQL (LIKE)
Práctica: Filtrar Datos con WHERE en SQL
Cláusulas de Comparación Textual en SQL (AND, NULL, IN, NOT)
Funciones de Aritmética Básica en SQL (COUNT, SUM, AVG)
Funciones de Aritmética Básica en SQL (MIN, MAX)
Agrupación de Datos
Agrupación de Datos en SQL: GROUP BY, HAVING y CASE para Análisis Avanzado
Práctica: Agrupamiento y Ordenamiento de Datos
Tipos de JOIN en SQL
¿Cómo funciona INNER JOIN, LEFT JOIN, RIGHT JOIN y FULL JOIN?
Práctica: LEFT JOIN en SQL
Transformación de Datos
Vistas Materializadas en SQL: Como optimizar tus consultas y reportes.
Práctica: Crear Vistas Materializadas en SQL
Optimización de Bases de Datos con SQL: CREATE INDEX y TRIGGER
Vistas Materializadas y Temporales en SQL
Expresiones de Tablas Comunes (CTE) en SQL
Procedimientos Almacenados
Procedimientos Almacenados en SQL
Procedimientos Almacenados en SQL: Gestión de Variables y Manejo de Excepciones
Administración de Base de Datos
Respaldos y Restauración de Bases de Datos
Seguridad en Bases de Datos SQL
Análisis de Datos Avanzados
Potenciando los Datos en la Nube: Data Science, Big Data, ML e AI
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
Si ya tienes una cuenta,
No se trata de lo que quieres comprar, sino de quién quieres ser. Aprovecha el precio especial.
Antes: $249
$209
Paga en 4 cuotas sin intereses
Termina en:
14 Días
11 Hrs
2 Min
43 Seg
Práctica: Agrupamiento y Ordenamiento de Datos
22/36Aportes 103
Preguntas 2
Ordenar por:
nuevamente se plantea un ejercicio con un tema que todavia no fue explicado para poder resolverlo (join)
@platzi, realmente deberian mirar el orden de los temas, y no poner pruebas con conceptos que no hemos visto, en este curso eh visto esta falencia y si es un poco saque de onda, porque pormas que uno realize el ejercicio con lo aprendido, las pruebas lo condicionan a una solucion , de conceptos que no hemos visto. 
```txt
SELECT (SELECT name
FROM teachers
WHERE teachers.id = courses.teacher_id) AS teacher, SUM(n_reviews) AS total_reviews
FROM courses WHERE n_reviews > 0
GROUP BY teacher_id
HAVING teacher IS NOT NULL
ORDER BY total_reviews DESC;
```
Cuando das clic en "ver solución" sale una solución con temas que no hemos visto. No le veo el sentido a poner estos ejercicios con temas que no hemos visto
```js
SELECT
teachers.name AS teacher,
SUM(courses.n_reviews) AS total_reviews
FROM courses
LEFT JOIN
teachers ON courses.teacher_id = teachers.id
WHERE
courses.teacher_id IS NOT NULL
GROUP BY teachers.name
ORDER BY total_reviews DESC;
```SELECT teachers.name AS teacher, SUM(courses.n\_reviews) AS total\_reviewsFROM coursesLEFT JOIN teachers ON courses.teacher\_id = teachers.idWHERE courses.teacher\_id IS NOT NULLGROUP BY teachers.nameORDER BY total\_reviews DESC;
Una consulta un poco mas simple
Que increible prueba, la he realizado asi:
`SELECT`
`t.name AS teacher,`
`SUM(c.n_reviews) AS total_reviews`
`FROM courses c`
`JOIN teachers t ON c.teacher_id = t.id`
`WHERE c.n_reviews > 0`
`GROUP BY t.name`
`ORDER BY total_reviews DESC;`
este curso es muy regular, no tiene estructura y las practicas no son acordes al orden de los temas vistos hasta el momento.
Muy mal que uno queriendo aprender y pongan una prueba con temas que no se han visto aún... algunos dicen que hay respuestas con lo que se ha aprendido, pero tampoco dejan la respuesta y al ver la solución planteada se usa LEFT JOIN, que se va a aprender en dos clases adelante :(
An example without Join:
```js
SELECT
CASE
WHEN courses.teacher_id = 8 THEN 'Silvia'
WHEN courses.teacher_id = 1 THEN 'Israel'
WHEN courses.teacher_id = 16 THEN 'Leomaris'
END as teacher,
sum(courses.n_reviews) as total_reviews
FROM courses
WHERE courses.teacher_id IS NOT NULL
GROUP BY courses.teacher_id
ORDER BY total_reviews DESC;
```
Dice el ejercicio que entrega dos(2) tablas,pero dice que no hay tabla teacher ...
idnamen\_reviewsteacher\_id100Fundamentos de Bases de Datos14001200Curso de MySQL y MariaDB400260Curso de Data Science3208350Curso de Firebase1501749Curso de Python23008750Curso de React.js150016
`(SQL error) no such table: teacher`
la tabla de profesores se llama teachers
Esta fregada la práctica.
Platzi está en decadencia😣
```js
SELECT
(SELECT name FROM teachers WHERE teachers.id = courses.teacher_id) AS teacher,
SUM(n_reviews) AS total_reviews
FROM courses
WHERE n_reviews > 1 AND
teacher_id IS NOT NULL
GROUP BY teacher_id
ORDER BY total_reviews DESC;
```SELECT (SELECT name FROM teachers WHERE teachers.id = courses.teacher\_id) AS teacher, SUM(n\_reviews) AS total\_reviewsFROM coursesWHERE n\_reviews > 1 ANDteacher\_id IS NOT NULLGROUP BY teacher\_id ORDER BY total\_reviews DESC;
Yo creo que el reto es realizarlo sin usar otras claúsulas que obviamente facilitan la operación. Aquí mi solución:
Muy buenas,
Mi solución que en la ejecución da un resultado correcto, pero en las Pruebas falla es la siguiente....
`SELECT T.name AS teacher, SUM(C.n_reviews) AS total_reviews`
`FROM courses AS C, teachers AS T`
`WHERE C.teacher_id = T.id`
`AND C.n_reviews > 0 `
`GROUP BY T.name`
`ORDER BY SUM(C.n_reviews) DESC;`
```js
SELECT
teachers.name AS teacher,
SUM(courses.n_reviews) AS total_reviews
FROM courses
INNER JOIN teachers ON teachers.id = courses.teacher_id
GROUP BY teachers.name
ORDER BY COUNT(courses.n_reviews) DESC;
```Yo lo hice usando INNER JOIN que unicamente coge los profesores que tienen cursos asignados
Este es mi codigo :)
SELECT name AS name\_teacher, SUM (n\_reviews) AS total\_reviews
FROM
teacher
JOIN
courses ON teacher.id = courses.teacher\_id
GROUP BY name\_teacher
HAVING SUM total\_reviews > 0
ORDER BY total\_reviews DESC;
### **Explicación detallada y organizada de la consulta SQL**
**Paso a paso:**
1\. Subconsulta en el `SELECT` para obtener el nombre del profesor:```js
(SELECT name FROM teachers WHERE teachers.id = courses.teacher_id)
```
* Se usa un `SELECT` dentro del `SELECT` principal para extraer el nombre del profesor (`name`) desde la tabla `teachers`.
* La relación se establece mediante `teachers.id = courses.teacher_id`.
2\. Seleccionar el nombre del profesor usando una subconsulta
```js
SELECT // Línea añadida
(SELECT name FROM teachers WHERE teachers.id = courses.teacher_id) AS "teacher"
FROM courses; // Línea añadida
```3. Agrupar por `teacher_id`
```js
SELECT
(SELECT name FROM teachers WHERE teachers.id = courses.teacher_id) AS "teacher"
FROM courses
GROUP BY teacher_id; // Línea añadida
```4. Sumar las reviews de los cursos de cada profesor
```js
SELECT
(SELECT name FROM teachers WHERE teachers.id = courses.teacher_id) AS "teacher",
SUM(n_reviews) AS "total_reviews" // Línea añadida
FROM courses
GROUP BY teacher_id;
```5. Excluir profesores sin cursos (NULL) y ordenar los resultados
```js
SELECT
(SELECT name FROM teachers WHERE teachers.id = courses.teacher_id) AS "teacher",
SUM(n_reviews) AS "total_reviews"
FROM courses
GROUP BY teacher_id
HAVING "teacher" IS NOT NULL // Línea añadida
ORDER BY "total_reviews" DESC; // Línea añadida
```SELECT
(SELECT name FROM teachers WHERE teachers.id = courses.teacher\_id) AS "teacher",
SUM(n\_reviews) AS "total\_reviews"
FROM courses
GROUP BY teacher\_id
HAVING "teacher" IS NOT NULL
ORDER BY "total\_reviews" DESC;
**Código final**
```js
SELECT
(SELECT name FROM teachers WHERE teachers.id = courses.teacher_id) "teacher",
SUM(n_reviews) "total_reviews"
FROM courses
GROUP BY teacher_id
HAVING "teacher" IS NOT NULL
ORDER BY "total_reviews" DESC;
```
```txt
SELECT teachers.name as teacher,sum(courses.n_reviews) as total_reviews from teachers
INNER JOIN courses ON
teachers.id = courses.teacher_id
group by teachers.name
ORDER BY total_reviews DESC;
```lo hice asi inicialmente sin ver comentarios ni nada, es el mismo resultado pero no de la misma manera para pasar la prueba.
Esa es mi propuesta de solución con los conocimientos que SI hemos visto hasta ahorita
SELECT teacher\_id, COUNT(n\_reviews) AS 'total\_reviews'FROM coursesGROUP BY teacher\_id HAVING COUNT (teacher\_id) > 0ORDER BY n\_reviews DESC
Comparto mi ejercicio:
SELECT teachers.name AS 'teacher', SUM (courses.n\_reviews) AS 'total\_reviews'
FROM teachers
JOIN courses ON teachers.id = courses.teacher\_id
WHERE courses.n\_reviews > 0
GROUP BY teachers.id, teachers.name
ORDER BY total\_reviews DESC
Despues de varios intentos, les comparto mi codigo
`SELECT teachers.name as teacher,SUM(courses.n_reviews) AS total_reviewsFROM courses JOIN teachers ON courses.teacher_id = teachers.idWHERE courses.n_reviews > 0GROUP BY teachers.nameHAVING SUM(courses.n_reviews > 0)ORDER BY total_reviews DESC;`
\-- Escribe tu código aquí 👇
SELECT \* FROM courses;
SELECT \* FROM teacher;
Debian haber compartido la base de datos, y no lo hicieron.Lastima, porque la idea es practicar simultaneamente con el docente.Lstima,Lastima y Lastima...no puedo creer que tengo que ir a videos de youtube para entender con bases de datos que si entrega el influencer , y aqui no, no veo respuesta de los administradores. En fin.
```txt
-- Escribe tu código aquí 👇
SELECT t.name teacher, SUM(n_reviews) total_reviews FROM courses c
INNER JOIN teachers t
ON c.teacher_id = t.id
GROUP BY t.name
ORDER BY total_reviews DESC;
```-- Escribe tu código aquí 👇SELECT t.name teacher, SUM(n\_reviews) total\_reviews FROM courses c INNER JOIN teachers tON c.teacher\_id = t.idGROUP BY t.nameORDER BY total\_reviews DESC;
`SELECT t.name AS teacher, SUM(c.n_reviews) AS total_reviewsFROM teachers tJOIN courses c ON t.id = c.teacher_idWHERE c.n_reviews > 0GROUP BY t.id, t.nameORDER BY total_reviews DESC;`
Esta fue la manera en la que yo lo hice, lo que aprendi que cai en cuenta es que la funcion SUM() al usarla en un GROUP BY separara en grupo y luego ahra la suma de cada grupo no solo la suma total y esto es gracias al GROUP BY tamvien use algunos alias que lo aprendi investigando buena practica:SELECT t.name AS teacher, SUM(c.n\_reviews) AS total\_reviewsFROM teachers tJOIN courses c ON t.id = c.teacher\_idWHERE c.n\_reviews > 0GROUP BY t.nameORDER BY total\_reviews DESC;
```txt
SELECT t.name AS teacher, SUM(c.n_reviews) AS total_reviews
FROM teachers t
JOIN courses c ON t.id = c.teacher_id
WHERE c.n_reviews > 0
GROUP BY t.name
ORDER BY total_reviews DESC;
```
Si se puede hacer sin un Join, sin embargo, tampoco nunca nos habían mencionado que se podían consultar dos tablas al mismo tiempo. Creo que si ya sabes SQL este curso es bueno, sin embargo ponerlo como básico, es un error.
Mi solución que pasó las pruebas siin uso de Joins:
```js
SELECT teachers.name AS teacher, SUM(n_reviews) AS total_reviews
FROM courses, teachers
WHERE teacher_id IS NOT NULL AND courses.teacher_id = teachers.id
GROUP BY teacher_id
ORDER BY total_reviews DESC;
```
mi CODIGO SIN USAR EL JOIN, Igual me sale mal porque debe salir el nombre del profesor y me sale el id; pero es una avance sin saber el join
```js
SELECT
teachers.name AS teacher,
SUM(n_reviews) AS total_reviews
FROM teachers
LEFT JOIN courses
ON teachers.id = courses.teacher_id
GROUP BY courses.teacher_id
HAVING total_reviews > 0
ORDER BY total_reviews DESC;
```
```js
-- Escribe tu código aquí 👇
SELECT teacher.name AS teacher, SUM(courses.n_reviews) AS total_reviews
FROM courses
JOIN teacher ON courses.teacher_id = teacher.id
GROUP BY teacher.name
ORDER BY total_reviews DESC;
```-- Escribe tu código aquí 👇SELECT teacher.name AS teacher, SUM(courses.n\_reviews) AS total\_reviewsFROM coursesJOIN teacher ON courses.teacher\_id = teacher.idGROUP BY teacher.nameORDER BY total\_reviews DESC;
Parece que los retos los crearon despues de haber terminado el curso, y los pusieron incorrectamente. Los retos deben ir despues de la explicacion del tema. Los "Joints"se explican en la siguiente clase. Asi que es mejor ver la clase 23, y luego regresar a la 22 y completar el reto... para no salir frustrado. Los retos parecen ser los mismos del curso de Fundamentos de bases de datos de Israel, recomiendo ver ese curso antes que este.
Mi sql
\-- AGRUPO LOS PROFESORES Y VEO A QUE CURSO ESTAN ASIGNADOS
SELECT t.name as 'teacher',sum(n\_reviews) as 'total\_reviews' FROM courses cinner join teachers t on c.teacher\_id = t.id GROUP BY c.teacher\_idorder by total\_reviews desc
Veo los comentarios de join y me quiero morir. Se puede resolver tranquilamente sin join, mas fácil hacerlo con join, si, pero no vimos el tema todavía. Así que sáquense de la cabeza los temas mas avanzados que saben, sino, vayan a hacer otro curso de mayor nivel. Lo resolví en 5 minutos así:
```js
select
(select name from teachers where id = c.teacher_id) as teacher, sum(n_reviews) as total_reviews
from courses c
where teacher_id is not null
group by teacher
order by total_reviews desc;
```
Ejercicio muy divertido:
SELECT a.name as teacher, sum(b.n\_reviews) as total\_reviewsFROM teachers ainner join courses b on b.teacher\_id = a.idgroup by a.nameorder by 2 desc;
SELECT t.name AS teacher, SUM(n\_reviews) AS total\_reviewsFROM courses AS c LEFT JOIN teachers AS t ON c.teacher\_id = t.idWHERE c.n\_reviews > 1 AND c.teacher\_id IS NOT NULLGROUP BY t.nameORDER BY total\_reviews DESC
Posible solución:
SELECT t.name AS "teacher", SUM(n\_reviews) AS "total\_reviews" FROM courses AS cJOIN teachers AS tON c.teacher\_id = t.id WHERE n\_reviews IS NOT NULL AND n\_reviews >= 1GROUP BY teacherORDER BY total\_reviews DESC;
1. La tabla se llama teache**s**, no teacher.
El resto, aqui va mi solución:
SELECT teachers.name AS teacher,
SUM (courses.n\_reviews) AS total\_reviews
FROM courses
LEFT JOIN teachers ON teacher\_id = teachers.id
WHERE courses.teacher\_id IS NOT NULL
GROUP BY teachers.name
ORDER BY total\_reviews DESC;
`select courses.teacher_id, teachers.name, sum(courses.n_reviews) as total_reviewsfrom coursesleft join teacherson courses.teacher_id == teachers.idgroup by teacher_idorder by total_reviews desc;`
`SELECT `
` t.name AS teacher, `
` SUM(c.n_reviews) AS total_reviews `
`FROM `
` teachers t `
`LEFT JOIN `
` courses c `
`ON `
` (c.teacher_id = t.id) `
`WHERE `
` c.n_reviews IS NOT NULL `
`GROUP BY `
` t.name `
`ORDER BY `
` total_reviews DESC;`
### Explicación de la Consulta:
1. **SELECT t.name AS teacher, SUM(c.n\_reviews) AS total\_reviews**:
* **t.name AS teacher**: Selecciona el nombre del profesor de la tabla `teachers` y lo renombra como `teacher` en el resultado.
* **SUM(c.n\_reviews) AS total\_reviews**: Suma el número de reseñas (`n_reviews`) de la tabla `courses` para cada profesor y lo renombra como `total_reviews`.
2. **FROM teachers t**:
* Indica que la tabla principal de la que se seleccionan los datos es `teachers`, y se le asigna el alias `t`.
3. **LEFT JOIN courses c ON (c.teacher\_id = t.id)**:
* Realiza una unión (join) de tipo `LEFT JOIN` entre la tabla `teachers` y la tabla `courses`.
* **c.teacher\_id = t.id**: La unión se basa en la condición de que el `teacher_id` en `courses` debe coincidir con el `id` en `teachers`.
* **LEFT JOIN**: Asegura que todos los registros de la tabla `teachers` se incluyan en el resultado, incluso si no hay coincidencias en la tabla `courses`. Los registros de `courses` que no tengan una coincidencia en `teachers` serán representados como `NULL` en el resultado.
4. **WHERE c.n\_reviews IS NOT NULL**:
* Filtra los resultados para incluir solo aquellos registros donde el número de reseñas (`n_reviews`) no sea `NULL`. Es decir, excluye las filas donde no hay reseñas.
5. **GROUP BY t.name**:
* Agrupa los resultados por el nombre del profesor (`t.name`). Esto es necesario para aplicar la función de agregación `SUM()` sobre cada grupo de profesores.
6. **ORDER BY total\_reviews DESC**:
* Ordena los resultados por la suma total de reseñas (`total_reviews`) en orden descendente (`DESC`). Así, el profesor con el mayor número de reseñas aparece primero.
Posiblemente, traten de incentivar a la investigación y autonomía para poder así resolver los problemas y no depender solo de los videos, ya que investigando y probando es cuando más aprendes
SELECT t.name AS teacher, SUM(c.n\_reviews) AS total\_reviewsFROM teachers tLEFT JOIN courses c ON (c.teacher\_id = t.id)WHERE c.n\_reviews IS NOT NULLGROUP BY t.name ORDER BY total\_reviews DESC;
SELECT teachers.name AS teacher, SUM(courses.n\_reviews) AS total\_reviewsFROM coursesLEFT JOIN teachers ON courses.teacher\_id = teachers.idWHERE courses.teacher\_id IS NOT NULLGROUP BY teachers.nameORDER BY total\_reviews DESC;
`-- Escribe tu código aquí 👇SELECT teachers.name teacher,SUM(courses.n_reviews) total_reviewsFROM coursesINNER JOINteachersON teachers.id = courses.teacher_idGROUP BY teachers.nameHAVING SUM(courses.n_reviews)>0ORDER BY SUM(courses.n_reviews) DESC;`
Me parece que hay un error en la descripcion dice tabla 'teacher', cuando realmente es 'teachers':
```js
-- Escribe tu código aquí 👇
SELECT t.name AS teacher, SUM(c.n_reviews) AS total_reviews
FROM courses AS c
INNER JOIN teachers AS t
ON t.id = c.teacher_id
WHERE c.n_reviews >= 1
GROUP BY teacher
ORDER BY total_reviews DESC;
```-- Escribe tu código aquí 👇SELECT t.name AS teacher, SUM(c.n\_reviews) AS total\_reviewsFROM courses AS cINNER JOIN teachers AS t ON t.id = c.teacher\_idWHERE c.n\_reviews >= 1GROUP BY teacherORDER BY total\_reviews DESC;
SELECT t.name as teacher, sum(n\_reviews) as total\_reviewsFROM courses cright join teachers t on t.id = c.teacher\_id
group by t.namehaving total\_reviews > 0order by total\_reviews desc
Hay un error en la descripción del primer punto, la tabla "teacher" no existe, la tabla se llama "teacherS"
```js
SELECT t.name AS teacher, SUM(c.n_reviews) AS total_reviews
FROM courses c, teachers t
WHERE c.teacher_id = t.id
AND c.teacher_id IS NOT NULL
GROUP BY t.name
ORDER BY total_reviews DESC;
```SELECT t.name AS teacher, SUM(c.n\_reviews) AS total\_reviewsFROM courses c, teachers tWHERE c.teacher\_id = t.id AND c.teacher\_id IS NOT NULLGROUP BY t.nameORDER BY total\_reviews DESC;
SELECT teachers.name AS teacher, SUM(courses.n\_reviews) AS total\_reviewsFROM coursesJOIN teachers ON courses.teacher\_id = teachers.idWHERE courses.n\_reviews > 0GROUP BY teachers.nameHAVING SUM(courses.n\_reviews) > 0ORDER BY total\_reviews DESC;
`SELECT teachers.name AS teacher,`
`SUM(courses.n_reviews) AS total_reviews FROM courses AS COURSES INNER JOIN teachers ON COURSES.teacher_id = teachers.idWHERE COURSES.n_reviews > 0GROUP BY teachers.name HAVING SUM(COURSES.n_reviews) > 0ORDER BY total_reviews DESC ;`
Con lo enseñado en las clases no se puede solucionar, no es la primera vez.
Puedo ponerme a buscar solución en google o preguntarle a ChatGPT, pero esa no es la idea, no es lo que quiero. Me retiro.
Soy nuevo en SQL y este es mi primer curso, y hasta este punto todavía no vi nada para relacionar tablas jaja pero gracias a un comentario de esta práctica, aprendí como hacerlo jaja y estoy feliz, les dejo lo que hice con los datos que veniamos trabajando en las clases.
Lo que hice fue: del salario de los instructores, restarle la edad de los estudiantes (jaja no tiene nada que ver lo uno con lo otro, pero utilicé esos datos para relacionar todas las tablas)
```python
select I.salary as 'Salario Instructores', S.age as 'Edad Estudiantes', I.salary - S.age as 'Resta'
from student_course as SC, instructors as I, students as S, courses as C
where C.INSTRUCTORID = I.INSTRUCTORID and C.COURSEID = SC.COURSEID and S.STUDENTID = SC.STUDENTID
```
Buenos días, les comparto mi solución. Veo que algunos estan con la duda de usar o no HAVING. En mi caso no lo vi necesario. Saludos!
```js
--Revisando estructura y datos
SELECT * FROM courses;
SELECT * FROM teachers;
--Reto...
SELECT tch.name as teacher, SUM(crs.n_reviews) as total_reviews
FROM courses crs
INNER JOIN teachers tch on crs.teacher_id = tch.id
WHERE (crs.teacher_id IS NOT NULL OR crs.teacher_id <> '')
AND crs.n_reviews > 0
GROUP BY tch.name
ORDER BY total_reviews DESC;
```
Siguiendo solo lo que he visto en el curso obtuve este resultado viendo las respuestas de los demás. PD: No sé de donde salen los nombres... no se de donde sacan la tabla de teachers... seguiré avanzando para encontrar una respuesta. PD2; en la prueba me salió mal aunque el resultado es el mismo de los que subieron que está bien. 
Solucion sin JOIN:
```js
SELECT T.name AS teacher, SUM(C.n_reviews) AS total_reviews
FROM courses AS C, teachers AS T
WHERE C.teacher_id = T.id
AND C.n_reviews > 0
GROUP BY T.name
ORDER BY total_reviews DESC;
```
```js
select t.name as teacher,sum(c.n_reviews) as total_reviews
from courses c
inner join teachers t on c.teacher_id=t.id
group by c.teacher_id
having sum(c.n_reviews) > 1
order by sum(c.n_reviews) desc;
```select t.name as teacher,sum(c.n\_reviews) as total\_reviewsfrom courses cinner join teachers t on c.teacher\_id=t.idgroup by c.teacher\_idhaving sum(c.n\_reviews) > 1order by sum(c.n\_reviews) desc;
Buenas noches, comparto mi solución
select t.name as teacher,sum(c.n\_reviews) as total\_reviewsfrom courses cinner join teachers t on c.teacher\_id=t.idgroup by c.teacher\_idhaving sum(c.n\_reviews) > 1order by sum(c.n\_reviews) desc;
SELECT teachers.name AS teacher, SUM(courses.n\_reviews) AS total\_reviewsFROM coursesINNER JOIN teachers ON (teachers.id == courses.teacher\_id)GROUP BY (teacher\_id)ORDER BY total\_reviews DESC;
SELECT t.name AS teacher, SUM(c.n\_reviews) AS total\_reviewsFROM teachers tJOIN courses c ON t.id = c.teacher\_idWHERE c.n\_reviews > 0GROUP BY t.id, t.nameORDER BY total\_reviews DESC;
No puedo creer lo mucho que me costo este ejercicio :')
Parecía ser fácil...
```js
SELECT
teachers.name AS teacher,
SUM(courses.n_reviews) AS total_reviews
FROM courses
JOIN
teachers ON courses.teacher_id = teachers.id
WHERE
courses.teacher_id IS NOT NULL
GROUP BY teachers.name
ORDER BY total_reviews DESC;
```
````python
Les comparto mi solucion
SELECT t.name AS teacher, SUM(c.n_reviews) AS total_reviews
FROM courses c
INNER JOIN teachers t ON c.teacher_id = t.id
GROUP BY t.name
ORDER BY 2 DESC;
```SELECT t.name AS teacher, SUM(c.n\_reviews) AS total\_reviewsFROM courses cINNER JOIN teachers t ON c.teacher\_id = t.idGROUP BY t.nameORDER BY 2 DESC;
````
Quise agregar una columna más para ver reflejado el id del docente
SELECT teachers.id as code\_docente, teachers.name AS teacher, SUM(courses.n\_reviews) AS total\_reviews
FROM courses
INNER JOIN teachers ON courses.teacher\_id = teachers.id
GROUP BY teachers.id, teachers.name
ORDER BY total\_reviews DESC;
La solución sin hacer Join explicada:Desglose de la Consulta:
```js
SELECT
(SELECT name
FROM teachers
WHERE teachers.id = courses.teacher_id) AS teacher,
SUM(n_reviews) AS total_reviews
FROM
courses
WHERE
n_reviews > 0
GROUP BY
teacher_id
HAVING
teacher IS NOT NULL
ORDER BY
total_reviews DESC;
```
1. **Subconsulta en la Selección**`(SELECT` name
` FROM` teachers
` WHERE teachers.id = courses.teacher_id) AS` teacher:
```js
(SELECT name
FROM teachers
WHERE teachers.id = courses.teacher_id) AS teacher
```
* Esta subconsulta se ejecuta para cada fila en la tabla `courses`.
* Busca el nombre del profesor (`name`) de la tabla `teachers` cuyo `id` coincida con `teacher_id` en la tabla `courses`.
* El resultado de esta subconsulta se renombra como `teacher`.
2. **SUM(n\_reviews) AS total\_reviews**:
* Calcula la suma total de las reviews (`n_reviews`) para cada grupo de cursos asociados a un `teacher_id`.
3. **FROM courses**:
* Indica que la consulta se está realizando sobre la tabla `courses`.
4. **WHERE n\_reviews > 0**:
* Filtra los cursos para incluir solo aquellos que tienen al menos 1 review (`n_reviews > 0`).
5. **GROUP BY teacher\_id**:
* Agrupa los resultados por `teacher_id`.
* Esto significa que todas las filas con el mismo `teacher_id` se agrupan juntas para calcular la suma de `n_reviews`.
6. **HAVING teacher IS NOT NULL**:
* Este filtro se aplica después de la agrupación.
* Asegura que solo se incluyan en los resultados los grupos donde el `teacher` no es nulo.
* En esta consulta, debido a la estructura, este `HAVING` no tiene un impacto significativo ya que `teacher` siempre tendrá un valor cuando `teacher_id` tenga un valor válido.
7. **ORDER BY total\_reviews DESC**:
* Ordena los resultados en orden descendente según el valor de `total_reviews`.
### Ejecución de la Consulta:
1. **Filtración Inicial**:
* La consulta primero filtra los cursos con al menos una review (`n_reviews > 0`).
2. **Agrupación**:
* Luego agrupa los cursos por `teacher_id`.
3. **Subconsulta de Selección**:
* Para cada grupo, ejecuta la subconsulta para encontrar el nombre del profesor correspondiente y lo selecciona como `teacher`.
4. **Suma de Reviews**:
* Calcula la suma total de `n_reviews` para cada grupo de `teacher_id`.
5. **Filtro HAVING**:
* Aplica el filtro `HAVING teacher IS NOT NULL`, aunque en este contexto no cambia el resultado ya que todos los `teacher_id` válidos tendrán un nombre de profesor correspondiente.
6. **Ordenación**:
* Finalmente, ordena los resultados por la suma total de reviews en orden descendente.
### Resultado Esperado:
La consulta devolverá una lista de profesores (con su nombre en la columna `teacher`) y la suma total de reviews de todos sus cursos (en la columna `total_reviews`), ordenada de mayor a menor según la cantidad total de reviews.
\--------------RESULTADO SIN USO DE JOIN--------------
`SELECT (SELECT name FROM teachers WHERE id = c.teacher_id) AS teacher, SUM(c.n_reviews) AS total_reviewsFROM courses cWHERE c.n_reviews > 0GROUP BY c.teacher_idORDER BY total_reviews DESC;`
Nuevamente una prueba que se necesita conocer temas que aún no explica. Les aconsejo ver el curso en YT del canal "Hola Mundo" antes de ver este curso, gracias a él pude realiar esta práctia y no por Platzi 
```python
SELECT teachers.name AS teacher, SUM(n_reviews) AS total_reviews
FROM courses
INNER JOIN teachers ON courses.teacher_id = teachers.id
WHERE teacher_id IS NOT NULL
GROUP BY teacher
HAVING total_reviews >= 1
ORDER BY total_reviews DESC;
```SELECT teachers.name AS teacher, SUM(n\_reviews) AS total\_reviewsFROM courses INNER JOIN teachers ON courses.teacher\_id = teachers.idWHERE teacher\_id IS NOT NULLGROUP BY teacherHAVING total\_reviews >= 1ORDER BY total\_reviews DESC;
Mi respuesta:
SELECT teacher\_id AS teacher, sum(n\_reviews) AS total\_reviews FROM courses
WHERE teacher\_id IS NOT NULL AND n\_reviews IS NOT NULL
GROUP BY teacher\_id
ORDER BY n\_reviews DESC;
Constantemente se plantea la dificultad de los ejercicios de este curso en los comentarios, principalmente a partir de sentencias no vistas aún. El punto es que los ejercicios son los mismos del curso Fundamentos para Bases de Datos (lo hice previo a éste), por lo que no son ejercicios del curso actual. Ahí está el inconveniente.
Esta es mi solución:
Mi respuesta
SELECT t.name as teacher,sum(n\_reviews) as total\_reviews FROM courses c INNER JOIN teachers t ON c.teacher\_id = t.idWhere c.n\_reviews > 0GROUP BY t.nameORDER BY total\_reviews DESC
mi aporte un saludo```txt
SELECT (
SELECT name FROM teachers -- name de la tabla teachers
where id=courses.teacher_id
) as 'teacher' ,
sum(n_reviews) as 'total_reviews'
FROM courses
where teacher_id is not null
group by teacher_id
order by total_reviews desc;
```
SELECT teachers.name AS teacher, SUM (n\_reviews) AS total\_reviewsFROM coursesLEFT JOIN teachers ON courses.teacher\_id = teachers.idWHERE teacher\_id IS NOT NULLGROUP BY teacher\_idORDER BY total\_reviews DESC;
Les dejo mi solución:
```txt
SELECT teachers.name AS teacher, SUM (n_reviews) AS total_reviews
FROM courses
LEFT JOIN teachers ON courses.teacher_id = teachers.id
WHERE teacher_id IS NOT NULL
GROUP BY teacher_id
ORDER BY total_reviews DESC;
```
dejo aqui mi solucion, recomiendo hacer sus queries con este formato para que les sea mas sencillo de leer al momento de volver a revisarlos.
`select `
`t.name as 'teacher', sum(c.n_reviews) as 'total_reviews'`
`from`
`courses.c`
`inner join`
`teachers t on c.teacher_id = t.id`
`group by`
`c.teacher_id`
`having`
`count(c.teacher_id) >= 1`
`order by`
`sum(c.n_reviews) desc;`
SELECT t.name AS teacher, SUM(c.n\_reviews) AS total\_reviewsFROM courses cJOIN teachers t ON c.teacher\_id = t.idGROUP BY t.nameORDER BY total\_reviews DESC;
select t.name as teacher, n.total as total\_reviews from ( SELECT teacher\_id, sum(n\_reviews) as totalFROM coursesgroup by teacher\_idhaving total>0 and count(teacher\_id)>0) as n, teachers as twhere t.id = n.teacher\_idorder by total\_reviews desc
![]()UFFFF ME TARDE MUCHO PERO LO HICE SIN CHATGPT PARA PODER HACER TODO DESDE CERO Y PRACTICAR.
PASO 1 CREAMOS LA DATABASE
```js
-- CREATE THE practica22 DATABASE
CREATE DATABASE practica22;
-- USE THE NEWLY CREATED DATABASE
USE practica22;
-- CREATE TABLE FOR courses
CREATE TABLE courses (
id INTEGER PRIMARY KEY NOT NULL,
name VARCHAR(100),
n_reviews INT,
teacher_id INT,
LOAD_DATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
UPDATE_DATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
-- CREATE TABLE FOR teachers
CREATE TABLE teachers (
id INTEGER PRIMARY KEY NOT NULL,
name VARCHAR(50),
LOAD_DATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
UPDATE_DATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
```PASO 2 INSERTAMOS DATOS
select \* from courses
```js
INSERT INTO courses (courses_id, name, n_reviews, teacher_id)
VALUES ('100', 'Fundamentos de Bases de Datos', '1400', '1');
INSERT INTO courses (courses_id, name, n_reviews)
VALUES ('200', 'Curso de MySQL y MariaDB', '400');
INSERT INTO courses (courses_id, name, n_reviews, teacher_id)
VALUES ('260', 'Curso de Data Science', '320', '8');
INSERT INTO courses (courses_id, name, n_reviews, teacher_id)
VALUES ('350', 'Curso de Firebase', '150', '1');
INSERT INTO courses (courses_id, name, n_reviews, teacher_id)
VALUES ('749', 'Curso de Python', '2300', '8');
INSERT INTO courses (courses_id, name, n_reviews, teacher_id)
VALUES ('750', 'Curso de React.js', '1500', '16');
```
select \* from teachers
```js
INSERT INTO teachers (teacher_id, name)
VALUES ('1', 'Israel');
INSERT INTO teachers (teacher_id, name)
VALUES ('8', 'Silvia');
INSERT INTO teachers (teacher_id, name)
VALUES ('16', 'Leomaris');
INSERT INTO teachers (teacher_id, name)
VALUES ('25', 'Juan');
```
```js
SELECT
teachers.name AS teacher,
SUM(courses.n_reviews) AS total_reviews
FROM courses
LEFT JOIN
teachers ON courses.teacher_id = teachers.teacher_id
WHERE
courses.teacher_id IS NOT NULL
GROUP BY teachers.name
ORDER BY total_reviews DESC;
```
Muy buenas,
Mi solución que en la ejecución da un resultado correcto, pero en las Pruebas falla es la siguiente....
`SELECT T.name AS teacher, SUM(C.n_reviews) AS total_reviewsFROM courses AS C, teachers AS TWHERE C.teacher_id = T.idAND C.n_reviews > 0GROUP BY T.nameORDER BY SUM(C.n_reviews) DESC;`
Para esta prueba (clase 22) es necesario usar un JOIN, pero eso no se explica sino en las siguientes clases.
SELECT teachers.name teacher, SUM(n\_reviews) total\_reviewsFROM courses LEFT JOIN teachers ON courses.teacher\_id=teachers.id WHERE teachers.id IS NOT NULL AND courses.n\_reviews >=1GROUP BY teachers.id ORDER BY total\_reviews DESC
Mi Solución
```sql
SELECT teachers.name as teacher, SUM(n\_reviews) as total\_reviewsFROM coursesINNER JOIN teachers ON teachers.id = teacher\_idGROUP BY teacher\_idORDER BY total\_reviews DESC;
```
```js
```
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?