Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Curso Práctico de SQL

Curso Práctico de SQL

Israel Vázquez Morales

Israel Vázquez Morales

El segundo más alto

11/29
Recursos

Aportes 255

Preguntas 20

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

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 )

Mi solucion al reto

SELECT * 
    FROM platzi.alumnos
    OFFSET ( SELECT COUNT(*)/2 FROM platzi.alumnos );
SELECT *
FROM platzi.alumnos
WHERE id > (
SELECT COUNT(*)/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.

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

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

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 ) 

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;

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
)

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

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

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.

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)

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.

Mis soluciones:

SELECT *
FROM platzi.alumnos
WHERE id > 500
ORDER BY id ASC
SELECT *
FROM (
    SELECT *
    FROM platzi.alumnos
    ORDER BY id DESC
    LIMIT 500 
    ) AS inverse_db
ORDER BY inverse_db.id ASC

OFFSET se utiliza para saltarse (skip) n cantidad de rows, por lo tanto, se puede realizar un subquery que ejecute un count de todos los registros y dicho valor dividirlo a la mitad.

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

select *
from platzi.alumnos
limit 500 offset 500
;

Pues esta es mi consulta, no se si este bien, pero me trajo el mismo resultado,

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

Para mostrar la segunda mitad de la tabla lo hice de la siguiente manera:

  1. Identifiqué cuantos registros tenía la tabla así:

Vemos que el resultado es 1000, por lo tanto usaremos algún query que nos muestre desde el id 500 en adelante:

Bueno, a mi se me ocurrió lo “obvio”.
Primero hice un SELECT COUNT para saber cuantas filas había.

SELECT COUNT(*)
FROM platzi.alumnos;

Al ver que hay 1000 datos, la primera parte sería desde 1 a 500 y la otra parte sería de 501 a 1000.

SELECT *
FROM platzi.alumnos
OFFSET 500
LIMIT 500;

with bottom as
(select top 50 percent * from tbl_alumnos order by id desc)
select ROW_NUMBER() OVER(ORDER BY id asc) as row_id, *
from bottom order by row_id

Muy buenas a todos.

Esa es una forma que encontré de Hacerlo, es Código SQL Server…

No está demás mencionar que en SQL Server no admite las sentencias LIMIT() y OFFSET()

Solo se me ocurrió esta forma para hacer el reto. Que opina?

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

Asi fue como lo hice

SELECT *
FROM platzi.alumnos
WHERE id >

	(
	SELECT avg(id)
	FROM platzi.alumnos
	);

Dejo acá mi forma de resolverlo

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

Hola, esta fue mi solución:

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

😃 😃
Select *
From platzi.alumnos
Fetch first 5 Rows ONLY;

RETO


SELECT *
FROM 
	(SELECT ROW_NUMBER() OVER(),*
	 FROM platzi.alumnos) as alumnos_data
WHERE row_number > (SELECT COUNT(*) FROM platzi.alumnos)/2;
SELECT ROW_NUMBER() OVER() AS row_id, *
FROM platzi.alumnos
OFFSET (
	SELECT COUNT(*)/2
	FROM platzi.alumnos
);
<select * from platzi.alumnos
limit 500 offset 500;> 

Reto de la clase:

SELECT *
FROM platzi.alumnos
WHERE id IN (
	SELECT id
	FROM platzi.alumnos
	WHERE tutor_id != 20
);

Aprovechando el id, la solucion mas facil seria

SELECT *
FROM platzi.alumnos
WHERE alumnos.id > 500 and alumnos.id <= 1000
ORDER BY id
;
--ejercicio
select *
from alumnos
where id > (select count(id)/2
from alumnos);

La segunda tarea lo realice de esta modo

SELECT COUNT (*)
FROM platzi.alumnos

SELECT *
FROM platzi.alumnos
OFFSET 500
LIMIT 500;

Aunque no he entendido muy bien window funtion, Acá esta es mi solución al reto con esta herramienta XD.

SELECT * FROM (
		SELECT ROW_NUMBER() OVER() AS row_id, *
		FROM platzi.alumnos)
