sql più efficace per il recupero

Question

Ho questa tabella

---------------- 
| X | Y | 
---------------- 
| a | 1 | 
| c | 6 | 
| e | 3 | 
| d | 6 | 
| c | 4 | 
| b | 1 | 
| a | 5 | 
| g | 1 | 
---------------- 

Quando mi sono dato una matrice [c, d] Ho bisogno di trovare "6" nella tabella sopra riportata. Cioè per ogni insieme di elementi ho bisogno di trovare il valore Y che è condiviso da tutti gli elementi nel set ma solo se non c'è nessun altro elemento (cioè un elemento che non è nell'array dato) che condivide quel valore. Il numero di elementi nella matrice non ha limiti teorici.

Altri esempi: per [a, b, c] non ho bisogno di trovare nulla. Anche per [a, b] non ho trovato nulla (perché g ha anche una voce per Y = 1, quindi per [a, b, g] ho bisogno di trovare "1").

Ovviamente potrei scorrere l'array, interrogare per query, ma sembra un modo così inefficiente di farlo. Qual è il modo migliore per farlo in SQL? Grazie.

Answer 1

Ecco un modo con i valori di "query" in una tabella separata.

create table t (x varchar(1), y int); 

insert into t (x, y) values ('a', 1); 
insert into t (x, y) values ('c', 6); 
insert into t (x, y) values ('e', 3); 
insert into t (x, y) values ('d', 6); 
insert into t (x, y) values ('c', 4); 
insert into t (x, y) values ('b', 1); 
insert into t (x, y) values ('a', 5); 
insert into t (x, y) values ('g', 1); 

create table q (x varchar(1)); 

insert into q (x) values ('a'); 
insert into q (x) values ('b'); 

select a.y from 
(
    select t.y 
    from t join q on (t.x = q.x) 
    group by t.y 
    having count(*) = (select count(*) from q) 
) a 
join t on (a.y = t.y) 
group by a.y 
having count(*) = (select count(*) from q) 

Here's an example SQLFiddle.

Ciò presuppone che non è possibile avere combinazioni duplicate.

Se si desidera eseguire l'operazione senza la seconda tabella, è possibile sostituire lo select count(*) con il numero di valori a cui si sta facendo la corrispondenza in un elenco IN e invece di eseguire il join sulla sottoquery interna, utilizzare una clausola where.

select a.y from 
(
select t.y 
from t 
    where t.x in ('c', 'd') 
group by t.y 
having count(*) = 2 
) a 
join t on (a.y = t.y) 
group by a.y 
having count(*) = 2 

Answer 2

Questi tipi di interrogazione sono mai particolarmente performante su grandi insiemi di dati e/o in cui molti valori in azioni Y gli stessi valori in X.

Detto questo, questa è la semplice versione del mio modo normale di farlo ...

CREATE TEMPORARY TABLE params (
    item VARCHAR(16) 
) 
INSERT INTO params SELECT 'a' 
INSERT INTO params SELECT 'b' 
INSERT INTO params SELECT 'g' 


SELECT 
    yourTable.Y 
FROM 
    yourTable 
LEFT JOIN 
    params 
    ON yourTable.X = params.item 
GROUP BY 
    yourTable.Y 
HAVING 
    COUNT(DISTINCT yourTable.X) = COUNT(DISTINCT params.item) 

Un'altra opzione che non ha bisogno di una tabella di parametri, anche se non credo che sia più performante ...

SELECT 
    y 
FROM 
    yourTable 
GROUP BY 
    y 
HAVING 
    COUNT(DISTINCT x) = COUNT(DISTINCT CASE WHEN x IN ('a', 'b', 'g') THEN x ELSE NULL END) 

Questo non ha join, ma è a costo di eseguire una scansione completa della tabella.