Calcolo del numero di chiavi esterne da più tabelle

Question

Ho 3 tabelle, con Tabella B & C tabella di riferimento A tramite chiave esterna. Voglio scrivere una query in PostgreSQL per ottenere tutti gli ID di A e anche le loro occorrenze totali da B & C.

a  |  b  |  c 
-----------------------------------  
id | txt | id | a_id | id | a_id 
---+---- | ---+----- | ---+------ 
1 | a | 1 | 1 | 1 | 3  
2 | b | 2 | 1 | 2 | 4  
3 | c | 3 | 3 | 3 | 4  
4 | d | 4 | 4 | 4 | 4  

uscita desiderato (solo l'id da A conteggio totale & in B & C):

id | Count 
---+------- 
1 | 2  -- twice in B 
2 | 0  -- occurs nowhere 
3 | 2  -- once in B & once in C 
4 | 4  -- once in B & thrice in C 

SQL finora SQL Fiddle:

SELECT a_id, COUNT(a_id) 
FROM 
(SELECT a_id FROM b 
    UNION ALL 
    SELECT a_id FROM c 
) AS union_table 
GROUP BY a_id 

La query che ho scritto recupera da B & C e conta le occorrenze. Ma se la chiave non si verifica in B o C, non viene visualizzata nell'output (ad es. Id = 2 in output). Come posso iniziare la mia selezione dalla tabella A & join/unione B & C per ottenere il risultato desiderato

Answer 1

Se la query riguarda grandi parti di b e/o c è più efficiente aggregare prima e iscriversi in seguito.
mi aspetto queste due varianti di essere molto più veloce:

SELECT a.id, 
     ,COALESCE(b.ct, 0) + COALESCE(c.ct, 0) AS bc_ct 
FROM a 
LEFT JOIN (SELECT a_id, count(*) AS ct FROM b GROUP BY 1) b USING (a_id) 
LEFT JOIN (SELECT a_id, count(*) AS ct FROM c GROUP BY 1) c USING (a_id); 

, è necessario tenere conto della possibilità che alcuni a_id non sono presenti a tutti in a e/o b. count() non restituisce mai NULL, ma questo è il comfort a freddo di LEFT JOIN, che tuttavia ti lascia con valori NULL per le righe mancanti. È deve prepararsi per NULL. Utilizzare COALESCE().

O UNION ALL a_id da entrambe le tabelle, aggregare, poi registrazione:

SELECT a.id 
     ,COALESCE(ct.bc_ct, 0) AS bc_ct 
FROM a 
LEFT JOIN (
    SELECT a_id, count(*) AS bc_ct 
    FROM (
     SELECT a_id FROM b 
     UNION ALL 
     SELECT a_id FROM c 
    ) bc 
    GROUP BY 1 
    ) ct USING (a_id); 

Probabilmente più lento. Ma ancora più veloce delle soluzioni presentate finora. E si potrebbe fare senza COALESCE() e ancora non perdere le righe. In questo caso potresti ottenere occasionalmente i valori NULL per bc_ct.

Answer 2

Usa ha lasciato unirsi con una subquery:

SELECT a.id, COUNT(x.id) 
FROM a 
LEFT JOIN (
    SELECT id, a_id FROM b 
    UNION ALL 
    SELECT id, a_id FROM c 
) x ON (a.id = x.a_id) 
GROUP BY a.id; 

Answer 3

Un'altra opzione:

SELECT 
    a.id, 
    (SELECT COUNT(*) FROM b WHERE b.a_id = a.id) + 
    (SELECT COUNT(*) FROM c WHERE c.a_id = a.id) 
FROM 
    a