Egoísta (selfish)

ESNEIDER ALBERTO BARRERA JARAMILLO

student•

solución reto:

SELECT AVG(alumnos_por_tutor) AS promedio_alumnos
FROM(
SELECT CONCAT(t.nombre,' ',	t.apellido) AS tutor,
		COUNT(*)   AS alumnos_por_tutor
FROM platzi.alumnos AS a
	INNER JOIN platzi.alumnos AS t ON a.tutor_id=t.id

GROUP BY tutor	
ORDER BY alumnos_por_tutor DESC
) AS promedio
--Experimento-- 
--promedio de tutores por carrera--
SELECT AVG(dc.tutor_por_carrera)
FROM(
	-- seleciona cuantas tutorias realiza en una carrera--
SELECT 	CONCAT(t.nombre,' ',	t.apellido) AS tutor,
		COUNT(*) AS tutor_por_carrera,
		a.carrera_id
FROM platzi.alumnos AS a
	INNER JOIN platzi.alumnos AS t ON a.tutor_id=t.id 
			AND a.carrera_id=t.tutor_id
GROUP BY tutor, a.carrera_id	
ORDER BY tutor_por_carrera DESC) AS dc

David Amador Morales

student•

Buen ejercicio, gracias por el aporte, Esneider.

Alejandro Jose Ysea Gonzalez

student•

Excelente, totalmente necesario!

Adrian Duran

student•

Lo que hace este query es asumir que el tutor con el tutor_id X de cada alumno es otro alumno con el mismo id, por eso te muestra los nombres y apellidos de profesores cuando en la table esta información no está, solo tenemos los nombres y apellidos de alumnos. Saludos

SELECT	a.nombre,
		a.apellido,
		t.nombre,
		t.apellido
FROM	platzi.alumnos AS a
	INNER JOIN platzi.alumnos AS t ON a.tutor_id = t.id;

Aaron Quiroga

student•

Gracias por ponerlo en palabras más claras que ayudan a entenderlo mejor

Isaias Castañeda

student•

gracias por tu comentario, estaba buscando esa informacion y estas en lo correcto, vine a confirmar y es asi, la info de los profesores no esta en la tabla, solo el id.

Jean Carlos Palencia Molina

student•

Si no estoy mal, al hacer:

INNER JOIN platzi.alumnos AS t ON a.tutor_id = t.id

también estamos asumiendo que todos los 30 tutores son alumnos, pero no todos los alumnos son tutores ¿No?

Daniel Eishu Oyama Arevalo

student•

Así es, no todos los alumnos son tutores, solo los primeros 30 son tutores, estuvo un poco confuso el ejercicio y por suerte ningún alumno es tutor de si mismo, pero si esta bien tu lógica.

José Rodrigo Arana Hi

student•

exacto

Diego Hermoso

student•


-- Promedio General de alumnos por tutor 
SELECT AVG(n_alumnos) AS promedio_alumnos
FROM (
     SELECT COUNT(*) AS n_alumnos FROM alumnos
     GROUP BY tutor_id
         ) AS tabla_num_alumnos_por_tutor;

William Leonardo Torres Toloza

student•

Muy sencillo y buen hecho, gracias bro Acá lo dejo para postgreSQL

SELECT AVG(n_alumnos) AS promedio_alumnos
FROM (
     SELECT COUNT(*) AS n_alumnos FROM platzi.alumnos
     GROUP BY tutor_id
         ) AS tabla_num_alumnos_por_tutor;

Jesús David García Cuello

student•

Wow, está realmente bien hecha esta solución. Me gustaría explicarla en mis palabras, de cómo yo la entendí:

En esta propuesta, el subquery dentro de FROM ( ... ) cuenta la cantidad de alumnos de cada tutor. Así pues, en el resultado, cada fila es un tutor (único, no repetido) y el campo n_alumnos de cada fila será la cantidad de alumnos de cada tutor. Finalmente, la función AVG suma todos los valores de n_alumnos (hallando el total de alumnos) y divide entre la cantidad total de filas (total de tutores).

Juan Pablo Cuenca Ludeña

student•

TIP: Si no les quedó claro el SELF JOIN

Era más sencillo si nos mostraba todos los campos primero al hacer el self join, ahí es evidente como se "cruzan" las tablas y el uso de las claves foráneas y primarias.

SELECT *
FROM platzi.alumnos AS a JOIN platzi.alumnos AS t 
	   ON a.tutor_id = t.id

A la izquierda (azul) está la tabla de alumnos y la derecha (amarillo) la tabla de "tutores" que en realidad es la misma tabla de alumnos, pero trae los datos del alumno que tenga el id del tutor que está a la izquierda. Ese join se lo ve claramente en color verde.

