Yo

Voila, je fais un requete du style

Et je voudrais retourner pour chaque pays le nombre d'user ET le nombre d'user ayant au moins un meuble
Ce tableau me retournant (a priori ?) une valeur NULL pour meuble_id si l'utilisateur n'a pas de meubles, je me dis qu'il suffit de soustraire le nombre de (meuble_id=NULL) du nb d'users

donc pour l'instant pour ce truc j'ai :

Seulement voila, 'nb_nulls' retourne toujours 0
C'est comme si il ne trouvait aucun meuble_id avec une valeur NULL, alors qu'en virant le GROUP BY, ben j'en ai...

edit : c'était pas clair, alors j'ai encore compliqué le truc

c'est nawak ta requête

tu groupes sur un champ (j'imagine user_id) qu'est pas dans ceux remontés par ton select alors qu'en plus tu fais un compte dessus.

Je suis pas sur de bien comprendre ce que tu cherches à faire...
Tu souhaites avoir le nombre de users, le nombre de meubles n'appartenant pas à un user, le nombre de meubles apparteant a des users ( en partant des deux précédents résultats) et enfin le nombre de meubles total.
Et tout ça regroupé par ???

Mais bon à mon avis t'es mal embarqué

edit: zouper t'as tout changé

Ouais je sais, en vrai c'est pas ça la vraie requete et je crois que j'ai mal métaphorisé, je corrige

edit: voila

tu veux pas soit:
- filer la structure des tables
- ecrire tes conditions de jointures explicitement
Histoire qu'on sache quel champ est dans quel table!

Yep
 

 
Donc tous les meubles ont un user correspondant.
Mais certain users (Fidel Castro) n'ont pas de meubles.
 
Je veux compter  
- le nb d'users total par pays
- le nb d'users total par pays ayant au moins un meuble

je ferais un truc dans le genre:

c'est quoi user_has_meubles ?

Sinon faut que je me renseigne sur OUTER JOIN

count(*) as nb_meubles  as user_has_meubles

Mais pourquoi mon

ne marche pas ?

parce que toute ta requête est mal pensée

Je vois pas en quoi

déjà, si un user est toujours dans un pays, le premier truc est un inner join et non pas un left.
 
ps : et pour le left, utilise la syntaxe complète : left OUTER join
 
parceque sans outer, ça peut aussi bien vouloir dire left inner (ce qui revient à inner tout court)

En théorie oui un user a toujours un pays, mais en cas de couille on sait jamais, je veux qu'il m'affiche un pays vide. C'est pour ça que pour toutes les requetes administrateur, je met du LEFT JOIN à foison (cet exemple du pays n'est pas le plus probable, mais je fais ça par principe). J'ai peut-etre tort mais je vois pas en quoi ?

pour LEFT OUTER JOIN, ça existe en MySQL ça ?

Ben ça devrait exister, c'est la syntaxe SQL Standard... Tu me diras, ils sont bien capable d'avoir décidés de pas l'accepter...

alors pourquoi ta requête est mal pensée?
Et bien tu as trois dimensions dans les résultats que tu essayes de remonter:
- pays
- user
- nb de meubles par user ( raccourci en 0 ou plus )
Or:
Pour calculer le nb de meubles par user tu vas logiquement être obligé de grouper sur user_id.
Pour calculer le nb de user par pays, tu vas être obligé de grouper sur pays_id.
Et here comes teh problem. Si tu écris tout dans la même requête tu te retrouves avec un group by pays_id, user_id et ton résultat final n'est pas du tout celui que tu souhaites.
 
Normalement la tu me réponds: "Oui mais j'ai rusé avec somme"... sauf que dans ce cas la c'est nawak
Tu fais un produit cartésien entre user et meuble et comme tu groupes pas par user tu remontes trop de fois un même user.

Je viens de tester une requête qui marche parfaitement.
 
Voici le script complet de test (SQL Server).
 

CREATE TABLE pays
(
  id int PRIMARY KEY,
  nom varchar(30) NOT NULL
)
go
 
CREATE TABLE uti
(
  id int PRIMARY KEY,
  nom varchar(30) NOT NULL,
  pays_id int NULL FOREIGN KEY REFERENCES pays(id)
)
go
 
CREATE TABLE meuble
(
  id int NOT NULL PRIMARY KEY,
  uti_id int NOT NULL FOREIGN KEY REFERENCES uti(id),
  prix_paye numeric(10,2)
)
go
 
INSERT INTO pays (id, nom) VALUES (1, 'Cuba');
INSERT INTO pays (id, nom) VALUES (2, 'Suisse');
INSERT INTO pays (id, nom) VALUES (3, 'France');
 
INSERT INTO uti (id, nom, pays_id) VALUES (1, 'Pouet Dupont', 2);
INSERT INTO uti (id, nom, pays_id) VALUES (2, 'JP Rafarin', 3);
INSERT INTO uti (id, nom, pays_id) VALUES (3, 'Fidel Castro', 1);
INSERT INTO uti (id, nom, pays_id) VALUES (4, 'Tintin', NULL);
INSERT INTO uti (id, nom, pays_id) VALUES (5, 'Casimir', NULL);
INSERT INTO uti (id, nom, pays_id) VALUES (6, 'J Chirac', 3);
INSERT INTO uti (id, nom, pays_id) VALUES (7, 'S Royal', 3);
 
INSERT INTO meuble (id, uti_id, prix_paye) VALUES (1, 1, 10);
INSERT INTO meuble (id, uti_id, prix_paye) VALUES (2, 2, 99.9);
INSERT INTO meuble (id, uti_id, prix_paye) VALUES (3, 2, 49);
INSERT INTO meuble (id, uti_id, prix_paye) VALUES (4, 1, 29.9);
INSERT INTO meuble (id, uti_id, prix_paye) VALUES (5, 1, 29);
INSERT INTO meuble (id, uti_id, prix_paye) VALUES (6, 4, 50);
INSERT INTO meuble (id, uti_id, prix_paye) VALUES (7, 6, 30);
 
 
SELECT isnull(p.nom, 'Inconnu') pays, count(DISTINCT u.id) tot_users, count(DISTINCT m.uti_id) mob_users
FROM pays p
RIGHT OUTER JOIN uti u ON u.pays_id = p.id
LEFT OUTER JOIN meuble m ON m.uti_id = u.id
GROUP BY p.nom;

 
Sortie :

PS : Ca marche grace au Warning, c'est cool

Bah ouais, truc rarement utilisé, mais pourtant utile :
COUNT(DISTINCT field) => Nombre d'occurences uniques du champ
 
COUNT(outer field) => Lors d'une jointure ouverte, faire un count sur le champ du côté ouvert permet de retrouver le count tel qu'il aurait été avec un INNER JOIN (les NULL sont ignorés lors d'un count)

Humm... t'as raison
En même temps tu as pris le problème dans un autre sens: "Quels sont les utilisateurs présents dans la table meuble?" alors que je suis resté focalisé sur "Compter les utilisateurs qui ont acheté un meuble ou plus".
 
Force est de constater qu'avec ta méthode on arrive au même résultat, mais de manière bien plus optimale.

C'est je pense la plus grande difficulté du SQL...
 
Arriver à formuler de façon "optimale" le problème
Ca vaut souvent de bonnes prises de tête

Mais bon j'ai 23 autres topics à venir

Ceci dit je retiens pour plus tard la technique de anapajari qui consiste a joindre une table virtuelle contenant ce qu'il faut