Resolviendo diferencias

Para los que usen SQL de Microsoft hay varios aspectos que cambian.
1.- por default el resultado te aparece sin decimales, tienes que convertir el tipo de tato para que te los muestre.
2.- La forma de hacer las subconsultas, ya que las entiendes se hacen más fácil y no es mas que seguir los pasos del profesor con la diferencia de estructurarte de la manera en que lo entiendas, yo lo hago por fases
A.- Hago un catalogo de todos los nombres concatenando sus apellidos.
B.- Asigno el id y los nombres de Alumnos y Tutores
C.- Hago el conteo de alumnos por tutor
D.- Convierto la columna de alumnos por tutor a float y después le saco el promedio para que esta forma me salga el resultado conforme a lo visto en clase.
Los beneficios es que al tener el código separado, es más fácil hacer un cambio en caso de requerirlo y/o realizar las validaciones pertinentes

<
Select 

-----D
AVG(convert (float,D.Alumnos_por_tutor)) promedio_alumnos_por_tutor
from (

-----C
			Select 

			C.Nombre_Tutor
			,COUNT(C.id_alumno) Alumnos_por_tutor

			from (
-----B 
					SELECT 
					a.id id_alumno
					,concat (a.nombre,' ', a.apellido) Nombre_Alumno
					,tutor_id id_tutor
					,b.Nombre Nombre_Tutor
					FROM [HAHM].[dbo].[platzialumnos] a
					inner join (
-----A
								SELECT 
								distinct 
								[id]
								,concat([nombre],' ',[apellido]) Nombre
								FROM [HAHM].[dbo].[platzialumnos]) b on a.tutor_id = b.id 

					) C

	

			Group by 
			C.Nombre_Tutor

) D>

Resolviendo el reto con left join:

SELECT a.nombre, a.apellido, a.carrera_id,
	   c.id, c.carrera
FROM platzi.alumnos AS a
	LEFT JOIN platzi.carreras AS c
	ON a.carrera_id = c.id;

y con Full Outer Join (atentos acá con los null de cursos borrados):

SELECT a.nombre,a.apellido,a.carrera_id,
       c.id,c.carrera
FROM platzi.alumnos AS a
    FULL OUTER JOIN platzi.carreras as c ON c.id = a.carrera_id
WHERE a.nombre IS NOT NULL
ORDER BY a.carrera_id;

Aunque el ejercicio está muy fácil, prefiero aprovechar para hacer uso de una buena práctica y es comentar el código, en vez de eliminar el WHERE sólo comentarlo

SELECT	pa.nombre,
		pa.apellido,
		pa.carrera_id,
		pc.carrera
FROM platzi.alumnos AS pa
	LEFT JOIN platzi.carreras AS pc ON pa.carrera_id = pc.id
--WHERE pc.id IS NULL
--Sólo comentar el WHERE
ORDER BY pa.carrera_id

Resuelto
Usando LEFT JOIN sin ninguna condicion en el WHERE

SELECT carrera_id, COUNT(*) AS cuenta
FROM platzi.alumnos
GROUP BY carrera_id
ORDER BY cuenta DESC;

SELECT  a.nombre,
		a.apellido,
		a.carrera_id,
		c.id,
		c.carrera
FROM 	platzi.alumnos AS a
	LEFT JOIN platzi.carreras AS c 
	ON a.carrera_id = c.id;

Reto

<code> 
SELECT a.nombre,
	   a.apellido,
	   a.carrera_id,
	   c.id,
	   c.carrera
FROM platzi.carreras AS c
	FULL OUTER JOIN platzi.alumnos AS a ON c.id = a.carrera_id
ORDER BY a.carrera_id DESC;

SELECT carrera_id, COUNT(*) AS cuenta
FROM platzi.alumnos
GROUP BY carrera_id
ORDER BY cuenta DESC;

SELECT  a.nombre,
		a.apellido,
		a.carrera_id,
		c.id,
		c.carrera
FROM 	platzi.alumnos AS a
	LEFT JOIN platzi.carreras AS c 
	ON a.carrera_id = c.id;