Dato extra: Los tutores son los primeros 30 estudiantes

Juan Esteban Bolívar Ferrer

student•

Aprecio mucho el tiempo para explicar esto, gracias!

Juan Pablo Cuenca Ludeña

student•

Esa es la idea tocayo, a veces uno tiene que darle las vueltas a las cosas para entender las cosas. Cuando uno enseña, dos aprenden.

Enzo Rafael Cárdenas Nicho

student•

Por qué en el último ejecicio, la query reconoce lo siguiente:

GROUP BY tutor

tengo entendido, o bueno lo había leído, que el GROUP BY es leído antes del SELECT, por lo tanto aún no existiría la columna tutor.

Estoy mal? esto me ha confudido un poco.

Gracias :)

Alvaro Javier Arango Guete

student•

Tengo esa misma duda, de hecho por los errores que me esta dando al intentar realizar el reto, me parece que GROUP BY estaría despues de SELECT. Alguien que nos pueda explicar? Gracias!

José Rodrigo Arana Hi

student•

En efecto, lee que debe agrupar la columna "tutor" y luego va y lo busca dentro de SELECT y que lo encuentra como un alias. Entonces, me imagino que debe de haber una condicional de si existe o no, en este caso SÍ existe y continua con el query.

Aaron Quiroga

student•

++SELF JOINS++

Personalmente considero que a la hora de hacer self-joins es de especial importancia más que en otros casos el hecho de comentar el código
En este caso aclararía en el código que recurrí a esta técnica, ya que los tutores a la vez son alumnos, de ahí que puedo obtener toda la información de la propia tabla

++RETO: Promedio de alumnos por tutor++

Anthony Guzman Lopez

student•

Mi respuesta el ejercicio de promedio

