No tienes acceso a esta clase

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

Curso Práctico de SQL

Curso Práctico de SQL

Israel Vázquez Morales

Israel Vázquez Morales

Egoísta (selfish)

18/29
Recursos

Aportes 178

Preguntas 19

Ordenar por:

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

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

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;

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?


-- 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;

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

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

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;```

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;

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;

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
;

Comparto el reto

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

  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

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

Me costó un poco entenderlo la primera vez porque me puse a buscar nombre y apellido de los tutores y no los encontraba. A partir de los comentarios entendí que los tutores son los mismos alumnos. Volví a ver la clase y en el minuto 3:50 el profesor incorpora “el supuesto” de que los alumnos sean también los tutores y por lo tanto el tutor_id se corresponde con el id del alumno.

RETO

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
INNER JOIN platzi.alumnos AS t on a.tutor_id=t.id
GROUP BY tutor
) AS promedio;

Hola! comparto mi solucion del ejercicio propuesto:

SELECT
	ROUND(AVG(conteo),1) AS prom_alumnos_por_tutor
FROM (SELECT 
			COUNT(DISTINCT id) AS conteo
			, tutor_id
		FROM platzi.alumnos
		GROUP BY tutor_id
	 ) AS num_alumnos_por_tutor

select avg(prom) as promedio
from (
select count(*) as prom
from platzi.alumnos
group by tutor_id
) tabla_prom

Mi solución del reto (postgreSQL):

SELECT AVG(cant_alumnos) AS promedio_alumnos_por_tutor
FROM(
SELECT CONCAT(t.nombre,' ', t.apellido) AS tutor, COUNT(*) cant_alumnos
FROM platzi.alumnos AS a
	INNER JOIN platzi.alumnos AS t
	ON a.tutor_id=t.id
GROUP BY tutor
	) AS alumnos_por_tutor
```js WITH alumnos_por_tutor AS ( 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 t.id, t.nombre, t.apellido ) SELECT AVG(alumnos_por_tutor) AS promedio_alumnos_por_tutor FROM alumnos_por_tutor; ```
```txt WITH alumnos_por_tutor AS ( 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 t.id, t.nombre, t.apellido ) SELECT AVG(alumnos_por_tutor) AS promedio_alumnos_por_tutor FROM alumnos_por_tutor; ```WITH alumnos\_por\_tutor AS (    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 t.id, t.nombre, t.apellido)SELECT     AVG(alumnos\_por\_tutor) AS promedio\_alumnos\_por\_tutorFROM     alumnos\_por\_tutor;
select avg(alumnos\_x\_tutor.alumnos\_por\_tutor) as promedio\_general 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 alumnos\_x\_tutor
Mi solución ```js select concat(b.nombre,' ',b.apellido) as tutor,round(avg(a.tutor_id),0) from platzi.alumnos as a join platzi.alumnos as b on a.tutor_id = b.id group by tutor; ```
select tutor, alumnos\_por\_tutor, avg(alumnos\_por\_tutor) 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) group by tutor, alumnos\_por\_tutor;
Quise sacar el promedio individual de cada tutor ```js -- Porcentajes de alumnos por tutor WITH total_alumnos AS ( SELECT COUNT(*) AS total FROM alumnos) , tutors AS ( SELECT CONCAT_WS(' ', t.nombre, t.apellido) AS tutor, COUNT(*) AS total_alumnos_por_tutor FROM alumnos AS a INNER JOIN alumnos AS t ON a.tutor_id = t.id GROUP BY tutor ORDER BY total_alumnos_por_tutor DESC ) SELECT t.* , ROUND(((t.total_alumnos_por_tutor::decimal / ta.total) * 100 ), 2) AS porcentaje FROM tutors AS t, total_alumnos AS ta ```-- Porcentajes de alumnos por tutor WITH total\_alumnos AS ( SELECT COUNT(\*) AS total FROM alumnos) , tutors AS ( SELECT CONCAT\_WS(' ', t.nombre, t.apellido) AS tutor, COUNT(\*) AS total\_alumnos\_por\_tutor FROM alumnos AS a INNER JOIN alumnos AS t ON a.tutor\_id = t.id GROUP BY tutor ORDER BY total\_alumnos\_por\_tutor DESC ) SELECT t.\* , ROUND(((t.total\_alumnos\_por\_tutor::decimal / ta.total) \* 100 ), 2) AS porcentaje FROM tutors AS t, total\_alumnos AS ta
```js SELECT AVG("Alumnos") AS Promedio_Alumnos_Por_Tutor FROM( SELECT CONCAT (t.nombre, ' ', t.apellido) AS "Nombre Tutor", COUNT (*) AS "Alumnos" FROM platzi.alumnos AS a INNER JOIN platzi.alumnos AS t ON a.tutor_id = t.id GROUP BY "Nombre Tutor") AS "Selfish_Table" ```
```css SELECT AVG("Alumnos") AS Promedio_Alumnos_Por_Tutor FROM( SELECT CONCAT (t.nombre, ' ', t.apellido) AS "Nombre Tutor", COUNT (*) AS "Alumnos" FROM platzi.alumnos AS a INNER JOIN platzi.alumnos AS t ON a.tutor_id = t.id GROUP BY "Nombre Tutor") AS "Selfish_Table" ```
```html SELECT AVG("Alumnos") AS Promedio_Alumnos_Por_Tutor FROM( SELECT CONCAT (t.nombre, ' ', t.apellido) AS "Nombre Tutor", COUNT (*) AS "Alumnos" FROM platzi.alumnos AS a INNER JOIN platzi.alumnos AS t ON a.tutor_id = t.id GROUP BY "Nombre Tutor") AS "Selfish_Table" ```
```python SELECT AVG("Alumnos") AS Promedio_Alumnos_Por_Tutor FROM( SELECT CONCAT (t.nombre, ' ', t.apellido) AS "Nombre Tutor", COUNT (*) AS "Alumnos" FROM platzi.alumnos AS a INNER JOIN platzi.alumnos AS t ON a.tutor_id = t.id GROUP BY "Nombre Tutor") AS "Selfish_Table" ```
```ts SELECT AVG("Alumnos") AS Promedio_Alumnos_Por_Tutor FROM( SELECT CONCAT (t.nombre, ' ', t.apellido) AS "Nombre Tutor", COUNT (*) AS "Alumnos" FROM platzi.alumnos AS a INNER JOIN platzi.alumnos AS t ON a.tutor_id = t.id GROUP BY "Nombre Tutor") AS "Selfish_Table" ```
```jsx SELECT AVG("Alumnos") AS Promedio_Alumnos_Por_Tutor FROM( SELECT CONCAT (t.nombre, ' ', t.apellido) AS "Nombre Tutor", COUNT (*) AS "Alumnos" FROM platzi.alumnos AS a INNER JOIN platzi.alumnos AS t ON a.tutor_id = t.id GROUP BY "Nombre Tutor") AS "Selfish_Table" ```
```tsx SELECT AVG("Alumnos") AS Promedio_Alumnos_Por_Tutor FROM( SELECT CONCAT (t.nombre, ' ', t.apellido) AS "Nombre Tutor", COUNT (*) AS "Alumnos" FROM platzi.alumnos AS a INNER JOIN platzi.alumnos AS t ON a.tutor_id = t.id GROUP BY "Nombre Tutor") AS "Selfish_Table" ```
```java SELECT AVG("Alumnos") AS Promedio_Alumnos_Por_Tutor FROM( SELECT CONCAT (t.nombre, ' ', t.apellido) AS "Nombre Tutor", COUNT (*) AS "Alumnos" FROM platzi.alumnos AS a INNER JOIN platzi.alumnos AS t ON a.tutor_id = t.id GROUP BY "Nombre Tutor") AS "Selfish_Table" ```
```c# SELECT AVG("Alumnos") AS Promedio_Alumnos_Por_Tutor FROM( SELECT CONCAT (t.nombre, ' ', t.apellido) AS "Nombre Tutor", COUNT (*) AS "Alumnos" FROM platzi.alumnos AS a INNER JOIN platzi.alumnos AS t ON a.tutor_id = t.id GROUP BY "Nombre Tutor") AS "Selfish_Table" ```
se podria ser mas corto, obviand concatenaciones, peroe s un alcance: ![](https://static.platzi.com/media/user_upload/image-4e8d5612-e7b1-428e-8a41-bf27b9c14153.jpg)
SELECT AVG(table\_A\_x\_t.alumnos\_por\_tutor) FROM( SELECT CONCAT(t.nombre,' ',t.apellido) AS tutor, COUNT(\*) AS alumnos\_por\_tutor FROM platzi.alumnos a INNER JOIN platzi.alumnos t ON a.tutor\_id= t.id GROUP BY tutor ) AS table\_A\_x\_t
```js SELECT AVG(alumnos_por_tutor) AS promedio FROM ( SELECT --CONCAT(a.nombre,' ',a.apellido) AS alumno, 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.tutor_id GROUP BY tutor ORDER BY alumnos_por_tutor )as Promedios ```SELECT AVG(alumnos\_por\_tutor) AS promedio FROM ( SELECT --CONCAT(a.nombre,' ',a.apellido) AS alumno, 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.tutor\_id GROUP BY tutor ORDER BY alumnos\_por\_tutor )as Promedios
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
		INNER JOIN platzi.alumnos AS t
		ON a.tutor_id = t.id
	GROUP BY tutor
);
📝 Solución al reto de esta clase: Promedio general de alumnos por tutor ```js SELECT ROUND(AVG(alumno_por_tutor), 3) AS promedio_alumnos_por_tutor FROM ( SELECT CONCAT(t.nombre, ' ', t.apellido) AS tutor, COUNT(*) AS alumno_por_tutor FROM platzi.alumnos AS a INNER JOIN platzi.alumnos AS t ON t.id = a.tutor_id GROUP BY tutor ) AS t_tutor; ```
Aqui mi reto: ![](https://static.platzi.com/media/user_upload/Screenshot%202024-04-22%2012.24.04-9bfc7467-3d56-48ed-bf20-eb76a052778c.jpg)
SELECT AVG(alumnos\_por\_tutor) as promedio\_por\_tutor 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 ```js SELECT AVG(alumnos_por_tutor) as promedio_por_tutor 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 ```
Para los que utilicen SQL Server (y puede que algun otro). En los GROUP BY no se pueden utilizar alias, entonces dentro del GROUP BY deben poner la concatenación de t.nombre y t.apellido. ```js SELECT CONCAT(t.nombre,' ',t.apellido) AS Tutor, COUNT (CONCAT (a.nombre,' ',a.apellido)) AS Alumnos_por_tutor FROM platzi.alumnos AS a INNER JOIN platzi.alumnos AS t ON a.tutor_id = t.id GROUP BY CONCAT(t.nombre,' ',t.apellido) ORDER BY Alumnos_por_tutor DESC; ```

Solución al reto

SELECT AVG(alumns_per_teacher.alumns) AS alumns_per_teahcer_avg
FROM (
	SELECT
	CONCAT(t.nombre, ' ', t.apellido) AS teachers,
	COUNT(*) AS alumns
	FROM platzi.alumnos AS a
	JOIN platzi.alumnos AS t ON a.tutor_id = t.id
	GROUP BY teachers
	ORDER BY alumns DESC
) AS alumns_per_teacher;
![](https://static.platzi.com/media/user_upload/image-c538ec41-10c4-43c4-84af-3a5a49d780f2.jpg)
Hola, mi opción: ``` select *a*.tutor\_id ,max(concat(*a*.nombre, ' ',*a*.apellido)) as *maxname* ,min(concat(*a*.nombre, ' ',*a*.apellido)) as *minname* from uni.alumnos *a* group by *a*.tutor\_id; ``` ![](https://static.platzi.com/media/user_upload/image-f9497174-4460-464a-834e-2e78c9851acf.jpg)
Esta fue mi solución: ```js SELECT AVG(alumnos_por_tutor) AS prom_por_tutor 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 prom_tutor; ```
Gracias por el tutorial
SELECT Concat(t.nombre,' ',t.apellido) AS Tutor, count(Concat(a.nombre,' ',a.apellido)) FROM platzi.alumnos AS a INNER JOIN platzi.alumnos AS t ON a.tutor\_id = t.id GROUP BY Tutor;
SELECT CONCAT(t.nombre, ' ', t.apellido) AS tutor, COUNT(\*) AS alumnos\_por\_tutor, AVG(COUNT(\*)) OVER () AS promedio\_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 LIMIT 10;

Valor Mínimo en Toda la Tabla alumnos:



SELECT MIN(colegiatura) AS minimo_total
FROM platzi.alumnos;



  • Esta consulta te devolverá el valor mínimo de la columna colegiaturaenalumnos.

Valor mínimo por tutor_id:


SELECT tutor_id, MIN(colegiatura) AS minimo_por_tutor
FROM platzi.alumnos
GROUP BY tutor_id;

En esta consulta, utilice la función MINjunto con GROUP BY tutor_idpara obtener el valor mínimo de la columna colegiaturapara cada tutor_id. Esto te dará el valor mínimo por cada tutor.

Mi solución al reto:

-- Promedio general por tutor de alumnos
SELECT CONCAT(t.nombre, ' ', t.apellido) AS tutor,
       AVG(COUNT(*)) OVER () AS promedio_de_alumnos 
FROM platzi.alumnos AS a
INNER JOIN platzi.alumnos AS t ON a.tutor_id = t.id
GROUP BY tutor
ORDER BY promedio_de_alumnos DESC;

Tómalo:

with taux as (
select concat(t.nombre, ' ', t.apellido) as tutor, count(*) as alumni_per_tutor 
from platzi.alumnos a
inner join platzi.alumnos t on a.tutor_id = t.id
group by tutor)
select round(avg(alumni_per_tutor),2) from taux

Así lo hice y me quedó bien, toy felí 😃

select avg(conteo.alumnos_x_tutor) as promedio_general
	from(
		select concat(t.nombre, ' ', t.apellido) as tutor,
		count(*) as alumnos_x_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 alumnos\_promedio 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;
Mi solución de la clase pasada: ```js SELECT MIN(nombre) FROM platzi.alumnos -- SELECT MIN(nombre), tutor_id FROM platzi.alumnos GROUP BY tutor_id ORDER BY tutor_id ```
Para sacar el promedio solicitado, no me es útil el INNER JOIN, a menos que haya entendido mal el ejercicio. Ví varias soluciones y algunas coinciden en ello.
select avg(al) from( select --concat(a.nombre, ' ',a.apellido)as alumno, concat(b.nombre, ' ',b.apellido)as tutor, count(\*) as al from platzi.alumnos as a inner join platzi.alumnos as b on a.tutor\_id=b.id group by tutor--, alumno order by al desc )as promedio;
-- Promedio general de alumnos por tutor
SELECT CONCAT(t.nombre,' ',t.apellido) AS tutor,
AVG(alumnos_conteo) AS alumnos_por_tutor
FROM (SELECT tutor_id, 
    COUNT(*) AS alumnos_conteo
    FROM platzi.alumnos
    GROUP BY tutor_id) AS a
INNER JOIN platzi.alumnos AS t ON a.tutor_id = t.id
GROUP BY tutor
ORDER BY alumnos_por_tutor DESC;

Aquí mi aporte:

SELECT CONCAT(t.nombre, ' ', t.apellido) AS tutor,
       COUNT(*) AS alumnos_por_tutor,
       AVG(COUNT(*)) OVER () AS promedio_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
LIMIT 5;

Mi solución, lo hice de dos maneras. Esta con el último código de la clase

SELECT AVG(alumnos_por_tutor) AS promedio_alumnos_por_tutor
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 cantidad;
	

Y esta más simplificada, solo cuento la cantidad de alumnos por tutor al agruparlos y saco el promedio de eso.

SELECT AVG(alumnos_por_tutor) AS promedio_alumnos_por_tutor
FROM (SELECT COUNT(*) AS alumnos_por_tutor
	  FROM platzi.alumnos
	  GROUP BY tutor_id
	 )AS cantidad;
---PROMEDIO DE ALUMNOS POR TUTOR--
SELECT AVG(alumnos_por_tutor) AS alumnos_promedio
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;

Reto: Promedio de tutores por carrera

SELECT AVG(tutores_unicos) AS Promedio_Tutores
FROM(
	SELECT platzi.carreras.carrera, t.tutores_unicos
		FROM(
			SELECT carrera_id, COUNT(DISTINCT tutor_id) AS tutores_unicos
			FROM platzi.alumnos
			GROUP BY carrera_id
			) AS t
		LEFT JOIN platzi.carreras ON t.carrera_id = platzi.carreras.id
)AS subconsulta

Se puede ignorar el Join, lo hice para ver cuantos tutores hay por carrera pero con la columna del nombre

--Promedio de alumnos por tutor

SELECT AVG(alumnos_por_tutor)
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 subconsulta

Reto: Sacar el prodio de alumnos que existen por tutor

SELECT CONCAT(t.nombre, ' ', t.apellido) AS tutor,
       COUNT(*) AS alumnos_por_tutor,
       AVG(COUNT(*)) OVER() AS promedio_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;

SELECT AVG(alumnos_por_tutor) AS promedio_alumnos_por_tutor
FROM (
    SELECT COUNT(*) AS alumnos_por_tutor
    FROM platzi.alumnos AS a
    INNER JOIN platzi.alumnos AS t ON a.tutor_id = t.id
    GROUP BY t.id
) AS consulta_promedio_alumnos_por_tutor;```

Reto

SELECT avg(datos.alumnos_por_tutor)
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 datos

Cuando el teacher realiza el siguiente codigo

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

sale el nombre del alumno por cada tutor, pero no queda esta informacion en la misma fila, asi que para que por cada fila o organizar los nombres de todos los alumnos por tutor realice el siguiente codigo, por si alguien le llama la atencion.

SELECT CONCAT(t.nombre, ' ', t.apellido) AS tutor,
       (SELECT STRING_AGG(CONCAT(a.nombre, ' ', a.apellido), ', ')
        FROM platzi.alumnos AS a
        WHERE a.tutor_id = t.id) AS alumnos
FROM platzi.alumnos AS t;

--RETO CLASE SELFISH

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

mi solucion

-- Selecciona el promedio de alumnos por tutor y lo renombra como "promedio"
SELECT AVG (alumnos_por_tutor) AS promedio
FROM (
    -- Selecciona el nombre y apellido del tutor y cuenta el número de alumnos asignados a cada tutor
    SElECT CONCAT ( t.nombre, ' ', t.apellido) AS tutor, 
           COUNT (*) AS alumnos_por_tutor
    FROM platzi.alumnos AS a
    -- Une la tabla de alumnos con la tabla de tutores en base al ID del tutor
    INNER JOIN platzi.alumnos AS t
    ON a.tutor_id = t.id
    -- Agrupa los resultados por tutor
    GROUP BY tutor
    -- Ordena los resultados en orden descendente por el número de alumnos
    ORDER BY alumnos_por_tutor DESC
) AS promedio_general; -- Renombra la subconsulta como "promedio_general"

Creo que esta opcion es mas eficiente

select 	concat(t.nombre,' ', t.apellido) as tutor,
		round(count(*) * 100.0 / (SELECT count(*) 
		FROM platzi.alumnos), 2) as porcentaje_por_tutor
from platzi.alumnos as t
	inner join platzi.alumnos as a on a.tutor_id = t.id
group by tutor
order by porcentaje_por_tutor  desc
limit 5

Mi respuesta al reto:

Me da un promedio de 33 estudiantes promedio por tutor.

SELECT
	ROUND(AVG(alumnos_tutor),0) AS alumnos_promedio_tutor
FROM
	(SELECT 
		CONCAT(t.nombre,' ',t.apellido) AS tutor,
		COUNT(*) alumnos_tutor
	FROM platzi.alumnos a
	INNER JOIN platzi.alumnos t
	ON a.tutor_id = t.id
	GROUP BY tutor
	ORDER BY alumnos_tutor DESC) AS alumnos_tutor;

Yo solo le veo utilidad en tablas recursivas.

Solucion PG admin

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;

“me quedo grande muchachos, que bendición ve”

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

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
		INNER JOIN platzi.alumnos AS t ON a.tutor_id = t.id
	GROUP BY tutor
) AS data

select tutor_id,
MIN (nombre)
from platzi.alumnos
group by tutor_id
order by tutor_id

mi solucion al reto del promedio de alumnos por tutor

select avg(alumnos_tutor.cantidad)  from 
	(select  
		concat(t.nombre, ' ',t.apellido) as tutor,
		count(a.id) cantidad
		from alumnos a 
	inner join alumnos t on t.id = a.tutor_id
	group by t.nombre, t.apellido) as alumnos_tutor;

Mi solución al reto de promedio

WITH 
  a1 
  	AS 
  (
	 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
  )
  
SELECT avg (a1.alumnos_por_tutor)
FROM a1

SELECT MIN(nombre)
FROM platzi.alumnos;

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

Solución Reto anterior:

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

Solución al reto de la clase.

PD: El promedio de estudiantes por tutor me dió 33.33 para cada tutor, no sé si el dato es correcto. Me dejan saber en los comentarios

SELECT
	tutor,
	alumnos_por_tutor,
	(SELECT AVG(alumnos_por_tutor) FROM (
		SELECT
			CONCAT(t.nombre, ' ', t.apellido) AS tutor,
			COUNT(a.tutor_id) 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 subquery) AS avg_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 subquery

Me siento toda hacker 😛

SELECT AVG(l.alumnos_por_tutor) AS avg_alumnos_por_tutor
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 l;

para que se viera mas limpio propuse esta solución

WITH alumnos_por_tutor as 
(
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
)
SELECT AVG(alumnos_por_tutor) FROM alumnos_por_tutor

Curiosamente el operador / en Postgresql se toma más como división modular que división normal. Toca usar casts y un poco de matemáticas (potenciación) para obtener el número sin necesidad de JOINs.

SELECT ROUND(COUNT(*) * (COUNT(DISTINCT(tutor_id))::numeric^(-1.0)),2)
FROM platzi.alumnos;

Un poco a mi manera pero que felicidad haberlo hecho.

SELECT CONCAT(b.nombre,' ',b.apellido) AS nombre_tutor,
       COUNT(*) as numero_alumnos
FROM platzi.alumnos a
INNER JOIN platzi.alumnos b
           ON a.tutor_id = b.id
GROUP BY nombre_tutor
ORDER BY numero_alumnos DESC
LIMIT 5;

Mi solucion:

SELECT AVG(total.alumnos_por_tutor)
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 total 

Sobre el tema del MIN cuando es de tipo varchar no funciona tan bien como creemos
Ejemplo:

select min(nombre) from platzi.alumnos limit 1

Esto nos va a devolver el nombre ‘Abbey’ pero esto es incorrecto ya que existen nombres mas ‘chicos’

Para solucionar esto podemos hacer algo asi

select nombre from platzi.alumnos 
order by length(nombre) asc limit 1

Esto nos va a devolver ‘Cy’ ya que ordenamos los nombres por caracter

No era necesario unir la tabla con si misma

select avg(tutor.count)
from(
	select tutor_id, count(*) from platzi.alumnos group by tutor_id
	)
	as tutor;

la solucione de esta forma

SELECT min(nombre),max(tutor_id)
FROM platzi.alumnos
limit 1



select min(nombre),tutor_id
FROM platzi.alumnos
group by(tutor_id)

RETO
Obtener el promedio general de la cantidad de alumnos por tutor.


  • Solución 1:
SELECT ROUND(AVG(alumnos_por_tutor),2) promedio_general
FROM (
SELECT CONCAT(t.nombre, ' ', t.apellido) AS tutor, COUNT(*) AS alumnos_por_tutor
FROM platzi.alumnos a
INNER JOIN platzi.alumnos t ON a.tutor_id = t.id
GROUP BY tutor
ORDER BY alumnos_por_tutor DESC
) tutor_alumnos;

ADICIONAL 1
Obtener el porcentaje de la cantidad de alumnos por cada tutor.


  • Solución:
SELECT tutor, alumnos_por_tutor, ROUND((alumnos_por_tutor::decimal(18,2)/total_alumnos)*100,2) porcentaje
FROM (
	SELECT 
		CONCAT(t.nombre, ' ', t.apellido) AS tutor, 
		COUNT(*) alumnos_por_tutor,
		(SELECT COUNT(*) FROM platzi.alumnos) total_alumnos
	FROM platzi.alumnos a
	INNER JOIN platzi.alumnos t ON a.tutor_id = t.id
	GROUP BY tutor
) t1;

ADICIONAL 2
Seleccionar la cantidad de alumnos y cuántas carreras enseña por cada tutor.


  • Solución:
SELECT  
	t.id cod_tutor,
	CONCAT(t.nombre, ' ', t.apellido) AS tutor, 
	COUNT(*) alumnos_por_tutor,
	COUNT(DISTINCT a.carrera_id) carreras_por_tutor
FROM platzi.alumnos a
INNER JOIN platzi.alumnos t ON a.tutor_id = t.id
GROUP BY cod_tutor, tutor;

Tambien para concatener en postgre existe la funcion concat_ws

concat_WS(' ',a.nombre,a.apellido) AS ALUMNO

eso ayuda a que no quede ese espacio al final que deja concat cuando solo habia un nombre

el reto pero desde el punto de vista del promedio de alumnos por carrera.

--Promedio de Alumnos que tiene cada carrera
SELECT AVG(Curso_Alumno) AS Promedio_Alumnos_Cursos
FROM(
	SELECT c.carrera_id AS Curso, COUNT(*) AS Curso_Alumno
	FROM platzi.alumnos AS a
	INNER JOIN platzi.alumnos AS c ON a.carrera_id = c.id
	GROUP BY Curso, a.carrera_id
	ORDER BY Curso_Alumno DESC
) AS Promedio


El Alias del SUb-Query Tu_Es significa (Tutor - Estudiantes)

Solución del reto

-- promedio de alumnos por tutor
select ROUND(avg(alumno_por_tutor))
from(
	select concat(t.nombre,' ',t.apellido) as tutor,
		count(*) as alumno_por_tutor
	from platzi.alumnos as a
		inner join platzi.alumnos as t on a.tutor_id = t.id
group by tutor
) as asignados;

Respuesta a la practica

select min(nombre) from platzi.alumnos

select tutor_id, min(nombre) from platzi.alumnos
group by tutor_id
order by tutor_id