Bonjour,

Je vous expose mon projet et mon problème:

Projet:
J'invite des gens à manger, certains n'aiment vraiment pas certains aliments et il faut donc que je prenne ça en compte. De plus, il faut que j'évite de faire 2 fois la même chose aux invités (même si c'est bon ).
Je me suis donc fait un petit site web me permettant d'entrer:
- Mes recettes avec des mots-clés qui serviront pour les goûts des personnes
- Les invités avec quelques infos, + des mots-clés décrivant ce qu'ils n'aiment pas (ananas, etc...)

Pour gérer ça j'ai plusieurs tables:
- Recettes

CREATE TABLE `recettes` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `titre` varchar(64) NOT NULL,
  `id_type` int(11) NOT NULL,
  `nbPersonnes` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `titre` (`titre`,`id_type`),
  FULLTEXT KEY `titre_2` (`titre`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1

- Type (les types de recette: entrée, plats, desserts, etc...)

CREATE TABLE `types` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `type` varchar(32) NOT NULL,
  `ordre` int(11) NOT NULL,
  PRIMARY KEY (`id`),
  KEY `ordre` (`ordre`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1

- personnes_gouts (qui fait la liaison entre les ID des personnes et les gouts. Si "aime=0" alors c'est quelque chose que la personne n'aime pas)

CREATE TABLE `personnes_gouts` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `id_personne` int(11) NOT NULL,
  `aime` tinyint(4) NOT NULL,
  `gout` varchar(64) NOT NULL,
  PRIMARY KEY (`id`),
  KEY `id_personne` (`id_personne`,`aime`,`gout`),
  KEY `gout` (`gout`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1

- personnes_recettes (qui fait la relation entre les ID des personnes et les ID des recettes qu'elles sont déjà eu)

CREATE TABLE `personnes_recettes` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `id_personne` int(11) NOT NULL,
  `id_recette` int(11) NOT NULL,
  PRIMARY KEY (`id`),
  KEY `id_personne` (`id_personne`,`id_recette`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1

- mots_cles (qui fait la relation entre des ID des recettes et donc les mots-clés qui vont avec)

CREATE TABLE `mots_cles` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `id_recette` int(11) NOT NULL,
  `mot_cle` varchar(32) NOT NULL,
  PRIMARY KEY (`id`),
  KEY `id_recette` (`id_recette`,`mot_cle`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1 

PROBLEME:
Voici ce que je souhaite obtenir:
- Je récupère grâce à un formulaire les ID des personnes qui vont être invitées, et je précise un ID de type (par exemple l'ID 1 qui est le type "entrée")
- Je voudrais une requête qui me sort un menu que je n'ai pas encore fait aux invités et donc aucun mot-clés desdits recettes ne soient dans les goûts à éviter pour ces mêmes personnes

Cette requête sera donc à créer dynamiquement suivant le nombre de personnes cochées, ce que je ferai en PHP, pas de souci là dessus.

Par contre voilà, la requête "de base" me pose souci avec après moult essais je n'y parviens pas... Alors qu'il s'agit du principal intérêt du site en question.

J'espère avoir été clair dans mon explication... A vot' bon cœur m'sieur dames!

salut,

Qu'a tu tenté comme requête ?

le principe :
Tu sélectionne sur la table recettes pour le type fournit par le formulaire.
ensuite tu restreint en demandant les id recette qui ne sont pas dans les tables personnes_recettes et personnes_gouts pour les personnes sélectionnées.

pour cela tu besoin de connaitre

- la clause in
- la négation (par exemple not in )
- les sous requêtes

Avec un bon formatage ça fait max 10 lignes


@+

C'est au niveau des "IN" et "NOT IN" que j'ai des m*****

Voici par exemple ce que j'ai:

SELECT DISTINCT r.id, r.titre, r.nbPersonnes FROM recettes r, mots_cles m WHERE r.id_type=22 AND m.id_recette=r.id AND m.mot_cle NOT IN (SELECT DISTINCT gout FROM personnes_gouts WHERE (id_personne=17 || id_personne=18) AND aime=0) 

Pour un ID de type=22 et pour 2 personnes d'ID 17 et 18. Ca ne fonctionne évidemment pas.
Je continue à chercher de toute façon mais j'ai "quelques" lacunes en SQL (que je tente de corriger!).

pourquoi un distinct ?

FROM recettes r, mots_cles m
non mots_clefs ne sert à rien ici.
tu ne prend pas le sujet dans le bon sens.

tu selectionne les recettes qui ont un type précis et dont l'id ne fait pas partis de recettes déja testées par une personnes (donc de personnes_recettes) et dont l'id n'est pas la table personnes_gouts).

en clair

SELECT *
FROM recettes
WHERE id_type = 1
      AND id NOT IN (SELECT id_recette
                     FROM personnes_recettes
                     WHERE id_personne IN (les id des gens))
      AND id NOT IN (SELECT id_recette
                     FROM personnes_gouts
                     WHERE id_personne IN (les id des gens))

c'est a tester bien entendus mais le principe est la.

@+

Suivant ce principe, voici ce que j'ai obtenu et qui fonctionne au poil:

SELECT r.id, r.titre, r.nbPersonnes  
FROM recettes r  
WHERE r.id NOT IN (  
  SELECT mc.id_recette  
  FROM mots_cles mc  
  WHERE mot_cle IN (  
    SELECT pg.gout 
    FROM personnes_gouts pg 
    WHERE pg.id_personne IN (id_des_personnes) 
    AND aime = 0 
  ) 
) 
AND r.id NOT IN ( 
 SELECT pr.id_recette 
 FROM personnes_recettes pr 
 WHERE pr.id_personne IN (id_des_personnes) 
) 
AND r.id_type = id_du_type