AS alumnos_with_row_num
WHERE row_id >= (SELECT (count(id) / 2) FROM platzi.alumnos);

Ya me estaré volviendo fancy.

Mi respuesta a la tarea:

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

Sólo por practicar windows functions y CTEs

WITH colegiatura (valor)
-- Las distintas colegiaturas en orden descendiente
AS
(
	SELECT DISTINCT colegiatura
	FROM platzi.alumnos
	ORDER BY colegiatura DESC
),
numerado
-- La tabla anterior numerada
AS
(
	SELECT ROW_NUMBER() OVER() AS row_id, precio
	FROM colegiatura
)
-- El SELECT de toda la vida
SELECT valor
FROM numerado
WHERE row_id = 2
;

Así fue como resolví el reto

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

Excelente video!

Yo saqué la segunda colegiatura más alta así:

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

Comparto mi query:

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

La manera mas sencilla que consegui y mas rapida (59 msec)

SELECT *
FROM platzi.alumnos
LIMIT 500 OFFSET 500;

Mi aporte:

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

Aqui la solucion que se me ocurrio, para hacerlo de manera general y no depender de ingresar el numero total de filas que tenemos.

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

El query del reto es:

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

Desafio:

-- Desafio: Traer solamente la segunda mitad de la tabla

SELECT *
FROM ( 
	SELECT ROW_NUMBER() OVER() AS row_id, * 
	FROM platzi.alumnos) AS number_table
WHERE number_table.row_id > (
	SELECT COUNT(id)/2 AS media_tabla
	FROM platzi.alumnos
	)
ORDER BY row_id ASC;

Mi solución al reto de la segunda mitad 👀:


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

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

En mi caso para el reto fue un poco mas estrecho pero me funciono, primero Conte el total de datos con:

<SELECT  COUNT(ID) FROM platzi.alumnos;> 

y despues solo consulte que me diera de 500 par arriba con:

< SELECT  * FROM platzi.alumnos OFFSET 500;> 

se que hay maneras mejores pero funciona para un momento.

Mi solución al reto del final

select row_number() over() as row_num, *
from (
	select row_number() over() as row_num, *
	from platzi.alumnos
) alumnos_with_row_num
where row_num >= (select count(*) from platzi.alumnos) / 2;

Lo hice en MySQL:

SELECT *
FROM platzi.alumnos
Where id >= (
    SELECT (count(id)/2)
    FROM platzi.alumnos);

En la penúltima forma, el “WHERE tutor_id =20” sale sobrando en el subquery.
Si lo que queremos es que nos despliegue todos los alumnos que pagan la segunda mayor colegiatura y que tienen asignado al tutor_id = 20, el WHERE debería ir al final de la sentencia:

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;

De igual forma si lo que queremos que nos despliegue a todos los alumnos que pagan la segunda mayor colegiatura, ese WHERE se quita del query y listo.

Select *
from platzi.alumnos
limit 500 offset 500;

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

Mi query con subquery quedo:
SELECT *
FROM platzi.alumnos
OFFSET (
SELECT COUNT(*)
FROM platzi.alumnos AS total_rows
) /2

select *
from platzi.alumnos
offset ((select count(1)
from platzi.alumnos)/2);

**Una forma más para obtener el segundo más alto. Esto les puede ayudar con otro tipo de retos
**

Select Colegiatura From (
SELECT Distinct  Colegiatura,
DENSE_RANK()  OVER(ORDER BY Colegiatura DESC) as Rank FROM platzi.alumnos 
) Datos where Rank = 2

No se deja entender muy bien.

mi solución:
select *
from platzi.alumnos
offset (select count(id)
from platzi.alumnos)/2;

-- Ejercicio del segundo video
Select * from platzi.alumnos
offset (select count (id)/2 
		from platzi.alumnos); 

Mi aporte al reto, solución de tres formas distintas:

SELECT * 
FROM platzi.alumnos
ORDER BY id DESC
LIMIT (	SELECT COUNT(*) 
		FROM platzi.alumnos)/2
;
----------------------------
SELECT * 
FROM platzi.alumnos
OFFSET (	SELECT COUNT(*) 
		FROM platzi.alumnos)/2 
