C'è qualche differenza tra GROUP BY e DISTINCT

L'altro giorno ho imparato qualcosa di semplice su SQL:

SELECT c FROM myTbl GROUP BY C

Ha lo stesso risultato di:

SELECT DISTINCT C FROM myTbl

Ciò di cui sono curioso, c'è qualcosa di diverso nel modo in cui un motore SQL elabora il comando o sono davvero la stessa cosa?

Personalmente preferisco la sintassi distinta, ma sono sicuro che sia più per abitudine che altro.

EDIT: questa non è una domanda sugli aggregati. GROUP BYÈ compreso l'uso di con funzioni aggregate.

La risposta di MusiGenesis è funzionalmente corretta per quanto riguarda la tua domanda come indicato; SQL Server è abbastanza intelligente da rendersi conto che se si utilizza "Raggruppa per" e non si utilizzano funzioni aggregate, ciò che si intende effettivamente è "Distinto" - e quindi genera un piano di esecuzione come se si fosse semplicemente usato "Distinto ".

Tuttavia, penso che sia importante notare anche la risposta di Hank - il trattamento sprezzante di "Raggruppa per" e "Distinto" potrebbe portare ad alcuni dannosi trucchi se non stai attento. Non è del tutto corretto affermare che questa "non è una domanda sugli aggregati" perché stai chiedendo la differenza funzionale tra due parole chiave di query SQL, una delle quali è pensata per essere utilizzata con gli aggregati e una non lo è.

A volte un martello può funzionare per avvitare una vite, ma se hai un cacciavite a portata di mano, perché preoccuparsi?

(ai fini di questa analogia Hammer : Screwdriver :: GroupBy : Distincte screw => get list of unique values in a table column)

GROUP BYconsente di utilizzare le funzioni di aggregazione, come AVG, MAX, MIN, SUM, e COUNT. D'altra parte DISTINCTrimuove solo i duplicati.

Ad esempio, se hai un sacco di record di acquisto e vuoi sapere quanto è stato speso da ciascun dipartimento, potresti fare qualcosa del tipo:

SELECT department, SUM(amount) FROM purchases GROUP BY department

Questo ti darà una riga per reparto, contenente il nome del reparto e la somma di tutti i amountvalori in tutte le righe per quel dipartimento.

Non c'è differenza (almeno in SQL Server). Entrambe le query utilizzano lo stesso piano di esecuzione.

http://sqlmag.com/database-performance-tuning/distinct-vs-group

Forse c'è una differenza, se ci sono sub-query coinvolte:

http://blog.sqlauthority.com/2007/03/29/sql-server-difference-between-distinct-and-group-by-distinct-vs-group-by/

Non c'è differenza (stile Oracle):

http://asktom.oracle.com/pls/asktom/f?p=100:11:0::::P11_QUESTION_ID:32961403234212

Qual è la differenza da un semplice punto di vista della funzionalità di rimozione duplicata

A parte il fatto che a differenza DISTINCT, GROUP BYconsente di aggregare dati per gruppo (che è stato menzionato da molte altre risposte), la differenza più importante secondo me è il fatto che le due operazioni "avvengono" in due fasi molto diverse nell'ordine logico delle operazioni eseguite in una SELECTdichiarazione .

Ecco le operazioni più importanti:

• FROM(tra cui JOIN, APPLY, etc.)
• WHERE
• GROUP BY (può rimuovere i duplicati)
• aggregazioni
• HAVING
• Funzioni della finestra
• SELECT
• DISTINCT (può rimuovere i duplicati)
• UNION, INTERSECT, EXCEPT (Può rimuovere i duplicati)
• ORDER BY
• OFFSET
• LIMIT

Come puoi vedere, l'ordine logico di ogni operazione influenza ciò che può essere fatto con essa e come influenza le operazioni successive. In particolare, il fatto che l' GROUP BYoperazione "avviene prima" l' SELECToperazione (sporgenza) significa che:

1. Non dipende dalla proiezione (che può essere un vantaggio)
2. Non può utilizzare alcun valore dalla proiezione (che può essere uno svantaggio)

1. Non dipende dalla proiezione

Un esempio in cui non dipende dalla proiezione è utile se si desidera calcolare le funzioni della finestra su valori distinti:

