MYSQL: COUNT con GROUP BY, LEFT JOIN e WHERE la clausola non restituisce valori zero

Question

Sono sicuro che questa risposta è molto semplice, ma non riesco a trovarla (non sono sicuro su cosa cercare!) . Un conteggio/gruppo per query standard può essere simile al seguente:

SELECT COUNT(`t2`.`name`) 
FROM `table_1` `t1` 
    LEFT JOIN `table_2` `t2` ON `t1`.`key_id` = `t2`.`key_id` 
WHERE `t1`.`another_column` = 123 

e questo funziona come previsto, restituendo 0 se non vengono trovate righe. Tuttavia:

SELECT COUNT(`t2`.`name`) 
FROM `table_1` `t1` 
    LEFT JOIN `table_2` `t2` ON `t1`.`key_id` = `t2`.`key_id` 
WHERE `t1`.`another_column` = 123 
GROUP BY `t1`.`any_col` 

funziona solo se esiste almeno una riga in Table_1 e fallisce sprecando restituendo un risultato vuoto impostato se ci sono zero righe. Mi piacerebbe molto questo per restituire 0! Qualcuno mi illumina su questo? La birra può essere fornita in cambio se si è a Londra ;-)

Answer 1

Il motivo per cui restituisce zero righe è che si sta raggruppando su un valore in table_1. SINC Non ci sono valori in table_1, non ci sono righe da restituire. Detto in altro modo, se si ritorna t1.any_col nella query dalla GROUP BY in questo modo:

SELECT `t1`.`any_col`, COUNT(`t2`.`name`) 
FROM `table_1` `t1` 
    LEFT JOIN `table_2` `t2` ON `t1`.`key_id` = `t2`.`key_id` 
WHERE `t1`.`another_column` = 123 
GROUP BY `t1`.`any_col` 

Cosa visualizzare per t1.any_col quando non c'erano le righe? L'unico modo per ottenere ciò che vuoi è unire i tuoi risultati con un'altra query che non verifica alcuna riga in table_1. In questo esempio, sto usando la vista INFORMATION_SCHEMA semplicemente per avere qualcosa contro cui posso interrogare.

SELECT COUNT(`t2`.`name`) 
FROM `table_1` `t1` 
    LEFT JOIN `table_2` `t2` ON `t1`.`key_id` = `t2`.`key_id` 
WHERE `t1`.`another_column` = 123 
GROUP BY `t1`.`any_col` 
UNION ALL 
SELECT 0 
FROM INFORMATION_SCHEMA.TABLES 
Where Not Exists(Select 1 From `table_1`) 
LIMIT 1 

Answer 2

Ecco la soluzione migliore:

SELECT COUNT(*) FROM 
(SELECT `t2`.`name` 
FROM `table_1` `t1` 
    LEFT JOIN `table_2` `t2` ON `t1`.`key_id` = `t2`.`key_id` 
WHERE `t1`.`another_column` = 123 
GROUP BY `t1`.`any_col`) tmp 

Hai solo bisogno di avvolgere intorno SELECT COUNT(*) la query.

Il problema è che COUNT() cambia dal significato "concedi un conteggio delle righe nel set di risultati" a una funzione di aggregazione che significa "dammi un conteggio delle righe per ogni gruppo che corrisponde ai miei criteri" quando viene utilizzato con il GROUP BY clausola. Nel tuo caso, poiché non ci sono righe per il gruppo dove another_column = 123, non viene restituito nulla.

Se lo si avvolge in un altro SELECT COUNT(*), si sta ripetendo "datemi il conteggio delle righe nel set di risultati".

Nella prima query, COUNT() funziona con GROUP BY. Ma senza specificare alcun criterio, stai ricevendo almeno una riga restituita da table_1. Poiché non ci sono record tabella_2 corrispondenti, NULL restituisce 0 per COUNT(). Non usare la prima query. Anche se restituisce ciò che ti aspetti, è solo per caso. Affinché la query sia significativa, è necessario specificare i criteri per t1.alterna_colonna nella clausola WHERE.

La seconda query funziona perché si richiede un conteggio delle righe del set di risultati. Dato che non ci sono righe dove t1.another_column = 123, ci sono 0 righe restituite, e COUNT() valuta a 0.