Contenido del curso
El segundo más alto
Alan Kevin Fuentes García
Estudiante
Iván Godoy
Estudiante
Kevin Yahir Garcia Gutierrez
Estudiante
Gustavo Fabian Sandoval
Estudiante
Francisco Murillo
Estudiante
Andrés Cardona
Estudiante
Bárbara de los Ángeles Morantes Carvajal
Estudiante
Orlando Ramirez
EstudianteOrlando Ramirez
Estudiante
Arnol Fabian Plazas Acevedo
Estudiante
John Alexander Ortiz Ramirez
Estudiante
Adriel Salguero
Estudiante
Luis Angel Pasos Montalvo
Estudiante
Joel Eduardo Gaspar
Estudiante
José Eduardo Morales Raygoza
Estudiante
david roberto urquiza rivera
Estudiante
Jhonney Correa
Estudiante
Javier Hugo Noto Enriquez
Estudiante
Abraham Leonel Salmerón Cimé
Estudiante
Solano Hilario
Estudiante
anderson chaparro
Estudiante
Carlos Vargas
Estudiante
Lucia Ugarte Huayhua
Estudiante
María Guadalupe Cerron Rocha
Estudiante
Sergio Fernando Blanco Ojeda
Estudiante
Juan Guillermo Leon
Estudiante
María Mercedes Eizaga Oberto
Estudiante
Cristian Orlando Rincon Bonilla
EstudianteBárbara de los Ángeles Morantes Carvajal
Estudiante
Juan Camilo Alfonso Mesquida
Estudiante
Manuel Espitia
Estudiante
Ricardo Ortiz
EstudianteEdgar Bernal
Estudiante
Humberto Adrián Hernández Maldonado
Estudiante
Miguel Martínez
Estudianteanderson chaparro
Estudiante
Fernando Yutiz
Estudiante
Jhon Stiven Posso Cardona
Estudiante
Alvarez Pozo Hugo Felipe
Estudiante
Jeyson David Vargas Crespo
Estudiante
Alex Camacho
Profesor
Marco Antonio Candia Ortega
Estudiante
Brayan Buitrago
EstudianteMe 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.
Gracias por la explicación.
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
Mi query
SELECT * FROM platzi.alumnos OFFSET ( SELECT (COUNT(id)/2) FROM platzi.alumnos )
wooow me gusto la forma que lo resolviste, estuve cerca de hacerlo asi, aunque tuve el mismo resultado, el tuyo es mas funcional
Excelente, incluso es más eficiente que:
SELECT * FROM platzi.alumnos OFFSET 499;
Porque ejecuta menos pasos
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.
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.
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.
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 );
Hola! probe hacer el mismo query pero me sale error en el OFFSET. Sabras porque?
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
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
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!
si intento tu código me sale que select debería de estar en otra posición :c
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:
SELECT DISTINCT colegiaturaFROM platzi.alumnos AS a1
Crea una tabla con los siguientes valores:
[3000,2000,2300,4500,3500,5000,2500,4800]
WHERE 2 = (Subconsutta)
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
Tu aporte igual me ayudó a entender esa primera query.
Aun sigo en duda porque hace el WHERE 2=SUBCONSULTA. El ejemplo del WHERE = (SUB CONSULTA) si logro entenderlo.
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
Acabo de comprobarlo y es cierto lo que comentas, de hecho ese WHERE hacia un poco mas confuso el query.
Para que sala solo tutor 20, hay que agregar el nombre en SELECT. SELECT DISTINCT colegiatura, tutor_id
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 =(
Ese es el reto llevar tu conocimiento a otro nivel no pares te aprender!
Me senti igual
Otra opción:
SELECT * FROM platzi.alumnos OFFSET 500 ROWS FETCH FIRST 500 ROWS ONLY```
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.
Está es muy buena solución pero está limitada a una tabla de 1000 registros.
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.
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;
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
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;
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.
tengo la misma duda no entiendo esta parte del codigo
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
Hola, como funciona el OVER()???
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
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)
