El segundo más alto

Alan Kevin Fuentes García

student•

Me costó un poco entender la primer consulta jaja, pero en caso de que tengan la misma duda de por qué funcionó, lo aclaro.

Dentro del subquery lo que hace es comparar dos copias de la misma columna, por ejemplo

a1.colegiatura = [2000, 4800, 1000, 5000, 3000] # Disctinct 
a2.colegiatura = [2000, 4800, 1000, 5000, 3000] # Distinct

Para cada valor, obtiene los valores que son mayores o igual a él

2000 -> 3000, 5000, 4800, 2000
4800 -> 5000, 4800
1000 -> 3000, 5000, 4800, 2000, 1000
5000 -> 5000
3000 -> 3000, 5000, 4800

Y finalmente obtiene la cuenta de ellos.

colegiatura = [2000, 4800, 1000, 5000, 3000] 
count = [4, 2, 5, 1, 3]

Esto se traduce a un ordenamiento con indexación y es por eso que elegir el 2 nos dará el segundo valor de colegiatura más alto. Este método es muy poco eficiente porque requiere de n^2 pasos (hizo 5 comparaciones por los 5 valores) mientras que un order by requiere en promedio nlogn pasos.

Iván Godoy

student•

Gracias por la explicación.

Kevin Yahir Garcia Gutierrez

student•

Hola! Tengo entendido que la subconsulta es: 'select count(distinct colegiatura) from platzi.alumnos as a2' cierto? Entonces si hago esa consulta sale como resultado 8, entonces a2 es 8. No entiendo como sacas los registros que pones en a2. Espero me puedas ayudar! Gracias

Gustavo Fabian Sandoval

student•

Mi query SELECT * FROM platzi.alumnos OFFSET ( SELECT (COUNT(id)/2) FROM platzi.alumnos )

Francisco Murillo

student•

wooow me gusto la forma que lo resolviste, estuve cerca de hacerlo asi, aunque tuve el mismo resultado, el tuyo es mas funcional

Andrés Cardona

student•

Excelente, incluso es más eficiente que:

SELECT * FROM platzi.alumnos
OFFSET 499;

Porque ejecuta menos pasos

Bárbara de los Ángeles Morantes Carvajal

student•

No estoy segura de si estoy en lo correcto, pero en el tercer Query creo que el WHERE tutor_id = 20 tiene que estar fuera del subquery, digo esto porque cuando realice el mismo Query que el tutor me traia todas las colegiaturas de 4800 pero con todos los tutores:

SELECT *
FROM platzi.alumnos AS datos_alumnos
INNER JOIN (
	SELECT DISTINCT colegiatura
	FROM platzi.alumnos
	ORDER BY colegiatura DESC
	LIMIT 1 OFFSET 1
) AS segunda_mayor_colegiatura
ON datos_alumnos.colegiatura = segunda_mayor_colegiatura.colegiatura
WHERE tutor_id = 20;

colocando el WHERE en el Query principal si aplica la condición de que sea la segunda colegiatura más alta con el tutor n° 20.

Acepto feedback en caso de estar equivocada.

Orlando Ramirez

student•

Hola, revisando el query que se hizo creo que si tienes razón, si queremos que sean solo los que tienen como tutor el que tiene id = 20 debe ponerse por fuera del query principal.

Orlando Ramirez

student•

Pero revisando nuevamente el video, la idea no es traer solo los estudiantes que tengan como tutor al de id = 20, cuando el usa eso dentro del primer query es porque cuando busca la segunda mayor colegiatura lo hace para ese tutor en especifico, es decir, puede que para otro tutor la segunda mayor colegiatura sea diferente de 4800, entonces, cuando se hace la segunda query los resultados serían distintos. No se si me explico, gracias por hacer esta observación la verdad creo que me ayudo a entender mucho más el ejercicio.

Arnol Fabian Plazas Acevedo

student•

