MySQL ordenar antes de agrupar por

Aquí se pueden encontrar muchas preguntas similares, pero no creo que ninguna responda la pregunta adecuadamente.

Continuaré con la pregunta más popular actual y usaré su ejemplo si está bien.

La tarea en este caso es obtener la última publicación para cada autor en la base de datos.

La consulta de ejemplo produce resultados inutilizables ya que no siempre es la última publicación que se devuelve.

SELECT wp_posts.* FROM wp_posts
    WHERE wp_posts.post_status='publish'
    AND wp_posts.post_type='post'
    GROUP BY wp_posts.post_author           
    ORDER BY wp_posts.post_date DESC

La respuesta actual aceptada es

SELECT
    wp_posts.*
FROM wp_posts
WHERE
    wp_posts.post_status='publish'
    AND wp_posts.post_type='post'
GROUP BY wp_posts.post_author
HAVING wp_posts.post_date = MAX(wp_posts.post_date) <- ONLY THE LAST POST FOR EACH AUTHOR
ORDER BY wp_posts.post_date DESC

Lamentablemente, esta respuesta es sencilla y errónea, y en muchos casos produce resultados menos estables que la consulta original.

Mi mejor solución es usar una subconsulta del formulario

SELECT wp_posts.* FROM 
(
    SELECT * 
    FROM wp_posts
    ORDER BY wp_posts.post_date DESC
) AS wp_posts
WHERE wp_posts.post_status='publish'
AND wp_posts.post_type='post'
GROUP BY wp_posts.post_author 

Mi pregunta es simple: ¿hay alguna forma de ordenar filas antes de agrupar sin recurrir a una subconsulta?

Editar : Esta pregunta fue una continuación de otra pregunta y los detalles de mi situación son ligeramente diferentes. Puede (y debe) asumir que también hay un wp_posts.id que es un identificador único para esa publicación en particular.

Usar un ORDER BYen una subconsulta no es la mejor solución para este problema.

La mejor solución para obtener el max(post_date)autor es usar una subconsulta para devolver la fecha máxima y luego unirla a su tabla tanto en la post_authorfecha como en la fecha máxima.

La solución debería ser:

SELECT p1.* 
FROM wp_posts p1
INNER JOIN
(
    SELECT max(post_date) MaxPostDate, post_author
    FROM wp_posts
    WHERE post_status='publish'
       AND post_type='post'
    GROUP BY post_author
) p2
  ON p1.post_author = p2.post_author
  AND p1.post_date = p2.MaxPostDate
WHERE p1.post_status='publish'
  AND p1.post_type='post'
order by p1.post_date desc

Si tiene los siguientes datos de muestra:

CREATE TABLE wp_posts
    (`id` int, `title` varchar(6), `post_date` datetime, `post_author` varchar(3))
;

INSERT INTO wp_posts
    (`id`, `title`, `post_date`, `post_author`)
VALUES
    (1, 'Title1', '2013-01-01 00:00:00', 'Jim'),
    (2, 'Title2', '2013-02-01 00:00:00', 'Jim')
;

La subconsulta devolverá la fecha máxima y el autor de:

MaxPostDate | Author
2/1/2013    | Jim

Luego, ya que está volviendo a unir eso a la tabla, en ambos valores devolverá los detalles completos de esa publicación.

Ver SQL Fiddle con Demo .

Para ampliar mis comentarios sobre el uso de una subconsulta para devolver con precisión estos datos.

MySQL no lo obliga a GROUP BYtodas las columnas que incluye en la SELECTlista. Como resultado, si solo tiene GROUP BYuna columna pero devuelve 10 columnas en total, no hay garantía de post_authorque se devuelvan los otros valores de columna que pertenecen a la columna . Si la columna no está en unGROUP BY MySQL, elige qué valor se debe devolver.

El uso de la subconsulta con la función agregada garantizará que se devuelva el autor y la publicación correctos cada vez.

Como nota al margen, si bien MySQL le permite usar un ORDER BYen una subconsulta y le permite aplicar una GROUP BYa no todas las columnas de la SELECTlista, este comportamiento no está permitido en otras bases de datos, incluido SQL Server.

