El segundo más alto

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.

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

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.

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

Mi solucion al reto

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

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

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

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:

1. 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]

1. 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)

1. 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

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

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.

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

Otra opción:

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

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 ) 

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
)

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;

Resolución del Reto

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)

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

Así fue como lo hice yo:

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

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

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)  

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

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

Misolución al reto es la siguiente

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

11. El segundo más alto

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, tutor_id
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 AS datos_alumnos 
WHERE 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
WHERE colegiatura = (
    SELECT MAX(colegiatura)
    FROM platzi.alumnos
    WHERE tutor_id = 20
);
 
 
-- RETO

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

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

SELECT *
FROM (
    SELECT *, NTILE(2) OVER (ORDER BY (SELECT NULL)) AS half
    FROM platzi.alumnos
) AS half_alumnos
WHERE half = 2;

WITH ranked_alumnos AS (
  SELECT *, PERCENT_RANK() OVER (ORDER BY (SELECT NULL)) AS rank
  FROM platzi.alumnos
)
SELECT *
FROM ranked_alumnos
WHERE rank > 0.5;

Leaving mine over here

SELECT ROW_NUMBER() OVER() AS row_id, *
FROM platzi.alumnos
OFFSET(
	SELECT COUNT(*)/2
	FROM platzi.alumnos
);

Con ayuda de Chat GPT. Tenía la idea de hacer los parámetros LIMIT y OFFSET dinámicos pero no tenía muy claro cómo hacerlo:

SELECT *
FROM your_table
ORDER BY some_column -- Replace "some_column" with the column you want to order the rows by
LIMIT (SELECT CEILING(COUNT(*) / 2) FROM your_table) OFFSET (SELECT CEILING(COUNT(*) / 2) FROM your_table);

Solución:

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

SELECT *
FROM platzi.alumnos
WHERE id >500

En los dos últimos ejemplos no se filtra correctamente la información para el tutor con id igual a 20. Para corregir esto, en el primero de estos ejemplos, se debe extraer la sentencia WHERE del subquery y llevarla al final del query principal:

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;

En el segundo ejemplo, se debe eliminar la sentencia WHERE del subquery y agregar la sentencia AND, con el filtro, al query principal:

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

EL RETO

select *
from platzi.alumnos
where id >= ((select count(id) as numero_alumnos
	  from platzi.alumnos)/2);

Muy buena la clase, resalto lo que dijo el profe “Aquí es donde se pone interesante hacer cardio con SQL” hahahahaha

Realicé tres formas de listar la segunda mitad de la tabla no muy optimas, pero lo hice!!

– El codigo trae el LISTADO de la segunda mitad de la tabla
SELECT *
FROM platzi.alumnos
OFFSET (SELECT (COUNT(id)/2) FROM platzi.alumnos)

– El codigo trae el LISTADO de la segunda mitad de la tabla de diferente forma al anterior
SELECT *
FROM platzi.alumnos
WHERE id >=(
SELECT COUNT (colegiatura)
FROM platzi.alumnos
)/2

– El codigo trae el LISTADO de la segunda mitad de la tabla de diferente forma al anterior
SELECT *
FROM platzi.alumnos
WHERE id BETWEEN (
SELECT COUNT (colegiatura)
FROM platzi.alumnos
)/2
AND
(
SELECT COUNT (colegiatura)
FROM platzi.alumnos
)

SELECT 	*
FROM	platzi.alumnos
WHERE 	id > 500
;

Traer la segunda mitad de la tabla

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

SELECT TOP 50 PERCENT *
FROM platzi.alumnos

En SQL Server es la forma más facil de obtener la segunda mitad de los registros de la tabla en un orden por default ascendente (ASC)

La solución fácil es la siguiente

SELECT * FROM platzi.alumnos LIMIT 500 OFFSET 500;

No obstante tiene un fallo, pues, sabemos a priori que la DB tiene mil registros; una opción más dinámica es con el siguiente query:

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

SEGUNDO RETO:

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

SELECT *
FROM (
SELECT ROW_NUMBER() OVER() AS row_id, *
FROM platzi.alumnos
)
AS alumnos_with_row_num
WHERE row_id >= 500;

Así obtuve la segunda parte de la tabla