SELECT *
FROM platzi.alumnos
WHERE id > (
SELECT COUNT(*)/2
FROM platzi.alumnos
);```

John Alexander Ortiz Ramirez

student•

Mi solucion al reto

SELECT * 
    FROM platzi.alumnos
    OFFSET ( SELECT COUNT(*)/2 FROM platzi.alumnos );

Adriel Salguero

student•

Hola! probe hacer el mismo query pero me sale error en el OFFSET. Sabras porque?

Luis Angel Pasos Montalvo

student•

A mi tambien me sale error en OFFSET no se si es por el manejador de base de datos, si debe ser una sintaxis diferente

Joel Eduardo Gaspar

student•

En MySQL:

set @count = (select count(*)/2 from alumnos)

select * from 
(select row_number() over() as row_id, alumnos.* from alumnos)
as alumnos_rows 
where row_id > @count

Me topé con que mysql no permite en argumentos limists u offset datos que no sean constantes, por eso seteo primero el count

José Eduardo Morales Raygoza

student•

También me topé con esta limitante de MySQL después de darle mil vueltas al query que pone el profe en la siguiente clase.

Gracias por el aporte!

david roberto urquiza rivera

student•

si intento tu código me sale que select debería de estar en otra posición :c

Jhonney Correa

student•

Con el DISTINCT le diré que me traiga valores sin duplicarlos, con el ORDER BY colegiatura DESC lo que hago es ordenarlo de manera descendente y con el LIMIT 2 lo que hago es decirle que me traiga solo 2 y el OFFSET 1 le digo que se salte un row.

SELECT DISTINCT colegiatura FROM platzi.alumnos ORDER BY colegiatura DESC LIMIT 2 OFFSET 1

Javier Hugo Noto Enriquez

student•

EL PRIMER EJEMPLO Me pase tiempo analizando esto, tiene que ver con conceptos fundamentales de SQL, y no lo entendía, ahí va la explicacion:

La primera parte :

SELECT DISTINCT colegiatura FROM platzi.alumnos AS a1

Crea una tabla con los siguientes valores:

[3000,2000,2300,4500,3500,5000,2500,4800]

Luego el WHERE por concepto, compara fila por fila un valor, es decir manda el 1er valor a la subconsulta (3000), luego el segundo (2000) y así sucesivamente. En este caso, espera un 2:

WHERE 2 = (Subconsutta)

La subconsulta:

SELECT COUNT(DISTINCT colegiatura) FROM platzi.alumnos AS a2 WHERE a1.colegiatura <= a2.colegiatura

Es la misma que la primera, y lo que hace es comparar cada valor que le llega de la columna colegiatura con todos los valores de la misma columna:

!Imagen

Y por último, recien actúa el COUNT, por lo que la subconsulta devuelve un valor de número, haciendo que el WHERE 2 = 2 se cumpla.

Es un proceso innecesariamente largo, pero ayuda a comprender en que orden se ejecutan las sentencias

Abraham Leonel Salmerón Cimé

student•

Tu aporte igual me ayudó a entender esa primera query.

Solano Hilario

student•

Aun sigo en duda porque hace el WHERE 2=SUBCONSULTA. El ejemplo del WHERE = (SUB CONSULTA) si logro entenderlo.

anderson chaparro

student•

La linea de código que muestro mas abajo y que aparece en el código de la clase; por los resultados me parece que es redundante y no esta causando ningún efecto porque la columna "tutor_id" muestra cualquier id no solo los 20. Ejecute el código sin esta línea y da el mismo resultado.

WHERE tutor_id=20

Carlos Vargas

student•

Acabo de comprobarlo y es cierto lo que comentas, de hecho ese WHERE hacia un poco mas confuso el query.

Lucia Ugarte Huayhua

student•

Para que sala solo tutor 20, hay que agregar el nombre en SELECT. SELECT DISTINCT colegiatura, tutor_id

María Guadalupe Cerron Rocha

student•

Me di cuenta que muchas personas piensan que el OFFSET debe usarse con un LIMIT, cosa que no es cierta, no es necesario.

El OFFSET de por sí ya se salta el número de registros que le pongas.
El LIMIT te muestra la cantidad de tuplas que quieras desde el inicio.
Combinándolos, puedes saltarte algunas tuplas con OFFSET y mostrar la cantidad que quieras después de estas filas saltadas con LIMIT.

Sergio Fernando Blanco Ojeda

student•

empezó muy rudo con todo yo apenas entiendo algo de sql =(

Juan Guillermo Leon

student•

Ese es el reto llevar tu conocimiento a otro nivel no pares te aprender!

María Mercedes Eizaga Oberto

student•

Me senti igual

Cristian Orlando Rincon Bonilla

student•

Otra opción:

SELECT * FROM platzi.alumnos
OFFSET 500 ROWS
FETCH FIRST 500 ROWS ONLY```

Bárbara de los Ángeles Morantes Carvajal

student•

Tengo una duda sobre tu Query, ¿por qué es necesario usar FETCH FIRST 500 ROWS ONLY?, ejecutando solo el OFFSET ya se salta las primeras 500.

Juan Camilo Alfonso Mesquida

student•