SELECT round((SUM(qq.alumnos_por_tutor) / COUNT(tutor)),0) as promedio
FROM (
	SELECT CONCAT(t1.nombre, ' ', t1.apellido ) AS tutor,
		   COUNT(*) AS alumnos_por_tutor
		   
	FROM platzi.alumnos AS t0
	INNER JOIN platzi.alumnos AS t1 ON t0.tutor_id = t1.id
	GROUP BY tutor
) QQ;```

Wilford Giuseppe Camargo Quesada

student•

Entendí q es lo de** t. **y a., pero no entiendo su funcionamiento ni por que existen antes de que se cree el alias?

Carlos S. Aldazosa

student•

Lo que pasa es que el SELECT es ejecutado luego del FROM y cualquier JOIN. Ya que primero se necesita que la informacion con la que se va a trabajar (las tablas) y luego se "filtra" las columnas u operaciones con estas en el SELECT.

ivan josue ortiz alban

student•

de donde salen los nombre y apellidos del tutor , si en tabla completa solo hace referencia al codigo unico de cada tutor unido al nombre y apellido del alumno pero no del tutor

German Gerardo Guerci

student•

Por que hay alumnos que son tutores, aunque no todos los tutores son alumnos, esta medio confuso pero parece que fue la manera mas facil de explicar los SELF JOIN.

Miguel Angel Cáceres Valdivia

student•

En la tabla alumnos hay un campo tutor_id que hace referencia al id de la tabla alumno, es una tabla recursiva. Donde algunos alumnos son a la vez tutores pero no todos los alumnos son tutores.

Alexander Sebastian Jaramillo Ordiales

student•

SELFISH

Selfjoins Hacer uniones entre columnas de la misma tabla.

Por lo que básicamente seleccionamos las columnas y les es asignamos sub tablas

SELECT a.nombre t.nombre

Asiganamos alias (a , t) a las nuevas tablas que queremos comparar, y ejecutamos el join

select a.nombre, a.apellido, t.nombre,t.apellido 
from platzi.alumnos AS a
	INNER JOIN platzi.alumnos AS t on a.tutor_id = t.id;

Jhon Manuel Angulo Moncada

student•

Un dia ayudando a un compañero describi que existe CONCAT_WS y me gusta mas que el CONCAT, sobre todo cuando tienes que unir muchos campos.

SELECT CONCAT_WS(' ', a.nombre, a.apellido) AS alumno,
		CONCAT_WS(' ', t.nombre, t.apellido) AS tutor
FROM platzi.alumnos AS a
INNER JOIN platzi.alumnos as t ON a.tutor_id = t.id;

Alvaro Javier Arango Guete

student•

Me costó mucho entenderlo, y tuve que ver algunos comentarios para este reto. Al final resultó de esta forma:

SELECT AVG(conteo.alumnos_por_tutor) AS promedio_alumnos
FROM(SELECT CONCAT(t.nombre, ' ', t.apellido) AS tutor, 
	COUNT(*) AS alumnos_por_tutor 
	FROM platzi.alumnos AS a INNER JOIN platzi.alumnos AS t ON (a.tutor_id = t.id)
	GROUP BY tutor) AS conteo
;

María Paula Zamora Ospitia

student•

Comparto el reto

SELECT tutor_id, Min(nombre) FROM platzi.alumnos GROUP BY tutor_id ORDER BY tutor_id;

Andrés David Lizarazo Becerra

student•

  SELECT AVG(alumnos_por_tutor) as promedio
FROM (
	SELECT CONCAT(t.nombre,' ',	t.apellido) AS tutor, COUNT(*) AS alumnos_por_tutor
	FROM platzi.alumnos AS a
	JOIN 
		 platzi.alumnos AS t 
	ON a.tutor_id = t.id
	GROUP BY tutor
) As promedio

karen gonzalez

student•

si alguien pudiera ayudarme, por fa, no comprendo como funciona la relacion entre

a.tutor_id = t. id

Carlos Eduardo Gomez García

teacher•

¡Hola! Es sencillo, tienes tu tabla "a" y tu tabla "t" y quieres juntar ambas, pero necesitas un campo en común para juntarlas, entonces uasas la relación:

a.tutor_id = t.id

¿Esto que significa? Bueno, podríamos leerlo algo así:

De la tabla a, vas a tomar la columna "tutor_id" y los vas a juntar con la columna "id" de la tabla t cuando ambos sean iguales

Es decir, supón estas dos tablas:

Tabla a

tutor_id	telefono
1	1235679
2	1235679
3	1235679

Tabla t

nombre	id
juan	1
maria	2
jaime	3

La relación a.tutor_id = t.id va a buscar los números que sea iguales tantp en la columna id de la tabla t como en la columna tutor_id de la tabla a y va a juntar las filas, por lo que tu tabla final quedaría así:

t.nombre	`t.id`	a.tutor_id	a.telefono
juan	1	1	1235679
maria	2	2	1235679
jaime	3	3	1235679

Es básicamente eso :D

Juan Carlos Hernández

student•

Hola! tutor_id y id son columnas que existen en las tablas a y t, respectivamente. Cuando el profesor pone a.tutor_id = t. id está dando la instrucción de traer los registros en que los valores en esas columnas son iguales.

Andres Alvarez Mazo

student•

Hola, tengo una pregunta, a partir del siguiente query, como podría agregarle la columna del nombre del tutor y así saber el promedio de alumnos por tutor, ya que esta query solo me arroja una única celda numérica haciendo referencia al promedio y lo que quiero son dos columnas (nombre tutor, promedio). Gracias, saludos

<SELECT AVG(alumnos_por_tutor) AS promedio_alumnos
FROM(
SELECT CONCAT(t.nombre,' ',	t.apellido) AS tutor,
		COUNT(*)   AS alumnos_por_tutor
FROM platzi.alumnos AS a
	INNER JOIN platzi.alumnos AS t ON a.tutor_id=t.id
GROUP BY tutor	
ORDER BY alumnos_por_tutor DESC
) AS promedio;>

Carlos S. Aldazosa

student•

Hola, Andres! . No se puede obtener un nombre de tutor para el promedio de alumnos, ya que la operacion que se esta haciendo es la siguiente: . total_alumnos = 1000 total_tutores = 30 promedio_alumnos_tutor = 1000 / 30 . Se entiende que por cada tutor (30) existe en promedio 33.33 alumnos. . Saludos 🙋🏾‍♂️

xavier alberto castillo varon

student•

¿ por que se me esta demorando tanto para hacer los querys en pgadmin4 , hay consultas que duran has mas de 5 minutos?

Sebastian Rodriguez

student•

ESo me sucede a mi tambien, y creeria que es por la RAM de nuestros PCs, el mio tiene una de 4GB pero lo he hecho en otro de 8 GB y es mucho mas rapido. Pero tal vez tambien puede ser errores de instalacion.

Joel Sierra Mendoza

student•

Tengo una pregunta desde el curso anterior y es, ¿Cómo se insertan TODOS los miles o millones de datos diarios a la database?

Jhins Ledys Cárdenas Pardo

student•

En el minuto 2:03 el resultado del Query NO ESTÁ ORDENADO ALFABETICAMENTE, esta ordenado es por tutor_id. Si se fijan, el registro 1 empieza por AL... y el registro 2 empieza por AD y alfabeticamente esta primero la D que la L. . Entonces para que quede ordenado alfabeticamente se debe asignar un alias al resultado de la funcion MIN y ordenar el query en base a ese alias, asi:

SELECT tutor_id,
	MIN (nombre) AS minimo
FROM platzi.alumnos
GROUP BY tutor_id
ORDER BY minimo; -- El resultado es el MIN ordenado alfabeticamente

SELECT AVG(alumnos_por_tutor) AS promedio_alumnos
FROM(
SELECT CONCAT(t.nombre,' ',	t.apellido) AS tutor,
		COUNT(*)   AS alumnos_por_tutor
FROM platzi.alumnos AS a
	INNER JOIN platzi.alumnos AS t ON a.tutor_id=t.id

GROUP BY tutor	
ORDER BY alumnos_por_tutor DESC
) AS promedio
--Experimento-- 
--promedio de tutores por carrera--
SELECT AVG(dc.tutor_por_carrera)
FROM(
	-- seleciona cuantas tutorias realiza en una carrera--
SELECT 	CONCAT(t.nombre,' ',	t.apellido) AS tutor,
		COUNT(*) AS tutor_por_carrera,
		a.carrera_id
FROM platzi.alumnos AS a
	INNER JOIN platzi.alumnos AS t ON a.tutor_id=t.id 
			AND a.carrera_id=t.tutor_id
GROUP BY tutor, a.carrera_id	
ORDER BY tutor_por_carrera DESC) AS dc

-- Promedio General de alumnos por tutor 
SELECT AVG(n_alumnos) AS promedio_alumnos
FROM (
     SELECT COUNT(*) AS n_alumnos FROM alumnos
     GROUP BY tutor_id
         ) AS tabla_num_alumnos_por_tutor;

SELECT round((SUM(qq.alumnos_por_tutor) / COUNT(tutor)),0) as promedio
FROM (
	SELECT CONCAT(t1.nombre, ' ', t1.apellido ) AS tutor,
		   COUNT(*) AS alumnos_por_tutor
		   
	FROM platzi.alumnos AS t0
	INNER JOIN platzi.alumnos AS t1 ON t0.tutor_id = t1.id
	GROUP BY tutor
) QQ;```