Su solución hace uso de un extensión de la cláusula GROUP BY que permite agrupar por algunos campos (en este caso, solo post_author):

GROUP BY wp_posts.post_author

y seleccione columnas no agregadas:

SELECT wp_posts.*

que no se enumeran en el grupo por cláusula, o que no se utilizan en una función agregada (MIN, MAX, COUNT, etc.).

Uso correcto de la extensión a la cláusula GROUP BY

Esto es útil cuando todos los valores de las columnas no agregadas son iguales para cada fila.

Por ejemplo, suponga que tiene una mesa GardensFlowers( namedel jardín, flowerque crece en el jardín):

INSERT INTO GardensFlowers VALUES
('Central Park',       'Magnolia'),
('Hyde Park',          'Tulip'),
('Gardens By The Bay', 'Peony'),
('Gardens By The Bay', 'Cherry Blossom');

y desea extraer todas las flores que crecen en un jardín, donde crecen varias flores. Luego debe usar una subconsulta, por ejemplo, podría usar esto:

SELECT GardensFlowers.*
FROM   GardensFlowers
WHERE  name IN (SELECT   name
                FROM     GardensFlowers
                GROUP BY name
                HAVING   COUNT(DISTINCT flower)>1);

Si necesita extraer todas las flores que son las únicas flores en el jardinero, puede cambiar la condición de TENER a HAVING COUNT(DISTINCT flower)=1, pero MySql también le permite usar esto:

SELECT   GardensFlowers.*
FROM     GardensFlowers
GROUP BY name
HAVING   COUNT(DISTINCT flower)=1;

sin subconsulta, no SQL estándar, pero más simple.

Uso incorrecto de la extensión a la cláusula GROUP BY

Pero, ¿qué sucede si SELECCIONA columnas no agregadas que no son iguales para cada fila? ¿Cuál es el valor que elige MySql para esa columna?

Parece que MySql siempre elige el PRIMER valor que encuentra.

Para asegurarse de que el primer valor que encuentra es exactamente el valor que desea, debe aplicar GROUP BYa una consulta ordenada, de ahí la necesidad de utilizar una subconsulta. No puedes hacerlo de otra manera.

Dado el supuesto de que MySql siempre elige la primera fila que encuentra, está ordenando correctamente las filas antes de GROUP BY. Pero desafortunadamente, si lee la documentación detenidamente, notará que esta suposición no es cierta.

Al seleccionar columnas no agregadas que no son siempre iguales, MySql es libre de elegir cualquier valor, por lo que el valor resultante que realmente muestra es indeterminado .

Veo que este truco para obtener el primer valor de una columna no agregada se usa mucho, y generalmente / casi siempre funciona, lo uso a veces también (bajo mi propio riesgo). Pero como no está documentado, no puede confiar en este comportamiento.

Este enlace (¡gracias ypercube!) El truco GROUP BY ha sido optimizado y muestra una situación en la que la misma consulta devuelve resultados diferentes entre MySql y MariaDB, probablemente debido a un motor de optimización diferente.

Entonces, si este truco funciona, es solo cuestión de suerte.

La respuesta aceptada en la otra pregunta me parece incorrecta:

HAVING wp_posts.post_date = MAX(wp_posts.post_date)

wp_posts.post_datees una columna no agregada, y su valor será oficialmente indeterminado, pero probablemente será el primero que se post_dateencuentre. Pero dado que el truco GROUP BY se aplica a una tabla desordenada, no está seguro de cuál es el primeropost_date encuentra.

Probablemente devolverá publicaciones que son las únicas publicaciones de un solo autor, pero incluso esto no siempre es seguro.

Una posible solución

Creo que esta podría ser una posible solución:

SELECT wp_posts.*
FROM   wp_posts
WHERE  id IN (
  SELECT max(id)
  FROM wp_posts
  WHERE (post_author, post_date) = (
    SELECT   post_author, max(post_date)
    FROM     wp_posts
    WHERE    wp_posts.post_status='publish'
             AND wp_posts.post_type='post'
    GROUP BY post_author
  ) AND wp_posts.post_status='publish'
    AND wp_posts.post_type='post'
  GROUP BY post_author
)