SELECT rating, row_number() OVER (ORDER BY rating) AS rn
FROM film
GROUP BY rating

Quando eseguito contro il database Sakila , questo produce:

rating   rn
-----------
G        1
NC-17    2
PG       3
PG-13    4
R        5

Lo stesso non si può ottenere DISTINCTfacilmente con :

SELECT DISTINCT rating, row_number() OVER (ORDER BY rating) AS rn
FROM film

Quella query è "sbagliata" e produce qualcosa di simile:

rating   rn
------------
G        1
G        2
G        3
...
G        178
NC-17    179
NC-17    180
...

Questo non è quello che volevamo. L' DISTINCToperazione "avviene dopo" la proiezione, quindi non possiamo più rimuovere le DISTINCTclassificazioni perché la funzione finestra era già calcolata e proiettata. Per poterlo utilizzare DISTINCT, dovremmo nidificare quella parte della query:

SELECT rating, row_number() OVER (ORDER BY rating) AS rn
FROM (
  SELECT DISTINCT rating FROM film
) f

Nota a margine: in questo caso particolare, potremmo anche usareDENSE_RANK()

SELECT DISTINCT rating, dense_rank() OVER (ORDER BY rating) AS rn
FROM film

2. Non può utilizzare alcun valore dalla proiezione