SELECT AVG(conteo.alumnos_por_tutor) AS promedio_alumnos
FROM(SELECT CONCAT(t.nombre, ' ', t.apellido) AS tutor, 
	COUNT(*) AS alumnos_por_tutor 
	FROM platzi.alumnos AS a INNER JOIN platzi.alumnos AS t ON (a.tutor_id = t.id)
	GROUP BY tutor) AS conteo
;

  SELECT AVG(alumnos_por_tutor) as promedio
FROM (
	SELECT CONCAT(t.nombre,' ',	t.apellido) AS tutor, COUNT(*) AS alumnos_por_tutor
	FROM platzi.alumnos AS a
	JOIN 
		 platzi.alumnos AS t 
	ON a.tutor_id = t.id
	GROUP BY tutor
) As promedio

tutor_id

telefono

1235679

nombre

juan

maria

jaime

t.nombre

t.id

a.tutor_id

a.telefono

juan

1235679

maria

1235679

jaime

1235679

<SELECT AVG(alumnos_por_tutor) AS promedio_alumnos
FROM(
SELECT CONCAT(t.nombre,' ',	t.apellido) AS tutor,
		COUNT(*)   AS alumnos_por_tutor
FROM platzi.alumnos AS a
	INNER JOIN platzi.alumnos AS t ON a.tutor_id=t.id
GROUP BY tutor	
ORDER BY alumnos_por_tutor DESC
) AS promedio;> 

Egoísta (selfish)

Introducción a SQL

Breve historia de SQL

Álgebra relacional

Instalación de la BD de ejemplo

Qué es una proyección (SELECT)

Origen (FROM)

Productos cartesianos (JOIN)

Selección (WHERE)

Ordenamiento (ORDER BY)

Agregación y limitantes (GROUP BY y LIMIT)

Ejercitando tu SQL

El primero

El segundo más alto

Seleccionar de un set de opciones

En mis tiempos

Seleccionar por año

Duplicados

Selectores de rango

Eres lo máximo

Egoísta (selfish)

Resolviendo diferencias

Todas las uniones

Triangulando

Generando rangos

Regularizando expresiones

Conceptos de SQL Avanzado

Bases de datos distribuidas

Queries distribuídos

Sharding

Window functions

Particiones y agregación

El futuro de SQL