Salut !  
 
J'ai un p'tit problème que je n'arrive pas à résoudre : je dois chercher un ensemble dans un autre ensemble, j'ai essayé pleins de trucs mais sans succès.
Mon but est de résoudre ce problème en une seule requête SQL, sans utiliser de procédure stockée ou de code niveau PHP sinon c'est pas marrant.
 
Voici un exemple pour mieux comprendre :
 
Le schéma de test avec ses données :

--  
-- Structure de la table `salles_softs`
--  

CREATE TABLE `salles_softs` (
  `num_salle` int(11) NOT NULL,
  `num_logiciel` int(11) NOT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

--  
-- Contenu de la table `salles_softs`
--  

INSERT INTO `salles_softs` (`num_salle`, `num_logiciel`) VALUES (50, 1), (50, 2), (51, 3);

-- --------------------------------------------------------

--  
-- Structure de la table `softs`
--  

CREATE TABLE `softs` (
  `num_logiciel` int(11) NOT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

--  
-- Contenu de la table `softs`
--  

INSERT INTO `softs` (`num_logiciel`) VALUES (1), (2), (3);

 
Graphiquement :

 
Avez-vous une idée de la requête SQL qu'il faudrait écrire pour savoir si la salle 50 contient les logiciels 1 et 2 ? Ou encore plus compliqué : savoir quelles sont les salles qui contiennent les logiciels 1 et 2 ?
En lisant la question, ça paraît enfantin mais je bloque, c'est chiant
 
A votre bon cœur !

pour savoir les salles qui ont le soft 1 et 2, après c'est juste une histoire d'adaptation
 

J'avais pas pensé au COUNT, bien joué
Y'a juste à modifier le HAVING pour vérifier que la somme égale le nombre de logiciels demandés et ça rulez.
 

SELECT num_salle, COUNT(*) cnt FROM salles_softs WHERE num_logiciel IN (1,2) GROUP BY num_salle HAVING cnt = 2;

 
Autre façon intéressante basée sur un COUNT () en utilisant les sous-requêtes corrélées :
 

SELECT DISTINCT num_salle n FROM salles_softs WHERE (SELECT COUNT(*) FROM salles_softs WHERE num_salle = n AND num_logiciel IN (1,2)) = 2 ;

 
Si y'en a qui ont d'autres solutions pour résoudre ce type de problème, n'hésitez pas !
 
Merci

count(*) est potentiellement une mauvaise idée.
Si, par hasard, tu te retrouves avec un doublon comme ça:

Ta requête va te remonter "vrai" alors que ce n'est pas ce que tu cherches.
Je remplacerais donc count(*) par count(distinct num_logiciel )

Ouep, j'y avais pensé aux doublons mais ça c'est réglé par la compound primary key qui n'existe pas dans ce test mais en réalité si !

Tiens, c'est marrant : en ajoutant les PK sur cet exemple, ma requête ne fonctionne plus  
 

 
Je décide donc de faire plus propre en ajoutant la table "salles" :

--  
-- Structure de la table `salles`
--  

CREATE TABLE `salles` (
  `num_salle` int(11) NOT NULL,
  PRIMARY KEY  (`num_salle`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

--  
-- Contenu de la table `salles`
--  

INSERT INTO `salles` (`num_salle`) VALUES (50), (51);

 
On ré-exécute la requête un peu modifiée pour utiliser cette table et là ça marche ce qui est normal cette fois ci..

Bizarre, n'est-ce pas ?

count(distinct num_logiciel)
 
ça devrait faire l'affaire. en tout cas, sous SQL Server 2005 ça marche nickel chrome.
 

CREATE TABLE salles_softs
(
  salle_id int NOT NULL,
  soft_id int NOT NULL
);
 
CREATE INDEX ix_salles_softs ON salles_softs (salle_id, soft_id);
 
INSERT INTO salles_softs (salle_id, soft_id) VALUES (1, 1);
INSERT INTO salles_softs (salle_id, soft_id) VALUES (1, 1);
INSERT INTO salles_softs (salle_id, soft_id) VALUES (1, 3);
INSERT INTO salles_softs (salle_id, soft_id) VALUES (2, 1);
INSERT INTO salles_softs (salle_id, soft_id) VALUES (2, 3);
INSERT INTO salles_softs (salle_id, soft_id) VALUES (3, 1);
INSERT INTO salles_softs (salle_id, soft_id) VALUES (3, 1);
INSERT INTO salles_softs (salle_id, soft_id) VALUES (3, 2);
INSERT INTO salles_softs (salle_id, soft_id) VALUES (4, 1);
INSERT INTO salles_softs (salle_id, soft_id) VALUES (4, 2);
INSERT INTO salles_softs (salle_id, soft_id) VALUES (4, 3);
 
SELECT salle_id
FROM salles_softs
WHERE soft_id IN (1, 2)
GROUP BY salle_id
HAVING count(DISTINCT soft_id) = 2;
 
DROP TABLE salles_softs;

Marche également parfaitement sous MySQL 5

Moi aussi j'ai un problème similaire :
 
Comment on fait pour dire qu'un sous-ensemble est présent dans un ensemble :
 
que le couple (1,2) est présent dans la liste de couple ((1,2),(1,3), etc.)
C'est comme un IN mais sur des ensembles, pas sur une simple valeur...et ça compile pas .

utilise une clause exists

 
Parfaitement raison, j'avais déjà trouvé et ça s'applique très bien. Voici un exemple en JPQL :