SELECT * from alumnos
LIMIT (SELECT count(*)/2 from alumnos) 
OFFSET (SELECT count(*)/2 from alumnos);

RETO
Así quedó mi Query

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

El segundo más alto también funciona así:

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

donde con el where =1 se busca aquel valor de colegiatura que solo tenga 1 mayor a él mismo. En este caso sale 4800 ya que solo tiene al 5000 como único valor mayor.

Para SQL Server

-- METODO 2
-- SEGUNDA COLEGIATURA EN ORDEN DESC CON FETCH NEXT
USE [platzi]
SELECT DISTINCT colegiatura AS [segunda colegiatura]
FROM platzi.alumnos
ORDER BY colegiatura DESC OFFSET 1 ROWS FETCH NEXT 1 ROWS ONLY
GO


-- SEGUNDA COLEGIATURA DE UN TUTOR
USE [platzi]
SELECT 
	DISTINCT colegiatura AS [segunda colegiatura], 
	tutor_id AS tutor
FROM platzi.alumnos
WHERE tutor_id=20
ORDER BY colegiatura DESC OFFSET 1 ROWS FETCH NEXT 1 ROWS ONLY
GO


-- METODO 3
-- DATOS DE LAS PERSONAS CON LA SEGUNDA COLEGIATURA EN ORDEN DESC CON INNER JOIN
USE [platzi]
SELECT id, nombre, apellido, colegiatura, segunda_colegiatura
FROM
	platzi.alumnos AS datos_alumnos
	INNER JOIN 
	(
		SELECT DISTINCT colegiatura AS segunda_colegiatura
		FROM platzi.alumnos
		ORDER BY colegiatura DESC OFFSET 1 ROWS FETCH NEXT 1 ROWS ONLY
	) AS segunda_mayor_colegiatura ON datos_alumnos.colegiatura = segunda_mayor_colegiatura.segunda_colegiatura
GO

Me salió así, en mySQL no pude hacer una subquery para el limit y el offset

SELECT *
FROM platzi.alumnos AS A
JOIN (SELECT ROW_NUMBER() OVER() AS row_id, id FROM platzi.alumnos) AS B
ON A.id = B.id
WHERE row_id > (SELECT COUNT(*)/2 FROM platzi.alumnos);

para los que estan siquiendo las clases del profesor con Mysql quedaria algo asi.

Reto:

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

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

Hola, con esta consulta que pensé no sólo trae la segunda colegiatura más cara si no que, además, nos dice cuántos usuarios están pagando dicho valor.

<code> 
SELECT colegiatura, COUNT(colegiatura) AS cantidad_de_alumnos
FROM platzi.alumnos
GROUP BY colegiatura
ORDER BY colegiatura DESC
OFFSET 1
LIMIT 1;

SELECT *
FROM platzi.alumnos
ORDER BY colegiatura DESC
OFFSET (SELECT COUNT(*) FROM platzi.alumnos) / 2
FETCH NEXT (SELECT COUNT(*) FROM platzi.alumnos) / 2 ROWS ONLY;

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

Mi query

select *
FROM PLATZI.ALUMNOS
offset (
select count(id)
from platzi.alumnos)/2
limit (
select count(id)
from platzi.alumnos)/2;

Les comparto como resolví el ejercicio: seleccione todos los
registros de la tabla alumno y luego establecí la condición
de que el id sea mayor al id de la mitad de la tabla

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

Otra forma de hallar el segundo valor mas alto:

select max(colegiatura) as SegValMasAlto from platzi.alumnos
where not colegiatura = (
	select max(distinct(colegiatura)) from platzi.alumnos)

Y yo pensando que ya sabia sql 😿

Encontré dos posibles respuestas;

1. En la primera usando el Where saco el Máximo del ID el cual es un Integer Autoincremental y PK y lo divido entre 2
2. En la segunda hago algo similar pero en el offset esta vez con un conteo dividido 2 para que omita ese número específico de rows

En SQL server

SELECT colegiatura FROM(
	SELECT ROW_NUMBER() OVER(ORDER BY colegiatura DESC) AS row_id, *
	FROM (SELECT DISTINCT colegiatura FROM alumnos) AS dist_cole
) AS row_cole
WHERE row_id=2;