Está es muy buena solución pero está limitada a una tabla de 1000 registros.

Manuel Espitia

student•

No debería traer los resultados donde colegiatura = 4.800 y tutor_id = 20 ? Cumple el primero pero no el segundo y no tengo claro por qué si ambos se escriben en el query.

Ricardo Ortiz

student•

Tendría que ser el query de la siguiente forma:

SELECT * FROM platzi.alumnos WHERE colegiatura = ( SELECT DISTINCT colegiatura FROM platzi.alumnos ORDER BY colegiatura DESC LIMIT 1 OFFSET 1 ) AND tutor_id=20;

Edgar Bernal

student•

Yo traje los datos con una consulta más básica, si la idea es que sea más optima, ya que creí que era más complicado así de esa forma, aunque me imagino que la idea principal era hacerlo con subconsultas ( SELECT tutor_id, colegiatura FROM platzi.alumnos WHERE tutor_id = 20 AND colegiatura = 4800

Humberto Adrián Hernández Maldonado

student•

Ejercicios.


--------------------------------------------------------
--Ejercicio 1
SELECT 
colegiatura
,count(colegiatura) Cuenta_Colegiatura
FROM [HAHM].[dbo].[platzialumnos]
Group by 
colegiatura 
order by 
colegiatura desc 
OFFSET  1 ROWS 
FETCH NEXT 1 ROWS ONLY 

---------------------------------------------------------
--Ejercicio 2

SELECT 
colegiatura
,tutor_id
,count(colegiatura) Cuenta_Colegiatura
FROM [HAHM].[dbo].[platzialumnos]

where tutor_id = 20

Group by 
colegiatura 
,tutor_id
order by 
colegiatura desc 
OFFSET  1 ROWS 
FETCH NEXT 1 ROWS ONLY 

---------------------------------------------------------
--Ejercicio 3

SELECT 
*
FROM [HAHM].[dbo].[platzialumnos] A 
inner join (SELECT 
					colegiatura
					,tutor_id
					,count(colegiatura) Cuenta_Colegiatura
					FROM [HAHM].[dbo].[platzialumnos]
					where tutor_id = 20
					Group by 
					colegiatura 
					,tutor_id
					order by 
					colegiatura desc 
					OFFSET  1 ROWS 
					FETCH NEXT 1 ROWS ONLY ) b on A.colegiatura = b.colegiatura
					

---------------------------------------------------------
--Ejercicio 4
SELECT 
*
FROM [HAHM].[dbo].[platzialumnos] A 
where colegiatura = (SELECT 
					colegiatura
				    FROM [HAHM].[dbo].[platzialumnos]
					where tutor_id = 20
					Group by 
					colegiatura 
					order by 
					colegiatura desc 
					OFFSET  1 ROWS 
					FETCH NEXT 1 ROWS ONLY )

Miguel Martínez

student•

código de la clase:

select distinct colegiatura
from platzi.alumnos as a1
where 2 = (
	select count(distinct colegiatura)
	from platzi.alumnos a2
	where a1.colegiatura <= a2.colegiatura
)

select distinct colegiatura
from platzi.alumnos
where tutor_id = 20
order by colegiatura desc
limit 1 offset 1

select *
from platzi.alumnos as datos_alumnos
inner join (
	select distinct colegiatura
	from platzi.alumnos
	where tutor_id = 20
	order by colegiatura desc
	limit 1 offset 1
) as segunda_mayor_colegiatura
on datos_alumnos.colegiatura = segunda_mayor_colegiatura.colegiatura

select *
from platzi.alumnos
where colegiatura = (
	select distinct colegiatura
	from platzi.alumnos
	where tutor_id = 20
	order by colegiatura desc
	limit 1 offset 1
)

anderson chaparro

student•

Lo resolví de la siguiente manera, si entendí bien el ejercicio es mostrar la segunda mitad de la tabla, de 500 a 1000.

SELECT *
FROM platzi.alumnos
LIMIT 501 OFFSET 499;

SELECT * 
FROM platzi.alumnos
WHERE id > 499;

Fernando Yutiz

student•

No se si estoy interpretando mal, pero no estaria mal el query? Se esta intentando limitar el tutor_id al 20, pero termina trayendo a todos.

Jhon Stiven Posso Cardona

student•

tengo la misma duda no entiendo esta parte del codigo

Alvarez Pozo Hugo Felipe

student•

por lo que entiendo, en la consulta select general trae todos lo registros, pero en el filtro de subquery solamente trae 1, en el where solo esta especificando la colegiatura filtrada a traves de esa subquery, si quisieras traer solo al tutor con id 20 , deberias agregarlo con AND al.tutor_id=20 te traeria solo los registros caidos con ese id, mas la colegiatura filtrada con la subquery

select *
from platzi.alumnos al where al.colegiatura = ( select distinct colegiatura from platzi.alumnos where tutor_id = 20 order by colegiatura desc limit 1 offset 1 ) and al.tutor_id = 20

Jeyson David Vargas Crespo

student•

Hola, como funciona el OVER()???

Alex Camacho

teacher•

Te comparto una conversación en stackoverlow sobre cuando y por qué es bueno usar OVER()

https://stackoverflow.com/questions/6218902/the-sql-over-clause-when-and-why-is-it-useful

Marco Antonio Candia Ortega

student•

Resolución del Reto

Brayan Buitrago

student•

Primera opcion: saltando la primera mitad del total de registros

SELECT * 
FROM platzi.alumnos
OFFSET (
	SELECT COUNT(id)/2 FROM platzi.alumnos
);

Segunda opcion: Agregar el row_id de la anterior clase y usar un between entre el total de registros sobre 2 y el total de registros

SELECT *
FROM (
	SELECT ROW_NUMBER() OVER() AS row_id, *
	FROM platzi.alumnos
) AS A1
WHERE row_id 
BETWEEN (SELECT COUNT(id)/2 FROM platzi.alumnos)
AND (SELECT COUNT(id) FROM platzi.alumnos)

SELECT *
FROM platzi.alumnos AS datos_alumnos
INNER JOIN (
	SELECT DISTINCT colegiatura
	FROM platzi.alumnos
	ORDER BY colegiatura DESC
	LIMIT 1 OFFSET 1
) AS segunda_mayor_colegiatura
ON datos_alumnos.colegiatura = segunda_mayor_colegiatura.colegiatura
WHERE tutor_id = 20;

--------------------------------------------------------
--Ejercicio 1
SELECT 
colegiatura
,count(colegiatura) Cuenta_Colegiatura
FROM [HAHM].[dbo].[platzialumnos]
Group by 
colegiatura 
order by 
colegiatura desc 
OFFSET  1 ROWS 
FETCH NEXT 1 ROWS ONLY 

---------------------------------------------------------
--Ejercicio 2

SELECT 
colegiatura
,tutor_id
,count(colegiatura) Cuenta_Colegiatura
FROM [HAHM].[dbo].[platzialumnos]

where tutor_id = 20

Group by 
colegiatura 
,tutor_id
order by 
colegiatura desc 
OFFSET  1 ROWS 
FETCH NEXT 1 ROWS ONLY 

---------------------------------------------------------
--Ejercicio 3

SELECT 
*
FROM [HAHM].[dbo].[platzialumnos] A 
inner join (SELECT 
					colegiatura
					,tutor_id
					,count(colegiatura) Cuenta_Colegiatura
					FROM [HAHM].[dbo].[platzialumnos]
					where tutor_id = 20
					Group by 
					colegiatura 
					,tutor_id
					order by 
					colegiatura desc 
					OFFSET  1 ROWS 
					FETCH NEXT 1 ROWS ONLY ) b on A.colegiatura = b.colegiatura
					

---------------------------------------------------------
--Ejercicio 4
SELECT 
*
FROM [HAHM].[dbo].[platzialumnos] A 
where colegiatura = (SELECT 
					colegiatura
				    FROM [HAHM].[dbo].[platzialumnos]
					where tutor_id = 20
					Group by 
					colegiatura 
					order by 
					colegiatura desc 
					OFFSET  1 ROWS 
					FETCH NEXT 1 ROWS ONLY ) 

select distinct colegiatura
from platzi.alumnos as a1
where 2 = (
	select count(distinct colegiatura)
	from platzi.alumnos a2
	where a1.colegiatura <= a2.colegiatura
)

select distinct colegiatura
from platzi.alumnos
where tutor_id = 20
order by colegiatura desc
limit 1 offset 1

select *
from platzi.alumnos as datos_alumnos
inner join (
	select distinct colegiatura
	from platzi.alumnos
	where tutor_id = 20
	order by colegiatura desc
	limit 1 offset 1
) as segunda_mayor_colegiatura
on datos_alumnos.colegiatura = segunda_mayor_colegiatura.colegiatura

select *
from platzi.alumnos
where colegiatura = (
	select distinct colegiatura
	from platzi.alumnos
	where tutor_id = 20
	order by colegiatura desc
	limit 1 offset 1
)

El segundo más alto

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