;
----------------------------
SELECT * 
FROM platzi.alumnos
ORDER BY id DESC
FETCH FIRST ((	SELECT COUNT(*) FROM platzi.alumnos)/2)  ROWS ONLY;


Esto fue lo que se me ocurrió:

SELECT *
FROM platzi.alumnos
WHERE id BETWEEN (
	SELECT COUNT(id)/2
	FROM platzi.alumnos) AND (
	SELECT COUNT(id)
	FROM platzi.alumnos);
select id,nombre, colegiatura
from platzi.alumnos
where id > (
		select count(*)/2
		from platzi.alumnos
		)

Mi reto lo sorteé así

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

Yo pensé en agrupar primero los datos según la colegiatura, luego ordenarlos y luego mostrar el segundo ID 😃

SELECT colegiatura
FROM platzi.alumnos
group by colegiatura 
order by colegiatura DESC
limit 1 offset 1;

Solución en SQL server

Creo que hay un error en el subquery porque solo trae los resultados con colegiatura = 4800 pero no donde el tutor_id=20. Para ello se puede poner un AND y agregar la condición del tutor_id, así:

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

Aquí tres posibles soluciones:

SELECT *
FROM platzi.alumnos
WHERE id >= 500

SELECT *
FROM (
	SELECT ROW_NUMBER() OVER() as row_id, *
	FROM platzi.alumnos
) AS alumnos_with_row_num
WHERE row_id > (
	SELECT COUNT(*)/2
	FROM platzi.alumnos
);

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

Reto:

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

Mi solucion al reto

La solución del reto me quedó así:

< select * from platzi.alumnos limit (select count(*)/2 from platzi.alumnos ); > 

Al final a mi me quedo asi
select *
from platzi.alumnos
offset
(select count(*) / 2
**from **platzi.alumnos)

Saludos a todos

Mi solución al reto:

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

select * from platzi.alumnos as table01

inner join (select id  from   platzi.alumnos  
		  limit ((select count(*) from platzi.alumnos)/2) offset ((select count(*) from platzi.alumnos)/2)) as table02 on table01.id=table02.id
		  ;
SELECT  *
FROM platzi.alumnos
WHERE id >= (
	SELECT MAX(id) / 2
	FROM platzi.alumnos
)

Mi solución al reto

SELECT * 
FROM platzi.alumnos
WHERE id <= (
SELECT COUNT(id)/2
FROM platzi.alumnos
)

usando el Window function del ejercicio pasado quede con este script

select * from (
	select row_number () over () as row_id,*
	from platzi.alumnos) as seg_mitad
	where row_id > 500;

Yo lo hice de esta forma 😄

SELECT *
FROM (
SELECT ROW_NUMBER() OVER() AS row_id,*
FROM platzi.alumnos
)AS alumnos_with_row_num
WHERE row_id IN (1,2,3,4,5);

Esto es mas cool de lo esperado 😃

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

Yo resolví el problema planteado al final así. De esta manera aunque los registros vayan aumentando el query dinámicamente traerá siempre la mitad de los registros.

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

Esta es mi solución al ejercicio propuesto en clase:

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

otra solución que encontré fue:

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

SELECT *
FROM platzi.alumnos
LIMIT 500 OFFSET 500;

así me salió

select * from platzi.alumnos
offset 500 limit 500;

select * from platzi.alumnos
order by id desc limit 500;

sin conocer la cantidad de los registros

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

select * from platzi.alumnos offset (select count(id)/2-1 from platzi.alumnos);

conociendo la cantidad de registros

select * from platzi.alumnos
offset 500 limit 500;

select * from platzi.alumnos
order by id desc limit 500;

sin conocer la cantidad de los registros

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

select * from platzi.alumnos offset (select count(id)/2-1 from platzi.alumnos);

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

///

SELECT *
FROM platzi.alumnos
WHERE id >= 500

///

SELECT *
FROM platzi.alumnos
ORDER BY ID
OFFSET 499

Aqui la tarea

SELECT *
FROM platzi.alumnos
WHERE id >= (
	SELECT MAX(id)/2
	FROM platzi.alumnos
)

Esta fue mi solución:

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