En la consulta interna, estoy devolviendo la fecha máxima de publicación para cada autor. Entonces estoy teniendo en cuenta el hecho de que el mismo autor podría tener dos publicaciones al mismo tiempo, por lo que solo obtengo la ID máxima. Y luego estoy devolviendo todas las filas que tienen esas ID máximas. Podría hacerse más rápido utilizando combinaciones en lugar de la cláusula IN.

(Si está seguro de que IDsolo está aumentando, y si ID1 > ID2también significa eso post_date1 > post_date2, entonces la consulta podría hacerse mucho más simple, pero no estoy seguro de si este es el caso).

Lo que vas a leer es bastante chiflado, ¡así que no lo intentes en casa!

En SQL, en general, la respuesta a su pregunta es NO , pero debido al modo relajado de GROUP BY(mencionado por @bluefeet ), la respuesta es SÍ en MySQL.

Supongamos que tiene un índice BTREE en (post_status, post_type, post_author, post_date). ¿Cómo se ve el índice debajo del capó?

(post_status = 'publicar', post_type = 'publicar', post_author = 'usuario A', post_date = '2012-12-01') (post_status = 'publicar', post_type = 'publicar', post_author = 'usuario A', post_date = '2012-12-31') (post_status = 'publicar', post_type = 'post', post_author = 'usuario B', post_date = '2012-10-01') (post_status = 'publicar', post_type = ' post ', post_author =' usuario B ', post_date =' 2012-12-01 ')

Es decir, los datos se ordenan por todos esos campos en orden ascendente.

Cuando está haciendo un GROUP BYpor defecto, ordena los datos por el campo de agrupación ( post_authoren nuestro caso; post_status, post_type son requeridos por la WHEREcláusula) y si hay un índice coincidente, toma los datos de cada primer registro en orden ascendente. Esa es la consulta obtendrá lo siguiente (la primera publicación para cada usuario):

(post_status = 'publicar', post_type = 'publicar', post_author = 'usuario A', post_date = '2012-12-01') (post_status = 'publicar', post_type = 'publicar', post_author = 'usuario B', post_date = '2012-10-01')

Pero GROUP BYen MySQL le permite especificar el orden explícitamente. Y cuando solicite post_useren orden descendente, recorrerá nuestro índice en el orden opuesto, aún tomando el primer registro para cada grupo que en realidad es el último.

Es decir

...
WHERE wp_posts.post_status='publish' AND wp_posts.post_type='post'
GROUP BY wp_posts.post_author DESC

nos dará

(post_status = 'publicar', post_type = 'publicar', post_author = 'usuario B', post_date = '2012-12-01') (post_status = 'publicar', post_type = 'publicar', post_author = 'usuario A', post_date = '2012-12-31')

Ahora, cuando ordena los resultados de la agrupación por post_date, obtiene los datos que desea.

SELECT wp_posts.*
FROM wp_posts
WHERE wp_posts.post_status='publish' AND wp_posts.post_type='post'
GROUP BY wp_posts.post_author DESC
ORDER BY wp_posts.post_date DESC;

NB :

Esto no es lo que recomendaría para esta consulta en particular. En este caso, usaría una versión ligeramente modificada de lo que sugiere @bluefeet . Pero esta técnica puede ser muy útil. Echa un vistazo a mi respuesta aquí: recuperar el último registro de cada grupo

Errores : las desventajas del enfoque es que

• el resultado de la consulta depende del índice, que está en contra del espíritu del SQL (los índices solo deberían acelerar las consultas);
• index no sabe nada sobre su influencia en la consulta (usted u otra persona en el futuro podrían encontrar que el índice consume demasiado recursos y cambiarlo de alguna manera, rompiendo los resultados de la consulta, no solo su rendimiento)
• Si no comprende cómo funciona la consulta, lo más probable es que olvide la explicación en un mes y la consulta los confundirá a usted y a sus colegas.

La ventaja es el rendimiento en casos difíciles. En este caso, el rendimiento de la consulta debe ser el mismo que en la consulta de @ bluefeet, debido a la cantidad de datos involucrados en la clasificación (todos los datos se cargan en una tabla temporal y luego se ordenan; por cierto, su consulta también requiere el (post_status, post_type, post_author, post_date)índice) .

Lo que sugeriría :