Hola, esta fue la solución al reto:

/*RETO: Left Join pero sin excluir gente*/

SELECT carrera_id, COUNT(*) AS cuenta
FROM platzi.alumnos
GROUP BY carrera_id
ORDER BY cuenta DESC;

SELECT a.nombre, a.apellido, a.carrera_id, c.id, c.carrera
FROM platzi.alumnos AS a
LEFT JOIN platzi.carreras AS c
ON a.carrera_id = c.id
ORDER BY a.carrera_id;

MI solución

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

Mi solución al reto:

SELECT AVG(p.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 p 

Postgre es súper divertido!!! Que ñoño soy que esto me divierte jajajaj 😄

SELECT a_.id,
	   a_.nombre,
       a_.carrera_id,
       c_.carrera,
       c_.id
from alumnos as a_
LEFT JOIN carreras as c_
on a_.carrera_id = c_.id;

El reto del left join:

SELECT 	a.nombre,
		a.apellido,
		a.carrera_id,
		c.id,
		c.carrera
FROM platzi.alumnos AS a
	LEFT JOIN platzi.carreras AS c
	ON a.carrera_id = c.id
ORDER BY a.carrera_id;

Desafío (Ordenado por carrera):

-- Reto: Join completo entre alumnos y carreras sin condiciones

SELECT *
FROM platzi.alumnos AS a
	FULL OUTER JOIN platzi.carreras AS c
	ON a.carrera_id = c.id
ORDER BY carrera_id;

select concat(a.nombre,' ',a.apellido) as nombres, a.carrera_id,
		c.id, c.carrera
from platzi.alumnos as a
	full outer join platzi.carreras as c 
	ON a.carrera_id = c.id;```

Solución al reto de la clase pasada

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 alumnos_por_tutor

Pues, encontré dos formas de solucionarlos.

--Forma 1
select a.nombre,
	a.apellido,
	a.carrera_id,
	c.id,
	c.carrera
from platzi.alumnos as a
	left join platzi.carreras as c
	on a.carrera_id = c.id
where c.id is not null
order by a.carrera_id;

--Forma2
select a.nombre,
	a.apellido,
	a.carrera_id,
	c.id,
	c.carrera
from platzi.alumnos as a
	full outer join platzi.carreras as c
	on a.carrera_id = c.id
order by a.carrera_id;

Cierre de clase y reto

LEFT JOIN exclusivo entre las tablas alumnos y carreras. ¿Qué alumnos no tienen carrera?

Borrado de datos para crear diferencias entre tablas

Introducción a diferencias y exploracion de datos, alumnos por carrera

Solución al reto de la clase anterior

Al crear las llaves foráneas lo configure para que los cambios se efectuaran en cascada, por lo cual al borrar las carreras con los id entre 30 y 40, también me elimino los alumnos que tenían dicha carrera, cosas a tener en cuenta que nos pueden agilizar el trabajo o arruinar los datos que tenemos, dependiendo del contexto y lo que necesitemos.

RETO

-- Left Join --
SELECT 	a.nombre,
		a.apellido,
		a.carrera_id,
		c.id,
		c.carrera
FROM	platzi.alumnos AS a
	LEFT JOIN platzi.carreras AS c
	ON a.carrera_id = c.id
ORDER BY id;

select a.nombre,
	   a.apellido,
	   a.carrera_id,
	   c.id,
	   c.carrera
from  platzi.alumnos as a full outer  join platzi.carreras as c 

on a.carrera_id=c.id 

order by 3;

Solución del reto

SELECT	a.nombre,
		a.apellido,
		a.carrera_id,
		c.id,
		c.carrera
FROM platzi.alumnos AS a
	LEFT JOIN platzi.carreras AS c
	ON a.carrera_id = c.id

SELECT a.nombre, 
	   a.apellido,
	   a.carrera_id,
	   c.id,
	   c.carrera
FROM platzi.alumnos AS a 
	LEFT JOIN platzi.carreras AS c
	ON a.carrera_id = c.id
WHERE c.id IS NOT NULL
ORDER BY a.carrera_id;	  

select a.nombre, a.apellido, a.carrera_id, c.id , c.carrera
from platzi.alumnos as a
left join platzi.carreras as c
on a.carrera_id = c.id

Solución al reto:

SELECT a.nombre, a.apellido, a.carrera_id, c.id, c.carrera
FROM platzi.alumnos AS a
LEFT JOIN platzi.carreras AS c ON a.carrera_id = c.id
ORDER BY c.id DESC;

SELECT 	a.nombre,
		a.apellido,
		a.carrera_id,
		c.id,
		c.carrera
FROM	platzi.alumnos AS a
	LEFT JOIN platzi.carreras AS c
	ON a.carrera_id = c.id
ORDER BY a.carrera_id;

Mi solución al reto:

SELECT
    student_body.nombre,
    student_body.apellido,
    student_body.carrera_id,
    careers.carrera
FROM
    platzi.alumnos AS student_body
LEFT JOIN platzi.carreras AS careers
    ON student_body.carrera_id = careers.id;

Mi query, basta con quitar la condición del WHERE

SELECT CONCAT(a.nombre, ' ', a.apellido) AS nombre,
	a.carrera_id,
	c.id,
	c.carrera
FROM platzi.alumnos AS a
	LEFT JOIN platzi.carreras AS c
	ON a.carrera_id = c.id
ORDER BY a.carrera_id DESC;

Resolviendo diferencias

• Elementos que se encuentran en una tabla pero no en otra

RETO
Le agregamos a la consulta lo siguiente:

WHERE platzi.carreras.id IS NOT NULL

solucion usando el FULL OUTER JOIN:

<
SELECT a.nombre,a.apellido,a.carrera_id,c.id,c.carrera
FROM platzi.alumnos AS a
FULL OUTER JOIN platzi.carreras AS c
ON a.carrera_id= c.id
ORDER BY a.carrera_id;
> 

Para SQL Server:

-- CANTIDAD DE ALUMNOS POR CARRERA
USE [platzi]
SELECT 
	carrera_id, 
	COUNT(*) AS cuenta
FROM platzi.alumnos
GROUP BY carrera_id
ORDER BY 2 DESC
GO


-- LEFT JOIN EXCLUSIVO
-- DIFERENCIA
-- ALUMNOS HUERFANOS DE CARRERA
USE [platzi]
SELECT 
	a.nombre,
	a.apellido,
	a.carrera_id,
	c.id,
	c.carrera
FROM
	platzi.alumnos AS a
	LEFT JOIN platzi.carreras AS c ON a.carrera_id = c.id
WHERE c.id IS NULL
ORDER BY a.carrera_id
GO

/*
TRAER TODO EXCEPTO LAS INTERSECCIONES
*/
-- O CARRERA_ID O ID DEBE SER NULL
USE [platzi]
SELECT 
	a.nombre,
	a.apellido,
	a.carrera_id,
	c.id,
	c.carrera
FROM
	platzi.alumnos AS a
	FULL OUTER JOIN platzi.carreras AS c ON a.carrera_id = c.id
ORDER BY a.carrera_id
GO

reto

SELECT a.nombre, a.apellido, a.carrera_id,
	   c.id, c.carrera
FROM platzi.alumnos AS a
	LEFT JOIN platzi.carreras AS c
	ON a.carrera_id = c.id
ORDER BY a.carrera_id;

Para no jugar con el DELETE, en el conjunto de datos que descargue hay muchas carreras sin alumnos.
Chequeen esa diferencia para no borrar datos, es solamente dar vuelta el join.

SELECT c.id, c.carrera, a.id as id_alumno, concat(a.nombre, a.apellido) as alumno
from platzi.carreras c
left join platzi.alumnos a
on c.id = a.carrera_id
where a.id is null;

Reto(Segun yo seria lo mismo pero sin el where)

SELECT 
a.nombre,
a.apellido,
a.carrera_id,
c.id,
c.carrera
FROM platzi.alumnos AS a
LEFT JOIN platzi.carreras AS c
ON a.carrera_id = c.id;

SELECT 
	a.nombre, 
	a.apellido, 
	a.carrera_id, 
	c.id, 
	c.carrera
FROM platzi.carreras AS c
	LEFT JOIN platzi.alumnos AS a 
	ON a.carrera_id = c.id
WHERE a.id IS NULL
ORDER BY a.id;

Usando FULL OUTER JOIN

SELECT carrera_id, COUNT(*) AS cuenta
FROM platzi.alumnos
GROUP BY carrera_id
ORDER BY cuenta DESC;

SELECT  a.nombre,
		a.apellido,
		a.carrera_id,
		c.id,
		c.carrera
FROM 	platzi.alumnos AS a
	FULL OUTER JOIN platzi.carreras AS c 
	ON a.carrera_id = c.id;

SELECT 	a.nombre,
		a.apellido,
		a.carrera_id,
		c.id,
		c.carrera
FROM	platzi.alumnos AS a
	LEFT JOIN platzi.carreras AS c
	ON a.carrera_id = c.id

Select a.nombre,
		a.apellido,
		a.carrera_id,
		c.id,
		c.carrera
		from platzi.alumnos as a
		join platzi.carreras as c
		on a.carrera_id = c.id
		Order by a.carrera_id;

aplique el código de ejemplo para una búsqueda de datos para el trabajo y pues funciono excelente

SELECT c.CODIGO_EMPRESA, c.CODIGO_rapido, c.nombre, c.razon_social, x.CLAVE, x.VALOR_CLAVE 
FROM clientes c left join (select * from clientes_claves_estadisticas where clave='RPN2' and codigo_empresa='004') x on c.codigo_rapido=x.codigo_cliente and c.codigo_empresa=x.codigo_empresa
WHERE c.CODIGO_EMPRESA='004' AND FECHA_BAJA IS NOT NULL and x.clave is null```

RETO realizar el left join mostrando los datos de toda la tabla alumnos

-- todos los alumnos con carrera y el nombre de sus carreras
SELECT a.nombre,
    a.apellido,
    a.carrera_id,
    c.id,
    c.carrera
FROM alumnos AS a
  INNER JOIN carreras AS c
  ON a.carrera_id = c.id
ORDER BY a.carrera_id;

-- todos los alumnos con y sin carrera y sus carreras
SELECT a.nombre,
    a.apellido,
    a.carrera_id,
    c.id,
    c.carrera
FROM alumnos AS a
  LEFT JOIN carreras AS c
  ON a.carrera_id = c.id
ORDER BY a.carrera_id;

-- todos los alumnos con y sin carrera y todas las carreras incluso las que no tienen alumnos
SELECT a.nombre,
    a.apellido,
    a.carrera_id,
    c.id,
    c.carrera
FROM alumnos AS a
  FULL OUTER JOIN carreras AS c
  ON a.carrera_id = c.id
ORDER BY a.carrera_id;

SELECT a.nombre,
		a.apellido,
		a.carrera_id,
		c.id,
		c.carrera 
FROM platzi.alumnos AS a 
FULL OUTER JOIN platzi.carreras AS c 
	ON a.carrera_id = c.id
ORDER BY a.carrera_id; ```

Mi respuesta

SELECT a.nombre, a.apellido, a.carrera_id, c.id, c.carrera
FROM platzi.alumnos AS a
LEFT JOIN platzi.carreras AS c ON a.carrera_id = c.id
ORDER BY a.carrera_id;

Solución para traer todos los datos de las dos tablas incluyendo los null:

SELECT 	a.nombre,
		a.apellido,
		a.carrera_id,
		c.id,
		c.carrera
FROM	platzi.alumnos AS a
	FULL OUTER JOIN platzi.carreras AS c
	ON a.carrera_id = c.id

LEFT JOIN

SELECT a.nombre,
	   a.apellido,
	   a.carrera_id,
	   c.id,
	   c.carrera
FROM platzi.alumnos AS a
	LEFT JOIN platzi.carreras AS c
	ON a.carrera_id = c.id
ORDER BY a.carrera_id;

FULL (OUTER) JOIN

SELECT a.nombre,
	   a.apellido,
	   a.carrera_id,
	   c.id,
	   c.carrera
FROM platzi.alumnos AS a
	FULL JOIN platzi.carreras AS c
	ON a.carrera_id = c.id
ORDER BY a.carrera_id;

Logré esto con esta clase:

SELECT  a.nombre,
		a.apellido,
		a.carrera_id,
		c.id,
		c.carrera
FROM platzi.alumnos AS a
	LEFT JOIN platzi.carreras AS c
	ON a.carrera_id = c.id
WHERE c.id IS NULL
ORDER BY a.carrera_id;

--Left Join--
SELECT a.nombre, a.apellido, a.carrera_id,
	   c.id, c.carrera
FROM platzi.alumnos AS a
	LEFT JOIN platzi.carreras AS c
	ON a.carrera_id = c.id;
	
--Full Outer Join--
SELECT a.nombre,a.apellido,a.carrera_id,
       c.id,c.carrera
FROM platzi.alumnos AS a
    FULL OUTER JOIN platzi.carreras as c ON c.id = a.carrera_id
WHERE a.nombre IS NOT NULL
ORDER BY a.carrera_id;

El resultado del reto.

SELECT a.nombre, a.apellido,
	a.carrera_id, c.id, c.carrera
FROM platzi.alumnos AS a
LEFT JOIN platzi.carreras AS c
ON a.carrera_id = c.id;

SELECT a.nombre, a.apellido, a.carrera_id,
	   c.id, c.carrera
FROM platzi.alumnos AS a
	LEFT JOIN platzi.carreras AS c
	ON a.carrera_id = c.id;

SELECT a.nombre, 
		a.apellido,
		a.carrera_id,
		c.id,
		c.carrera
FROM  platzi.alumnos AS a
	LEFT JOIN platzi.carreras AS c
	ON a.carrera_id = c.id
	WHERE c.carrera IS NOT NULL
	ORDER BY a.carrera_id ;
	
SELECT a.nombre, 
		a.apellido,
		a.carrera_id,
		c.id,
		c.carrera
FROM  platzi.alumnos AS a
	FULL OUTER JOIN platzi.carreras AS c
	ON a.carrera_id = c.id
	WHERE a.nombre IS NOT NULL
	ORDER by c.carrera;

Para traer toda la información no solo las carrearas que quedaron nulas se debe quitar el WHERE por lo tanto queda de esta manera, le deje el ORDER BY para que me muestre el orden por carreras

SELECT a.nombre,
		a.apellido,
		a.carrera_id,
		c.id,
		c.carrera
FROM platzi.alumnos AS a
	LEFT JOIN platzi.carreras AS c
	ON a.carrera_id = c.id
ORDER BY a.carrera_id;

-- Carreras de los alumnos

SELECT a.nombre,a.apellido,c.carrera
FROM alumnos a
    LEFT JOIN carreras c ON c.id = a.carrera_id;

Mi solución al desafío

select a.nombre, a.apellido, a.carrera_id,
  		c.id, c.carrera
from platzi.alumnos AS a left join platzi.carreras AS c ON a.carrera_id = c.id
where c.id IS not null
order by a.carrera_id desc;

Otro script adicional sencillo que hice fue que mostrara los que sí estaban en la tabla B

select a.nombre, a.apellido, a.carrera_id,
  		c.id, c.carrera
from platzi.alumnos AS a left join platzi.carreras AS c ON a.carrera_id = c.id
where c.id IS not null
order by a.carrera_id desc
;

Esta es mi solución al reto:

Mi solución:

Reto de Clase

SELECT a.nombre,
       a.apellido,
       a.carrera_id,
       c.id,
       c.carrera
    FROM platzi.alumnos AS a
    FULL OUTER JOIN platzi.carreras as c ON c.id = a.carrera_id
    ORDER BY a.carrera_id;