Bonjour,  
 
je ne connais sans doute pas assez le langage sql pour savoir si ma requete est réalisable ou non  
J'essaie d'expliquer le pb: j'ai une table client (avec un id), et une table facture (avec un id, un client_id, et un magasin appartenant à un ensemble de 3 valeurs possibles: A, B, C). Je peux extraire toutes les factures d'un magasin donné (disons 'A') via:
 
select * from client join facture on (client.id=facture.client_id) where facture.magasin='A';
 
un client donné peut ne pas avoir de factures,
ou des factures d'un seul magasin
ou des factures de deux magasins
ou des factures des trois magasins.
 
Ce que je souhaite obtenir EN UNE SEULE REQUETE:  
requete 1: la liste de tous les clients (SANS DOUBLONS) qui ont des factures dans n'importe quel magasin
requete 2:                                                               qui ont des factures au magasin 'A' mais pas au 'B' ni 'C'
requete 3:                                                               qui ont des factures non effectuées au magasin 'A'
 
Le but étant (entre autre) de compter le nombre de clients en fonction des magasins.
 
Est-ce-possible et si oui comment?
 
Merci d'avance de votre aide.

Au pif:
requete 1:
 
Select distinct c.id from clients c, facture f where c.id=f.client_id
 
requete 2:
 
Select distinct c.id from clients c, facture f where c.id=f.client_id and f.magasin='A'
 
requete 3:
Select distinct c.id from clients c, facture f where c.id=f.client_id and f.magasin<>'A'

Heu, merci, je devais être mal réveillé ce matin...
Je vais vérifier que cela répond bien à mon pb, et vérifier surtout que mon pb est bien celui que j'ai exposé...

Je crois avoir retrouvé la requete qui me posait le pb: comment obtenir les clients qui ont des factures au magasin 'A' ET au magasin 'B'?
Si j'indique magasin='A' OR magasin='B' c'est faux, et si je remplace le OR par un AND, c'est également faux...
Merci encore.

Fais une union entre ceux qui ont des factures au magasin A et ceux qui en ont au magasin B

Je vois bien l'idée, mais pas la syntaxe, peux-tu m'indiquer comment cela s'écrit stp?
Merci.

Pas besoin d'union.

SELECT DISTINCT c.*
FROM clients c
          JOIN facture f ON c.id = f.client_id AND  f.magasin_id IN ('A', 'B')

[edit]

Non, j'avais mal compris.
Et c'est pas une union, c'est une intersection, que tu veux.

Si on se fout de ramener les infos des factures mais juste les informations clients, c'est plus propre et peut-être même plus rapide (si correctement indexé) comme ça IMHO :

Plus rapide? 2 sous-requêtes par rapport à deux jointures?

Et je vois pas non plus pourquoi ce serait plus propre...

1 seul passage sur la table client (pas de distinct), pas de multiplication inutile via les jointures, les sous-requêtes seront montées en mémoire avec des bind-variables, si la table facture est bien indexée, 1 seul lecture / client.
Faudrait voir le plan d'exécution, mais d'instinct, je dirais plus rapide... le where doit bien plomber (vu que tu vas aller chercher toutes les combinaison f et f2 et ensuite appliquer ton prédicat sur la combinaison f = A ET f = B)

et pour ce qui est du plus propre, c'est juste que ça répond à la question posée, ni plus ni moins.

Le query engine va probablement generer le meme plan pour les 2 query mais les 2 jointures ont l'air bien plus propre et facile a comprendre en 1 coup d'oeuil.
 
Le probleme des "exists" c'est qu'on a trop vite fait de transformer en "not exists" et la c'est la misere totale.

en testant rapidement avec ce que j'avais sous le coude (departement / commune) :
 
Select c.*
from departement c
where exists (select 1  
                  from commune f
                  where f.iddepartement = c.iddepartement
                  and f.numinsee = '28353')
and    exists (select 1  
                  from commune f2
                  where f2.iddepartement = c.iddepartement
                  and f2.numinsee = '28354');
 

 
Cout : 4
 
 
SELECT DISTINCT c.*
FROM departement c
        JOIN commune f ON f.iddepartement = c.iddepartement
        JOIN commune f2 ON f2.iddepartement = c.iddepartement
WHERE f.numinsee = '28353'
AND f2.numinsee = '28354';
 

 
Cout : 5
 
C'est le distinct qui plombe la 2ieme.

 
Euh, et ma version elle répond à quelle question, celle du voisin?
Je veux les clients

SELECT c.*
FROM client c

 
qui ont des factures dans le magasin A
 

JOIN facture f
WHERE f.magasin ='A'

 
et des factures dans le magasin B
 

JOIN facture f2
WHERE f2.magasin = 'B'

 
 

 
 
