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 146

Preguntas 19

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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 鈥渃ruzan鈥 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 鈥渢utores鈥 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;```

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
;

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;

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 鈥渆l 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

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;

鈥渕e 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 鈥楢bbey鈥 pero esto es incorrecto ya que existen nombres mas 鈥榗hicos鈥

Para solucionar esto podemos hacer algo asi

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

Esto nos va a devolver 鈥楥y鈥 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

reto:

SELECT AVG(cantidad_alumnos) AS promedio_alumnos_por_tutor
FROM (
	SELECT
		CONCAT (t.nombre,' ', t.apellido) AS tutor,
		COUNT (*) AS cantidad_alumnos
	FROM platzi.alumnos a
	INNER JOIN platzi.alumnos t ON a.tutor_id= t.id
	GROUP BY tutor
) AS tutor_cantidad_alumnos

Mi reto:

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

Si quieres saber el numero de estudiantes por tutor, con un query r谩pido lo puedes hacer:

SELECT tutor_id, count(*) as alumnos from platzi.alumnos
groupby tutor_id
orderby alumnos desc;

Pero ahora, queremos saber quienes son estos tutor_ids, que por cierto, tambi茅n son alumnos. Se trabaja sobre el mismo query, haciendo un **join ** a la misma tabla, alumnos:

SELECT a.tutor_id, count(*) as alumnos from platzi.alumnos as a
JOIN platzi.alumnos as b
ON a.tutor_id = b.id
groupby a.tutor_id
orderby alumnos desc;

Bien, como ya est谩 relacionado, todo tutor_id en a hace referencia a un alumno_id de la tabla b, entonces solo nos traemos el nombre del alumno en b que ser谩 tutor en la tabla a

SELECT b.nombre as tutor, count(*) as alumnos FROM platzi.alumnos as a
JOIN platzi.alumnos as b
ON a.tutor_id = b.id
GROUPby tutor
ORDERby alumnos desc;
SELECT AVG(alumnos)
FROM (SELECT
        concat(c.nombre, ' ', c.apellido) as tutor,
        count(*) alumnos
    FROM platzi.alumnos as a
    join platzi.alumnos as c
    on a.tutor_id = c.id
    GROUP by tutor
    order by alumnos desc
) as averaging;

Reto: La segunda forma es m谩s r谩pida

/*1RA FORMA: Promedio de alumnos por tutor*/
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 alumnos_tutor
	 
/*2DA FORMA: Promedio de alumnos por tutor*/
SELECT (SUM(alumnos_por_tutor)/ COUNT(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 alumnos_tutor

Mi soluci贸n del reto:

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

Una soluci贸n al reto:

SELECT AVG(promedio_alumnos_por_tutor) AS promedio_alumnos_tutor
FROM (SELECT CONCAT(t.nombre, ' ', t.apellido) AS tutor,
		COUNT(*) 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 promedio_alumnos_por_tutor
) AS promedio;
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 alumnos_grupo;
SELECT tutor_id, MIN(nombre)
FROM platzi.alumnos
GROUP BY tutor_id;

Esta fue la soluci贸n al reto propuesto y un reto personal adicional:

/* RETO: Sacar el promedio de alumnos por tutor */

SELECT AVG(test)
FROM(
	SELECT CONCAT (al.nombre,' ', al.apellido) AS tutor,  COUNT(*) AS test
	FROM platzi.alumnos as al
	INNER JOIN platzi.alumnos as ab
	ON al.id =ab.tutor_id
	GROUP BY tutor
	
)AS test

/*Reto Personal: Promedio de tutorores por carrera*/

SELECT carrera, AVG(cantidad_tutorias_carrera) AS t
FROM (
	SELECT CONCAT(a1.carrera_id) AS carrera, COUNT(*) AS cantidad_tutorias_carrera
	FROM platzi.alumnos AS a1
	INNER JOIN platzi.alumnos AS a2
	ON a1.id = a2.tutor_id
	GROUP BY carrera
	ORDER BY carrera ASC
) AS calculo
GROUP BY carrera
ORDER BY t ASC;

Podemos agregarle la carrera de la tutor铆a de la siguiente manera:

FROM(
SELECT CONCAT(t.nombre, ' ', t.apellido) AS tutor,
	COUNT(*) AS tutorias_por_carrera, c.carrera
FROM platzi.alumnos AS a
	INNER JOIN platzi.alumnos AS t
	ON a.tutor_id = t.id-----relacion del id del alumno con el id del tutor, un SELF JOIN
	INNER JOIN platzi.carreras AS c
	ON c.id = t.tutor_id
--WHERE c.vigente = true
GROUP BY tutor, c.carrera
ORDER BY tutorias_por_carrera DESC;

Soluci贸n al reto:

  1. El m铆nimo del nombre en toda la tabla:
SELECT nombre
FROM platzi.alumnos
GROUP BY nombre
ORDER BY nombre
LIMIT 1;
  1. EL m铆nimo del nombre por tutor_id:
SELECT MIN(nombre), tutor_id
FROM platzi.alumnos
GROUP BY tutor_id
ORDER BY tutor_id;
from(SELECT count(*) as alumnos_por_tutor 
  FROM alumnos as a_
      INNER join alumnos as t_
      on a_.tutor_id = t_.id
  GROUP by t_.id)as est_por_tut;麓麓麓

El reto del promedio de alumnos:

SELECT AVG(alumnos_por_tutor) as promedio_de_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 numero_alumnos_tutor;

Desaf铆o:

-- Reto: promedio general 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 tabla_alumnos_por_tutor;

Soluci贸n al reto de la clase pasada

-- el m铆nimo por tabla
select *
from platzi.alumnos
order by nombre asc
limit 1;

-- el m铆nimo por tutor id
select tutor_id, min(nombre)
from platzi.alumnos
group by tutor_id
order by tutor_id;
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
	) AS promedio

Soluci贸n al reto:

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

Reto de la clase, encontrar el promedio de alumnos por tutores

驴Cu谩ntos alumnos tiene cada tutor?

Selfjoin y CONCAT para unir campos

Introducci贸n a selfjoins, alumnos y tutores

Solucion de la tarea encontrar valores m铆nimos

Soluci贸n al reto:

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
	ORDER BY alumnos_por_tutor DESC
) AS tutor_alumnos;

Resultado:
33.33333333

Mi soluci贸n al reto, no se si sea muy deportivo pero fue como lo pens茅:馃馃徑

SELECT COUNT(id) / COUNT(DISTINCT(tutor_id)) AS promedio_alumnosXtutor
FROM platzi.alumnos

Reto 7:

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

RETO

As铆 qued贸

-- El promedio de alumnos por tutor --
SELECT AVG(tutores.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 tutores;

MI soluci贸n del 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 
	ORDER BY alumnos_por_tutor DESC
	) as tabled
SELECT COUNT (DISTINCT id) / COUNT (DISTINCT tutor_id)
FROM platzi.alumnos

Comparo mis respuestas para el reto de la clase anterior:
Primer reto

SELECT MIN(nombre)
FROM platzi.alumnos

Segundo reto

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

Reto #9

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) AS tabla_almunos_por_tutor;