Discussion :

[rejul]

Bonjour à tous!

Nous sommes nouveaux sur ce forum, et nous avons besoin de vous de toute urgence!

Nous réalisons un projet en Java pour les cours et avons un petit souci avec une requête SQL.

Voilà le problème:
Nous avons une table contenant deux colonnes, l'une avec des identifiants de plats, l'autre avec des identifiants d'ingrédients.
Nous souhaitons effectuer une requête sur cette table pour sélectionner les identifiants des plats qui contiennent tous les identifiants des ingrédients que l'on rentre dans la commande.

En fait, l'utilisateur tape des noms d'ingrédients et nous voulons lui proposer les plats qui les contiennent tous (mais pas forcément que ceux ci). Donc on récupère les identifiants des ingrédients tapés, puis on veut effectuer une requete pour retourner les identifiants des plats correspondants.

Pouvez-vous nous aider?

Merci beaucoup à vous!

[rejul]

alors personne n'a une petite idée? si vous voulez des précisions n'hésitez pas à demander!!

[Yanika_bzh]

alors personne n'a une petite idée? si vous voulez des précisions n'hésitez pas à demander!!

les ingredients entrés par l'utilisateur sont stockées dans une table ?

[rejul]

oui ils le sont

[Yanika_bzh]

Conformément aux règles du forum :

- quelle base de données ?
- Script des tables
- Jeu d'essais.

Ca permettra de t'aider beaucoup plus rapidement

[rejul]

Nous travaillons avec netbeans et derby.

Voici le code permettant de créer la table Ingrédient:

String creationSQLPourDerby =
"CREATE TABLE Ingredient (\n"+
" idIng INTEGER NOT NULL GENERATED ALWAYS AS IDENTITY, \n"+
" nomIng VARCHAR(40) NOT NULL,\n"+
" type INTEGER NOT NULL,\n"+
" categorie INTEGER NOT NULL,\n"+
" partie INTEGER,\n"+
" CONSTRAINT PK_1 PRIMARY KEY(idIng)\n"+
")";
st.executeUpdate(creationSQLPourDerby);


code pour la création de la table Plat :

String creationSQLPourDerby3 =
"CREATE TABLE Plat (\n"+
" idPlat INTEGER NOT NULL GENERATED ALWAYS AS IDENTITY, \n"+
" nomPlat VARCHAR(40) NOT NULL,\n"+
" difficulte VARCHAR(20) NOT NULL,\n"+
" note INTEGER,\n"+
" tpsprepa INTEGER,\n"+
" typeplat VARCHAR(20),\n"+
" instru VARCHAR(5000),\n"+
" commentaires VARCHAR(5000),\n"+
" image BLOB(3000000),\n"+
" CONSTRAINT PK_3 PRIMARY KEY(idPlat)\n"+
")";
st.executeUpdate(creationSQLPourDerby3);

code pour la création de la table joignant les tables Ingrédient et Plat

String creationSQLPourDerby5 =
"CREATE TABLE IngPlat (\n"+
" idPlat INTEGER NOT NULL,\n"+
" idIng INTEGER NOT NULL,\n"+
" quantite FLOAT NOT NULL,\n"+
" unite VARCHAR(20) NOT NULL,\n"+
"CONSTRAINT FK_IngPlat_Ing FOREIGN KEY(idIng) REFERENCES Ingredient\n"+
")";
st.executeUpdate(creationSQLPourDerby5);
}


Par contre, nous ne savons ce qu'est un jeu d'essai.
Merci de votre aide.

[jpelaho]

Je vous propose de créer une fonction dans votre langage ou une procédure stockée qui prend en paramètre l'identifiant de l'utilisateur et renvoie les plats qui lui conviennent selon les ingrédients qu'il a choisi.

La table des ingrédients choisis par l'utilisateur est IngUser(UserId , idIng)
Si @UserId est votre paramètre,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
SELECT IdPlat,NomPlat FROM Plat P
WHERE NOT EXISTS
(
SELECT idIng  FROM IngUser
WHERE idIng  NOT IN 
    (SELECT idIng  FROM IngPlat WHERE IdPlat = P.IdPlat) AND UserId = @UserId
)

[fsmrel]

Variante...

Supposons que l’on dispose d’une table CdeIngredient dans laquelle pour chaque commande, on trouve l’ensemble des ingrédients requis pour la commande.
Soit PlatIngredient la table qui donne l’ensemble des ingrédients entrant dans la composition de chaque plat.
Le schéma des tables est le suivant (clé primaire soulignée) :

CdeIngredient (CdeId, IngredientId, ...)

PlatIngredient (PlatId, IngredientId, ...)

La théorie relationnelle propose l’opérateur DIVIDEBY pour obtenir tous les plats où l’on trouve (au moins) tous les ingrédients requis pour une commande donnée (disons 'c1'). L’ensemble de ces plats est le résultat de l’opération :

(Plat DIVIDEBY Commande Where CdeId = 'c1') {PlatId}

Malheureusement, SQL ne propose pas cet opérateur, il faut donc le paraphraser en faisant des contorsions.

Prenons l’énoncé :

« Quels sont les plats qui comportent tous les ingrédients de la commande 'c1' »

La quantification universelle permet de résoudre le problème. Mais, si SQL propose un avatar de la quantification existentielle avec EXISTS, ce langage ne propose rien quant à la quantification universelle. Heureusement, on sait exprimer la quantification universelle au moyen de la quantification existentielle :



Du fait de la double négation, on paraphrase donc ainsi l’énoncé précédent :

« Quels sont les plats pour lesquels il n’existe pas d’ingrédient qui n’existe pas dans la commande 'c1' »

La requête SQL correspondante fait donc intervenir un double NOT EXISTS :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
Select Distinct PlatId
From   PlatIngredient As P1
Where  Not Exists (
       Select  *
       From    CdeIngredient As C
       Where   CdeId = 'c1'
       And     Not Exists (
               Select  *
               From    PlatIngredient As P2
               Where   P1.PlatId = P2.PlatId
                 And   C.IngredientId = P2.IngredientId
                         )
                   ) ;

Il existe d’autres façons de s’en sortir, mais celle-ci s’appuie uniquement sur la logique.

[Yanika_bzh]

Si les ingredients entrés par l'utilisateur sont stockés dans une table table1

alors tu peux t'inspirer de ce genre de requete :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
SELECT idPlat FROM IngPlat 
WHERE EXISTS (SELECT 1 FROM table1 WHERE IngPlat.IdIng = table1.idIng)
GROUP BY IdPlat
HAVING COUNT(1) >= (SELECT COUNT(1) FROM table1)

bien entendu si table1 possede plusieurs utilisateurs, il faudra filtrer.
Attention !! Requete non testée

Bon courage