Kolejność MySQL według grupuj według

Można tu znaleźć wiele podobnych pytań, ale nie sądzę, aby jakakolwiek odpowiedź na to pytanie była odpowiednia.

Będę kontynuować od najpopularniejszego pytania i użyję ich przykładu, jeśli to w porządku.

W tym przypadku zadaniem jest uzyskanie najnowszego postu dla każdego autora w bazie danych.

Przykładowe zapytanie daje bezużyteczne wyniki, ponieważ nie zawsze jest to ostatni zwracany post.

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

Obecna akceptowana odpowiedź to

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

Niestety ta odpowiedź jest prosta i błędna, aw wielu przypadkach daje mniej stabilne wyniki niż pierwotne zapytanie.

Moim najlepszym rozwiązaniem jest użycie podzapytania formularza

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 

Moje pytanie jest więc proste: czy w ogóle można zamówić wiersze przed grupowaniem bez uciekania się do podzapytania?

Edycja : To pytanie było kontynuacją innego pytania, a specyfika mojej sytuacji jest nieco inna. Możesz (i powinieneś) założyć, że istnieje również wp_posts.id, który jest unikalnym identyfikatorem dla tego konkretnego postu.

Korzystanie ORDER BYz podzapytania nie jest najlepszym rozwiązaniem tego problemu.

Najlepszym rozwiązaniem, aby uzyskać max(post_date)autor, jest użycie podzapytania, aby zwrócić maksymalną datę, a następnie dołączyć ją do tabeli zarówno w post_authordniu maksymalnym, jak i maksymalnym.

Rozwiązaniem powinno być:

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

Jeśli masz następujące przykładowe dane:

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

Podkwerenda zwróci maksymalną datę i autora:

MaxPostDate | Author
2/1/2013    | Jim

Następnie, ponieważ dołączasz to z powrotem do tabeli, w przypadku obu wartości zwrócisz pełne szczegóły tego postu.

Zobacz SQL Fiddle with Demo .

Aby rozwinąć moje komentarze na temat korzystania z podzapytania w celu dokładnego zwrócenia tych danych.

MySQL nie zmusza cię do GROUP BYkażdej kolumny, którą umieszczasz na SELECTliście. W rezultacie, jeśli tylko GROUP BYjedna kolumna zwróci łącznie 10 kolumn, nie ma gwarancji, że pozostałe wartości kolumn należące do tej, post_authorktóra zostanie zwrócona. Jeśli kolumna nie znajduje się w GROUP BYMySQL, wybiera jaką wartość należy zwrócić.

Użycie podzapytania z funkcją agregującą zagwarantuje, że poprawny autor i post będą zwracane za każdym razem.

Na marginesie, podczas gdy MySQL pozwala na użycie ORDER BYw podzapytaniu i pozwala zastosować GROUP BYdo nie każdej kolumny na SELECTliście, to zachowanie nie jest dozwolone w innych bazach danych, w tym SQL Server.

Twoje rozwiązanie korzysta z rozszerzenia klauzuli GROUP BY , która pozwala grupować według niektórych pól (w tym przypadku po prostu post_author):

GROUP BY wp_posts.post_author

i wybierz niezagregowane kolumny:

SELECT wp_posts.*

które nie są wymienione w grupie według klauzuli lub które nie są używane w funkcji agregującej (MIN, MAX, COUNT itp.).

Prawidłowe użycie rozszerzenia klauzuli GROUP BY

Jest to przydatne, gdy wszystkie wartości niezagregowanych kolumn są równe dla każdego wiersza.

Załóżmy na przykład, że masz stół GardensFlowers( namew ogrodzie, flowerktóry rośnie w ogrodzie):

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

i chcesz wydobyć wszystkie kwiaty, które rosną w ogrodzie, w którym rośnie wiele kwiatów. Następnie musisz użyć podzapytania, na przykład możesz użyć tego:

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

Jeśli zamiast tego musisz wyodrębnić wszystkie kwiaty, które są jedynymi kwiatami w garderobie, możesz po prostu zmienić warunek HAVING na HAVING COUNT(DISTINCT flower)=1, ale MySql pozwala również na użycie tego:

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

bez podkwerendy, niestandardowy SQL, ale prostszy.

Niepoprawne użycie rozszerzenia klauzuli GROUP BY

Ale co się stanie, jeśli wybierzesz niezagregowane kolumny, które nie są równe dla każdego wiersza? Jaką wartość wybiera MySql dla tej kolumny?