Como dije, esas consultas hacen que MySQL pierda tiempo clasificando cantidades potencialmente enormes de datos en una tabla temporal. En caso de que necesite paginación (es decir, LIMIT está involucrado), la mayoría de los datos incluso se descartan. Lo que haría es minimizar la cantidad de datos ordenados: es decir, ordenar y limitar un mínimo de datos en la subconsulta y luego volver a unirme a la tabla completa.

SELECT * 
FROM wp_posts
INNER JOIN
(
  SELECT max(post_date) post_date, post_author
  FROM wp_posts
  WHERE post_status='publish' AND post_type='post'
  GROUP BY post_author
  ORDER BY post_date DESC
  -- LIMIT GOES HERE
) p2 USING (post_author, post_date)
WHERE post_status='publish' AND post_type='post';

La misma consulta utilizando el enfoque descrito anteriormente:

SELECT *
FROM (
  SELECT post_id
  FROM wp_posts
  WHERE post_status='publish' AND post_type='post'
  GROUP BY post_author DESC
  ORDER BY post_date DESC
  -- LIMIT GOES HERE
) as ids
JOIN wp_posts USING (post_id);

Todas esas consultas con sus planes de ejecución en SQLFiddle .

Prueba este. Simplemente obtenga la lista de las últimas fechas de publicación de cada autor . Eso es

SELECT wp_posts.* FROM wp_posts WHERE wp_posts.post_status='publish'
AND wp_posts.post_type='post' AND wp_posts.post_date IN(SELECT MAX(wp_posts.post_date) FROM wp_posts GROUP BY wp_posts.post_author) 

No. No tiene sentido ordenar los registros antes de la agrupación, ya que la agrupación va a mutar el conjunto de resultados. La forma de subconsulta es la forma preferida. Si esto va demasiado lento, tendría que cambiar el diseño de su tabla, por ejemplo, almacenando la identificación de la última publicación para cada autor en una tabla separada, o introducir una columna booleana que indique para cada autor cuál de sus publicaciones es la última uno.

Solo use la función max y la función de grupo

    select max(taskhistory.id) as id from taskhistory
            group by taskhistory.taskid
            order by taskhistory.datum desc

Solo para recapitular, la solución estándar utiliza una subconsulta no correlacionada y se ve así:

SELECT x.*
  FROM my_table x
  JOIN (SELECT grouping_criteria,MAX(ranking_criterion) max_n FROM my_table GROUP BY grouping_criteria) y
    ON y.grouping_criteria = x.grouping_criteria
   AND y.max_n = x.ranking_criterion;

Si está utilizando una versión antigua de MySQL, o un conjunto de datos bastante pequeño, puede utilizar el siguiente método:

SELECT x.*
  FROM my_table x
  LEFT
  JOIN my_table y
    ON y.joining_criteria = x.joining_criteria
   AND y.ranking_criteria < x.ranking_criteria
 WHERE y.some_non_null_column IS NULL;  

** Las subconsultas pueden tener un impacto negativo en el rendimiento cuando se usan con grandes conjuntos de datos **

Consulta original

SELECT wp_posts.*
FROM   wp_posts
WHERE  wp_posts.post_status = 'publish'
       AND wp_posts.post_type = 'post'
GROUP  BY wp_posts.post_author
ORDER  BY wp_posts.post_date DESC; 

Consulta modificada

SELECT p.post_status,
       p.post_type,
       Max(p.post_date),
       p.post_author
FROM   wp_posts P
WHERE  p.post_status = "publish"
       AND p.post_type = "post"
GROUP  BY p.post_author
ORDER  BY p.post_date; 

porque estoy usando maxen el select clause==> max(p.post_date)es posible evitar consultas de selección secundaria y ordenar por la columna máxima después del grupo por.

Primero, no use * en select, afecta su rendimiento e impide el uso del grupo por y el orden por. Prueba esta consulta:

SELECT wp_posts.post_author, wp_posts.post_date as pdate FROM wp_posts
WHERE wp_posts.post_status='publish'
AND wp_posts.post_type='post'
GROUP BY wp_posts.post_author           
ORDER BY pdate DESC

Cuando no especifica la tabla en ORDER BY, solo el alias, ordenarán el resultado de la selección.