Uno degli svantaggi di SQL è la sua verbosità a volte. Per lo stesso motivo di ciò che abbiamo visto prima (vale a dire l'ordine logico delle operazioni), non possiamo "facilmente" raggruppare per qualcosa che stiamo proiettando.

Questo è SQL non valido:

SELECT first_name || ' ' || last_name AS name
FROM customer
GROUP BY name

Questo è valido (ripetendo l'espressione)

SELECT first_name || ' ' || last_name AS name
FROM customer
GROUP BY first_name || ' ' || last_name

Anche questo è valido (annidando l'espressione)

SELECT name
FROM (
  SELECT first_name || ' ' || last_name AS name
  FROM customer
) c
GROUP BY name

Ho scritto più approfonditamente su questo argomento in un post sul blog

Utilizzare DISTINCTse si desidera solo rimuovere duplicati. Utilizzare GROUPY BYse si desidera applicare operatori di aggregazione ( MAX, SUM, GROUP_CONCAT, ..., o di una HAVINGclausola di).

Mi aspetto che ci sia la possibilità di sottili differenze nella loro esecuzione. Ho verificato i piani di esecuzione di due query funzionalmente equivalenti lungo queste linee in Oracle 10g:

core> select sta from zip group by sta;

---------------------------------------------------------------------------
| Id  | Operation          | Name | Rows  | Bytes | Cost (%CPU)| Time     |
---------------------------------------------------------------------------
|   0 | SELECT STATEMENT   |      |    58 |   174 |    44  (19)| 00:00:01 |
|   1 |  HASH GROUP BY     |      |    58 |   174 |    44  (19)| 00:00:01 |
|   2 |   TABLE ACCESS FULL| ZIP  | 42303 |   123K|    38   (6)| 00:00:01 |
---------------------------------------------------------------------------

core> select distinct sta from zip;

---------------------------------------------------------------------------
| Id  | Operation          | Name | Rows  | Bytes | Cost (%CPU)| Time     |
---------------------------------------------------------------------------
|   0 | SELECT STATEMENT   |      |    58 |   174 |    44  (19)| 00:00:01 |
|   1 |  HASH UNIQUE       |      |    58 |   174 |    44  (19)| 00:00:01 |
|   2 |   TABLE ACCESS FULL| ZIP  | 42303 |   123K|    38   (6)| 00:00:01 |
---------------------------------------------------------------------------

L'operazione centrale è leggermente diversa: "HASH GROUP BY" rispetto a "HASH UNIQUE", ma i costi stimati ecc. Sono identici. Ho quindi eseguito questi con la traccia attiva e i conteggi dell'operazione effettiva erano gli stessi per entrambi (tranne per il fatto che il secondo non doveva eseguire alcuna lettura fisica a causa della memorizzazione nella cache).

Ma penso che poiché i nomi delle operazioni sono diversi, l'esecuzione seguirà percorsi di codice in qualche modo diversi e ciò apre la possibilità di differenze più significative.

Penso che dovresti preferire la sintassi DISTINCT per questo scopo. Non è solo un'abitudine, indica più chiaramente lo scopo della query.

Per la query che hai pubblicato, sono identici. Ma per altre query ciò potrebbe non essere vero.

Ad esempio, non è lo stesso di:

SELECT C FROM myTbl GROUP BY C, D

Ho letto tutti i commenti sopra ma non ho visto nessuno indicare la differenza principale tra Group By e Distinct a parte il bit di aggregazione.

Distinct restituisce tutte le righe, quindi le de-duplica, mentre le righe raggruppate per de-deduplicano le righe come vengono lette dall'algoritmo una per una.

Ciò significa che possono produrre risultati diversi!

Ad esempio, i codici seguenti generano risultati diversi:

SELECT distinct ROW_NUMBER() OVER (ORDER BY Name), Name FROM NamesTable

 SELECT ROW_NUMBER() OVER (ORDER BY Name), Name FROM NamesTable
GROUP BY Name

Se nella tabella sono presenti 10 nomi in cui 1 è un duplicato di un altro, la prima query restituisce 10 righe mentre la seconda query restituisce 9 righe.

Il motivo è quello che ho detto sopra in modo che possano comportarsi diversamente!

Se si utilizza DISTINCT con più colonne, il set di risultati non verrà raggruppato come in GROUP BY e non è possibile utilizzare le funzioni di aggregazione con DISTINCT.

Hanno una semantica diversa, anche se hanno risultati equivalenti sui tuoi dati particolari.

GROUP BY ha un significato molto specifico che è distinto (heh) dalla funzione DISTINCT.

GROUP BY fa sì che i risultati della query vengano raggruppati utilizzando l'espressione scelta, è quindi possibile applicare funzioni di aggregazione, che agiranno su ciascun gruppo anziché sull'intero gruppo di risultati.

Ecco un esempio che potrebbe aiutare:

Dato un tavolo che assomiglia a questo:

name
------
barry
dave
bill
dave
dave
barry
john

Questa query:

SELECT name, count(*) AS count FROM table GROUP BY name;

Produrrà un output in questo modo:

name    count
-------------
barry   2
dave    3
bill    1
john    1

Che è ovviamente molto diverso dall'uso di DISTINCT. Se si desidera raggruppare i risultati, utilizzare GROUP BY, se si desidera solo un elenco univoco di una colonna specifica, utilizzare DISTINCT. Ciò darà al database la possibilità di ottimizzare la query in base alle proprie esigenze.

Per favore, non usare GROUP BY quando intendi DISTINCT, anche se funzionano allo stesso modo. Suppongo che tu stia cercando di radere millisecondi dalle query e devo sottolineare che il tempo degli sviluppatori è un ordine di grandezza più costoso del tempo del computer.

Se si utilizza un GROUP BY senza alcuna funzione aggregata, internamente verrà trattato come DISTINCT, quindi in questo caso non vi è alcuna differenza tra GROUP BY e DISTINCT.

Ma quando ti viene fornita la clausola DISTINCT meglio usarla per trovare i tuoi record univoci perché l'obiettivo di GROUP BY è quello di raggiungere l'aggregazione.

raggruppa per viene utilizzato in operazioni aggregate, ad esempio quando si desidera ottenere un conteggio di Bs suddiviso per colonna C

select C, count(B) from myTbl group by C

distinto è come suona - ottieni righe uniche.

In sql server 2005, sembra che Query Optimizer sia in grado di ottimizzare la differenza negli esempi semplicistici che ho eseguito. Non so se puoi contare su quello in tutte le situazioni, comunque.

In quella particolare query non c'è differenza. Ma, naturalmente, se aggiungi colonne aggregate, dovrai usare group by.

Nella prospettiva di Teradata :

Dal punto di vista del set di risultati, non importa se si utilizza DISTINCT o GROUP BY in Teradata. Il set di risposte sarà lo stesso.

Dal punto di vista delle prestazioni, non è lo stesso.

Per capire cosa influisce sulle prestazioni, è necessario sapere cosa succede su Teradata quando si esegue una dichiarazione con DISTINCT o GROUP BY.

Nel caso di DISTINCT, le righe vengono ridistribuite immediatamente senza alcuna preaggregazione, mentre nel caso di GROUP BY, in una prima fase viene eseguita una preaggregazione e solo allora i valori univoci vengono ridistribuiti tra gli AMP.

Non pensare ora che GROUP BY sia sempre migliore dal punto di vista delle prestazioni. Quando si hanno molti valori diversi, la fase di preaggregazione di GROUP BY non è molto efficiente. Teradata deve ordinare i dati per rimuovere i duplicati. In questo caso, potrebbe essere meglio prima ridistribuire, ovvero usare l'istruzione DISTINCT. Solo se ci sono molti valori duplicati, l'istruzione GROUP BY è probabilmente la scelta migliore poiché una volta effettuata la fase di deduplicazione, dopo la ridistribuzione.

In breve, DISTINCT vs. GROUP BY a Teradata significa:

Raggruppa per -> per molti duplicati DISTINCT -> no o solo alcuni duplicati. A volte, quando si utilizza DISTINCT, si esaurisce lo spazio di spooling su un AMP. Il motivo è che la ridistribuzione ha luogo immediatamente e l'inclinazione potrebbe causare l'esaurimento dello spazio da parte degli AMP.

Se ciò accade, probabilmente hai una migliore possibilità con GROUP BY, poiché i duplicati vengono già rimossi in un primo passaggio e meno dati vengono spostati attraverso gli AMP.

Dal punto di vista di "SQL the language" i due costrutti sono equivalenti e quale si sceglie è una di quelle scelte di "stile di vita" che tutti noi dobbiamo fare. Penso che ci sia un buon caso per DISTINCT più esplicito (e quindi più attento alla persona che erediterà il tuo codice, ecc.), Ma ciò non significa che il costrutto GROUP BY sia una scelta non valida.

Penso che questo "GROUP BY sia per aggregati" sia l'enfasi sbagliata. Le persone dovrebbero essere consapevoli del fatto che la funzione impostata (MAX, MIN, COUNT, ecc.) Può essere omessa in modo da poter capire l'intento del programmatore quando lo è.

L'ottimizzatore ideale riconoscerà costrutti SQL equivalenti e sceglierà sempre il piano ideale di conseguenza. Per il tuo vero motore SQL preferito, devi testare :)

PS nota che la posizione della parola chiave DISTINCT nella clausola select può produrre risultati diversi, ad esempio contrasto:

SELECT COUNT(DISTINCT C) FROM myTbl;

SELECT DISTINCT COUNT(C) FROM myTbl;

Lo noti solo perché stai selezionando una singola colonna.

Prova a selezionare due campi e guarda cosa succede.

Raggruppa per è destinato a essere utilizzato in questo modo:

SELECT name, SUM(transaction) FROM myTbl GROUP BY name

Che mostrerebbe la somma di tutte le transazioni per ogni persona.

So che è un vecchio post. Ma succede che avevo una query che utilizzava il gruppo solo per restituire valori distinti quando si utilizzava quella query in rospo e l'oracolo riporta che tutto ha funzionato bene, intendo un buon tempo di risposta. Quando siamo passati da Oracle 9i a 11g, il tempo di risposta in Toad è stato eccellente, ma nel report ci sono voluti circa 35 minuti per terminare il rapporto quando si utilizzava la versione precedente ci sono voluti circa 5 minuti.

La soluzione consisteva nel cambiare il gruppo e utilizzare DISTINCT e ora il rapporto viene eseguito in circa 30 secondi.

Spero che questo sia utile per qualcuno con la stessa situazione.

In termini di utilizzo, GROUP BY viene utilizzato per raggruppare le righe che si desidera calcolare. DISTINCT non eseguirà alcun calcolo. Non mostrerà righe duplicate.

Ho sempre usato DISTINCT se volevo presentare dati senza duplicati.

Se voglio fare calcoli come riassumere la quantità totale di mango, userò GROUP BY

Il modo in cui ho sempre capito è che l'uso di distinto è lo stesso del raggruppamento per ogni campo selezionato nell'ordine in cui li hai selezionati.

vale a dire:

select distinct a, b, c from table;

equivale a:

select a, b, c from table group by a, b, c

L'efficienza funzionale è totalmente diversa. Se si desidera selezionare solo "valore restituito" tranne uno duplicato, utilizzare distinto è meglio di raggruppa per. Poiché "raggruppa per" include (ordinamento + rimozione), "distinto" include (rimozione)

In Hive (HQL), raggruppare per può essere molto più veloce di distinto, perché il primo non richiede il confronto di tutti i campi nella tabella. Vedi https://sqlperformance.com/2017/01/t-sql-queries/surprises-assumptions-group-by-distinct .

A volte possono darti gli stessi risultati ma sono pensati per essere usati in senso / caso diverso. La differenza principale è nella sintassi.

Notare con attenzione l'esempio seguente. DISTINCTviene utilizzato per filtrare l'insieme duplicato di valori. (6, cs, 9.1) e (1, cs, 5.5) sono due set diversi. Quindi DISTINCTmostrerà entrambe le righe mentre GROUP BY Branchmostrerà solo un set.

 SELECT * FROM student; 
+------+--------+------+
| Id   | Branch | CGPA |
+------+--------+------+
|    3 | civil  |  7.2 |
|    2 | mech   |  6.3 |
|    6 | cs     |  9.1 |
|    4 | eee    |  8.2 |
|    1 | cs     |  5.5 |
+------+--------+------+
5 rows in set (0.001 sec)

SELECT DISTINCT * FROM student; 
+------+--------+------+
| Id   | Branch | CGPA |
+------+--------+------+
|    3 | civil  |  7.2 |
|    2 | mech   |  6.3 |
|    6 | cs     |  9.1 |
|    4 | eee    |  8.2 |
|    1 | cs     |  5.5 |
+------+--------+------+
5 rows in set (0.001 sec)

SELECT * FROM student GROUP BY Branch;
+------+--------+------+
| Id   | Branch | CGPA |
+------+--------+------+
|    3 | civil  |  7.2 |
|    6 | cs     |  9.1 |
|    4 | eee    |  8.2 |
|    2 | mech   |  6.3 |
+------+--------+------+
4 rows in set (0.001 sec)

A volte GROUP BYnon è possibile ottenere i risultati che possono essere raggiunti dalla clausolaDISTINCT senza l'uso di clausole o condizioni aggiuntive. Ad esempio nel caso precedente.

Per ottenere lo stesso risultato DISTINCTdevi passare tutti i nomi di colonna nella GROUP BYclausola come sotto. Quindi vedi la differenza sintattica. È necessario conoscere tutti i nomi di colonna per utilizzare la GROUP BYclausola in tal caso.

SELECT * FROM student GROUP BY Id, Branch, CGPA;
+------+--------+------+
| Id   | Branch | CGPA |
+------+--------+------+
|    1 | cs     |  5.5 |
|    2 | mech   |  6.3 |
|    3 | civil  |  7.2 |
|    4 | eee    |  8.2 |
|    6 | cs     |  9.1 |
+------+--------+------+

Inoltre ho notato che GROUP BYmostra i risultati in ordine crescente di default qualeDISTINCT non lo fa. Ma non ne sono sicuro. Potrebbe essere diverso dal punto di vista del fornitore.

Fonte: https://dbjpanda.me/dbms/languages/sql/sql-syntax-with-examples#group-by

Generalmente possiamo usare DISTINCTper eliminare i duplicati sulla colonna specifica nella tabella.

Nel caso di 'GROUP BY' siamo in grado di applicare le funzioni di aggregazione come AVG, MAX, MIN, SUM, e COUNTsulla colonna specifica a prendere il nome di colonna e di aggregazione risultato della funzione sulla stessa colonna.

Esempio :

select  specialColumn,sum(specialColumn) from yourTableName group by specialColumn;

Non vi è alcuna differenza significativa tra clausola group by e distinta, tranne l'uso di funzioni aggregate. Entrambi possono essere usati per distinguere i valori, ma se nel punto di vista delle prestazioni raggruppare è migliore. Quando viene utilizzata una parola chiave distinta, internamente utilizza un'operazione di ordinamento che può essere visualizzata nel piano di esecuzione.

Prova un semplice esempio

Dichiara la tabella @tmpresult (Id tinyint)

Inserisci in @tmpresult Seleziona 5 Union tutti Seleziona 2 Union tutti Seleziona 3 Union tutti Seleziona 4

Seleziona ID distinto da @tmpresult