Wygląda na to, że MySql zawsze wybiera PIERWSZĄ wartość, na jaką napotyka.

Aby upewnić się, że pierwsza napotkana wartość jest dokładnie taką, jakiej potrzebujesz, musisz zastosować a GROUP BYdo uporządkowanego zapytania, stąd potrzeba użycia podzapytania. Nie możesz tego zrobić inaczej.

Zakładając, że MySql zawsze wybiera pierwszy napotkany wiersz, poprawnie sortujesz wiersze przed GROUP BY. Ale niestety, jeśli dokładnie przeczytasz dokumentację, zauważysz, że to założenie nie jest prawdziwe.

Podczas wybierania niezagregowanych kolumn, które nie zawsze są takie same, MySql może wybrać dowolną wartość, więc wynikowa wartość, którą faktycznie pokazuje, jest nieokreślona .

Widzę, że ta sztuczka polegająca na uzyskaniu pierwszej wartości niezagregowanej kolumny jest często używana i zwykle / prawie zawsze działa, czasem jej używam (na własne ryzyko). Ale ponieważ nie jest to udokumentowane, nie możesz polegać na tym zachowaniu.

Ten link (dzięki ypercube!) Sztuczka GROUP BY została zoptymalizowana, pokazuje sytuację, w której to samo zapytanie zwraca różne wyniki między MySql a MariaDB, prawdopodobnie z powodu innego silnika optymalizacji.

Więc jeśli ta sztuczka się sprawdzi, to tylko kwestia szczęścia.

Akceptowane odpowiedź na inne pytanie wygląda źle do mnie:

HAVING wp_posts.post_date = MAX(wp_posts.post_date)

wp_posts.post_datejest niezagregowaną kolumną, a jej wartość zostanie oficjalnie nieokreślona, ​​ale prawdopodobnie będzie to pierwsza post_datenapotkana. Ale ponieważ sztuczka GROUP BY jest stosowana do nieuporządkowanej tabeli, nie jest pewne, która jest pierwsza post_datenapotkana.

Prawdopodobnie zwróci posty, które są jedynymi postami jednego autora, ale nawet to nie zawsze jest pewne.

Możliwe rozwiązanie

Myślę, że to może być możliwe rozwiązanie:

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
)

Na wewnętrzne zapytanie zwracam maksymalną datę publikacji dla każdego autora. Następnie biorę pod uwagę fakt, że ten sam autor może teoretycznie mieć dwa posty w tym samym czasie, więc otrzymuję tylko maksymalny identyfikator. A potem zwracam wszystkie wiersze, które mają te maksymalne identyfikatory. Można to zrobić szybciej, używając sprzężeń zamiast klauzuli IN.

(Jeśli jesteś pewien, że IDto tylko rośnie, a jeśli ID1 > ID2to oznacza post_date1 > post_date2, to zapytanie może być znacznie prostsze, ale nie jestem pewien, czy tak jest).

To, co zamierzasz przeczytać, jest raczej hakerskie, więc nie próbuj tego w domu!

Ogólnie w SQL odpowiedź na twoje pytanie brzmi NIE , ale ze względu na zrelaksowany tryb GROUP BY(wspomniany przez @bluefeet ) odpowiedź w MySQL brzmi TAK .

Załóżmy, że masz indeks BTREE na (post_status, post_type, post_author, post_date). Jak wygląda indeks pod maską?