Pour le plan d'exécution je zappe, flemme de tester. Mais au mieux je dirais que ça va donner le même résultat.
 

SELECT c.*
FROM client c

JOIN facture f
WHERE f.magasin ='A'

JOIN facture f2
WHERE f2.magasin = 'B'

 
Ça dépend comment on veut répondre à la question, là tu vas chercher les clients et toutes leurs factures dans le magasins A et toutes leurs factures dans le magasins B et tu ne prends que ceux qui ont des factures dans les 2. D'ailleurs petite question pourquoi ne pas remonter le filtre sur magasin A et magasin B directement dans la jointure ? (bon ça change rien au plan d'exécution vu que l'optimiser va les remonter lui-même, mais je trouve ça plus compréhensible si par hasard tu te retrouves avec 4 ou 5 filtres sur les clients par la suite pour pas mélanger les choux et les carottes).
 
 
C'est différent de répondre par "Je vais chercher tous les clients pour lesquels il existe au moins 1 facture dans A et 1 facture dans B

 
Le not exists a traduire en jointure c'est pas mal non plus

 
C'est une manière de l'interpréter.
 

 
Par habitude.
J'ai des collègues qui en sont encore aux jointures uniquement via la clause where, si je mets autre chose que les identifiants dans le join ils ont tendance à s'y perdre.

 
mais non, faut juste avoir l'habitude.
Par contre il faut vraiment passer la condition dans le JOIN ce coup-ci, les collègues souffrent.
 
A mais pas B :
 

SELECT DISTINCT c.*
FROM clients c
        JOIN facture f ON c.id = f.client_id AND f.magasin_id = 'A'
        LEFT OUTER JOIN facture f2 ON c.id = f2.client_id AND f2.magasin_id = 'B'
WHERE f2.id IS NULL

SELECT DISTINCT c.*
FROM clients c
        JOIN facture f ON c.id = f.client_id AND f.magasin_id = 'A'
        LEFT OUTER JOIN facture f2 ON c.id = f2.client_id AND f2.magasin_id = 'B'
WHERE f2.id IS NULL

Et si c'est les clients qui n'ont aucune facture dans A ni dans B   (oui je sais double outer join et double is null )

Bon je pinaille après chacun a ses petites habitudes d'écriture et ça joue à pas grand chose sur les perfs.

P.S. : pour les collègues, ils ont qu'à s'adapter ou mourrir. Viva la Evolution !  

Heu, merci pour toutes ces infos, mais si j'en reviens à ma question de départ,
je constate que j'ai toujours un soucis sur la requete2.
 
Si j'utilise les solutions vues plus haut basées sur les jointures multiple, cela ne fonctionne pas: .... f1.magasin = 'A' AND f2.magasin != 'B'
(dans ma vraie base, facture.magasin est à remplacer par facture.type et A, B par
ADOM et MAG):
 
mysql> select client_id, type from facture where client_id=2327;
+-----------+------+
| client_id | type |
+-----------+------+
|      2327 | MAG  |
|      2327 | ADOM |
+-----------+------+
 
mysql> select distinct client.id, f1.type, f2.type from client join facture f1 on client.id=f1.client_id join facture f2 on client.id=f2.client_id where f1.type='ADOM' and f2.type!='MAG' and client.id = 2327;
+------+------+------+
| id   | type | type |
+------+------+------+
| 2327 | ADOM | ADOM |
+------+------+------+
1 row in set (0.00 sec)
 
Le distcint est tj là, car j'ai simplement rajouté un filtre sur l'id client, normalement, il me les faut tous de manière unique.

TU veux compter les clients unique ok mais quand tu as un client qui a des factures dans 2 magasins, tu les comptes comment ?

Je crois avoir pigé le truc, merci de me confirmer:
 
Requete 1: tous les clients distincts ayant des factures de type 'A':
select distinct ... from client join facture on facture.client_id=client.id and facture.type='A'
 
Requete 2: factures A mais PAS B:
select distinct ... from client join facture on facture.client_id=client.id and facture.type='A' left outer join facture f2 on f2.client_id=client.id and f2.type='B' where f2.id is null
 
Requete 3: clients ayant des factures A ET AUSSI B:
select distinct ... from client join facture on facture.client_id=client.id and facture.type='A' left outer join facture f2 on f2.client_id=client.id and f2.type='B' where f2.id is NOT null
 
J'ai bien tout compris?
D'avance, merci.

La dernière te retournera le bon résultat, mais c'est très alambiqué, là, t'as pas besoin de jointure externe!
 
select distinct ... from client join facture on facture.client_id=client.id and facture.type='A' join facture f2 on f2.client_id=client.id and f2.type='B'