El segundo más alto

No tienes acceso a esta clase

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

Si ya tienes una cuenta,

Recursos

Aportes 573

Preguntas 39

Ordenar por:

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

Alan Kevin Fuentes García

hace 4 años

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.

sandovalgus

hace 4 años

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

Bárbara de los Ángeles Morantes Carvajal

Platzi Team

hace 4 años

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.

arnolplazas

hace 4 años

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

John Alexander Ortiz Ramirez

hace 4 años

Mi solucion al reto

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

Joel Eduardo Gaspar

hace 4 años

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

Jhonney Correa

hace 4 años

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

hace 2 años

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:

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

anderson chaparro

hace 4 años

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

María Guadalupe Cerron Rocha

hace 4 años

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

hace 2 años

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

Cristian Orlando Rincón Bonilla

hace 4 años

Otra opción:

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

Humberto Adrián Hernández Maldonado

hace 4 años

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

hace 4 años

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

hace 4 años

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;

Marco Antonio Candia Ortega

hace 2 años

Resolución del Reto

Brayan Buitrago

hace 4 años

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)

Edgar Michell Contreras Zambrano

hace 2 años

-- PARA RESOLVER EL RETO ENCONTRÉ UNA SOLUIÓN MUY SENCILLA

-- SIMPLEMENTE CONTAR LOS REGISTROS DE LA TABLA
SELECT COUNT(id)
FROM platzi.alumnos;

-- VEMOS QUE HAY 1000 REGISTROS

-- ENTONCES FILTRO LOS RESULTADOS DONDE EL ID SEA >= 501
-- ASÍ TRAIGO EXACTAMENTE LA SEGUNDA MITAD DE LA TABLA
SELECT *
FROM platzi.alumnos
WHERE id >= 501;

Sebastian Felipe Bernal Rodríguez

hace 2 años

Así fue como lo hice yo:

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

Julian Alejandro Barragan Triana

hace 3 años

Solución al reto, 2 formas distintas.

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

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

José Carlos Díaz

hace 4 años

Del reto, con un combo de LIMIT/OFFSET

/* Con un LIMIT */
SELECT * from platzi.alumnos LIMIT (
SELECT COUNT (id)/2 from Platzi.alumnos
) 
OFFSET (
 SELECT COUNT (id)/2 from Platzi.alumnos)

Nadir Antonio Soza Solis

hace 4 años

Otra forma de hacerlo

SELECT 
	MAX(A1.colegiatura) as segundo_mas_alto
FROM platzi.alumnos as A1
WHERE A1.price not in (
	SELECT max(A.colegiatura) 
	FROM platzi.alumnos as A
);

Sebastián Andrés Sanhueza Tapia

Si ya tienes una cuenta,

Curso Práctico de SQL

El segundo más alto

11. El segundo más alto