(post_status = 'opublikuj', post_type = 'post', post_author = 'użytkownik A', post_date = '2012-12-01') (post_status = 'opublikuj', post_type = 'post', post_author = 'użytkownik A', post_date = '2012-12-31') (post_status = 'opublikuj', post_type = 'post', post_author = 'użytkownik B', post_date = '2012-10-01') (post_status = 'opublikuj', post_type = ' post ”, post_author =„ użytkownik B ”, post_date =„ 2012-12-01 ”)

Oznacza to, że dane są sortowane według wszystkich pól w porządku rosnącym.

Podczas wykonywania GROUP BYdomyślnie sortuje dane według pola grupującego ( post_authorw naszym przypadku; post_status, typ_typu są wymagane przez WHEREklauzulę), a jeśli istnieje zgodny indeks, pobiera dane dla każdego pierwszego rekordu w porządku rosnącym. To jest zapytanie pobierze następujące (pierwszy post dla każdego użytkownika):

(post_status = 'opublikuj', post_type = 'post', post_author = 'użytkownik A', post_date = '2012-12-01') (post_status = 'opublikuj', post_type = 'post', post_author = 'użytkownik B', post_date = „2012-10-01”)

Ale GROUP BYw MySQL pozwala jawnie określić kolejność. A kiedy poprosisz post_userw kolejności malejącej, przejdzie on przez nasz indeks w odwrotnej kolejności, wciąż biorąc pierwszy rekord dla każdej grupy, która jest rzeczywiście ostatnia.

To jest

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

da nam

(post_status = 'opublikuj', post_type = 'post', post_author = 'użytkownik B', post_date = '2012-12-01') (post_status = 'opublikuj', post_type = 'post', post_author = 'użytkownik A', post_date = „2012-12-31”)

Teraz, kiedy zamawiasz wyniki grupowania według post_date, otrzymujesz pożądane dane.

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 :

Nie to poleciłbym dla tego konkretnego zapytania. W takim przypadku użyłbym nieco zmodyfikowanej wersji sugerowanej przez @bluefeet . Ale ta technika może być bardzo przydatna. Spójrz na moją odpowiedź tutaj: Pobieranie ostatniego rekordu w każdej grupie

Pułapki : wady tego podejścia

• wynik zapytania zależy od indeksu, co jest sprzeczne z duchem SQL (indeksy powinny tylko przyspieszać zapytania);
• indeks nie wie nic o jego wpływie na zapytanie (ty lub ktoś w przyszłości może uznać, że indeks jest zbyt pochłaniający zasoby i jakoś go zmienić, przerywając wyniki zapytania, a nie tylko jego wydajność)
• jeśli nie rozumiesz, jak działa zapytanie, najprawdopodobniej zapomnisz wyjaśnienia za miesiąc, a zapytanie spowoduje zamieszanie ciebie i twoich kolegów.

Zaletą jest wydajność w trudnych przypadkach. W takim przypadku wydajność zapytania powinna być taka sama, jak w zapytaniu @ bluefeet, ze względu na ilość danych zaangażowanych w sortowanie (wszystkie dane są ładowane do tabeli tymczasowej, a następnie sortowane; przy okazji jego zapytanie również wymaga (post_status, post_type, post_author, post_date)indeksu) .

Co sugerowałbym :

Jak powiedziałem, zapytania te powodują, że MySQL marnuje czas na sortowanie potencjalnie dużych ilości danych w tabeli tymczasowej. W przypadku, gdy potrzebujesz stronicowania (dotyczy to LIMIT), większość danych jest nawet odrzucana. Chciałbym zminimalizować ilość posortowanych danych: to posortować i ograniczyć minimum danych w podzapytaniu, a następnie dołączyć ponownie do całej tabeli.

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

To samo zapytanie przy użyciu podejścia opisanego powyżej:

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

Wszystkie te zapytania wraz z ich planami wykonania na SQLFiddle .

Spróbuj tego. Wystarczy pobrać listę najnowszych dat postów od każdego autora . Otóż ​​to

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) 

Nie. Nie ma sensu porządkowanie rekordów przed grupowaniem, ponieważ grupowanie spowoduje mutację zestawu wyników. Preferowana jest metoda zapytania częściowego. Jeśli to idzie zbyt wolno, musiałbyś zmienić projekt tabeli, na przykład przechowując identyfikator ostatniego postu dla każdego autora w osobnej tabeli lub wprowadzić kolumnę logiczną wskazującą dla każdego autora, który z jego postów jest ostatnim jeden.

Wystarczy użyć funkcji max i funkcji grupy

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

Podsumowując, standardowe rozwiązanie wykorzystuje nieskorelowane podzapytanie i wygląda następująco:

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;

Jeśli używasz starożytnej wersji MySQL lub dość małego zestawu danych, możesz użyć następującej metody:

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;  

** Zapytania podrzędne mogą mieć zły wpływ na wydajność, jeśli są używane z dużymi zestawami danych **

Oryginalne zapytanie

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; 

Zmodyfikowane zapytanie

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; 

ponieważ używam maxw select clause==> max(p.post_date)możliwe jest uniknięcie zapytań subselekcji i uporządkowanie według maksymalnej kolumny po grupie według.

Po pierwsze, nie używaj * w select, wpływa to na ich wydajność i utrudnia korzystanie z grupy według i sortowanie według. Spróbuj tego zapytania:

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

Jeśli nie określisz tabeli w ORDER BY, tylko alias, uporządkują wynik zaznaczenia.