SQL: relación muchos a muchos, condición IN

Question

Tengo una tabla llamada transacciones con una relación de varios a varios elementos a través de la tabla items_transactions.

quiero hacer algo como esto:

SELECT "transactions".* 
    FROM "transactions" 
INNER JOIN "items_transactions" 
     ON "items_transactions".transaction_id = "transactions".id 
INNER JOIN "items" 
     ON "items".id = "items_transactions".item_id 
WHERE (items.id IN (<list of items>)) 

Pero esto me da todas las transacciones que tienen uno o más de los elementos de la lista de la misma y yo sólo quiero que me dé las transacciones que están asociados con todos esos artículos.

Cualquier ayuda sería apreciada.

Answer 1

Hay que ampliar a cabo la consulta para todos los elementos de la lista:

SELECT "transactions".* 
FROM "transactions" 
WHERE EXISTS (SELECT 1 FROM "items_transactions" 
       INNER JOIN "items" ON "items".id = "items_transactions".item_id 
       WHERE "items_transactions".transaction_id = "transactions".id 
       AND "items".id = <first item in list>) 
AND EXISTS (SELECT 1 FROM "items_transactions" 
       INNER JOIN "items" ON "items".id = "items_transactions".item_id 
       WHERE "items_transactions".transaction_id = "transactions".id 
       AND "items".id = <second item in list>) 
... 

También podría darle masajes usando IN y COUNT DISTINCT, no estoy seguro de cuál sería más rápido. Algo así como (completamente no probado):

SELECT "transactions".* 
FROM "transactions" 
INNER JOIN (SELECT "items_transactions".transaction_id 
      FROM "items_transactions" 
      INNER JOIN "items" ON "items".id = "items_transactions".item_id 
      WHERE "items".id IN (<list of items>) 
      GROUP BY "items_transactions".transaction_id 
      HAVING COUNT(DISTINCT "items".id) = <count of items in list>) matches ON transactions.transaction_id = matches.transaction_id 

Answer 2

El bit final de la consulta se ve mal:

WHERE (items.id IN (<list of items>)) 

el 'en' declaración es como un gran O declaración en lugar de una instrucción AND, por lo que se expande por el optimizador como:

WHERE (items.id = 123 OR items.id = 456 OR items.id = 789) 

EDITAR

Creo que es necesario realizar un correlated subquery en la tabla de artículos.

Answer 3

no he ejecutado este, pero que debe obtener el resultado deseado:

SELECT t.* FROM items i 
    INNER JOIN items_transactions it ON i.id = it.item_id 
     INNER JOIN transactions t ON it.transaction_id = t.id 
WHERE i.id IN (1,2,3) 

Answer 4

Creo que esto hace lo que quiere.

Me gustaría poner la lista de elementos que necesita en una tabla (la temperatura uno va a estar bien) y unirme a eso. Luego cuente la cantidad de elementos distintos y haga coincidir el recuento con el recuento de transacciones del elemento.

He proporcionado la muestra DDL & Datos que he utilizado.

Create table #trans 
(
transId int identity(1,1), 
trans varchar(10) 
) 

Create Table #itemTrans 
(
transId int, 
itemId int 
) 

Create table #items 
(
itemId int identity(1,1), 
item varchar(10) 
) 

Create table #itemsToSelect 
(
itemId int 
) 


Insert Into #trans 
Values ('Trans 1') 

Insert Into #trans 
Values ('Trans 2') 

Insert Into #trans 
Values ('Trans 3') 


Insert Into #Items 
Values ('Item 1') 

Insert Into #Items 
Values ('Item 2') 

Insert Into #Items 
Values ('Item 3') 

Insert Into #Items 
Values ('Item 4') 

Insert Into #itemTrans 
Values (1, 1) 

Insert Into #itemTrans 
Values (1, 2) 

Insert Into #itemTrans 
Values (1, 3) 

Insert Into #itemTrans 
Values (2, 1) 

Insert Into #itemTrans 
Values (2, 3) 

Insert Into #itemTrans 
Values (3, 4) 



Insert Into #itemsToSelect 
Values (1) 
Insert Into #itemsToSelect 
Values (2) 
Insert Into #itemsToSelect 
Values (3) 


Select t.transId 

From #items i 
Join #itemTrans it on i.itemId = it.itemId 
Join #trans t on it.transId = t.transId 

Join #itemsToSelect its on it.ItemId = its.ItemId 

Where it.TransId is not null 
Group by t.transId 
Having count(distinct(it.itemId)) = (Select count(distinct(itemId)) from #itemsToSelect) 

Answer 5

SELECT transactions.* 
WHERE (SELECT count(*) 
     FROM items_transactions 
     WHERE items_transactions.transaction_id = transactions.transaction_id 
      AND items_transactions.item_id IN (<list of items>) 
    ) = <number of items> 

Aunque esto probablemente hará un análisis de las transacciones, anidando la consulta correlacionada para cada uno ... no es particularmente eficiente, así que tal vez:

SELECT transactions.* 
WHERE EXISTS (SELECT 1 FROM items_transactions 
       WHERE items_transactions.transaction_id = transactions.transaction_id 
       AND items_transactions.item_id IN (<list of items>) 
    ) 
     AND 
     (SELECT count(*) 
     FROM items_transactions 
     WHERE items_transactions.transaction_id = transactions.transaction_id 
      AND items_transactions.item_id IN (<list of items>) 
    ) = <number of items> 

o algo similar para persuadir al DB para buscar transacciones relacionadas con al menos uno de los elementos primero, y luego verificar que cada transacción se vincule con todos los artículos más adelante.

Como alguien ha notado, también puede simplemente generar cláusulas de unión para cada elemento, lo que podría ser mejor si la cantidad de elementos no es grande.