[MySQL 4.0] Question sur GROUP BY

Version imprimable

bonjour à tous et à toute,

j'ai 2 tables comme ceci :

TABLE "SONG" : id (clé)
TABLE "SONG_FILE" : id (clé), song_id (clé étrangere ID de SONG) track_type (int)

un SONG contient 0 ou plusieurs SONG_FILE

relation relativement simple, comme vous pouvez le voir.

ce que je souhait effectué comme requête.

je veux parcourir tout les SONG_FILE groupé par SONG, et extraire ceux, dont le track_type est égal au max(track_type) du group SONG

alors en fait j'avais procédé ainsi :
Code:

1 2 3 4 5 6 7 SELECT sf.id, s.id, track_type, max(track_type) as max_track FROM song_file AS sf LEFT JOIN song AS s ON sf.song_id = s.id WHERE sf.seller_id =1 AND TYPE =1 GROUP BY song_id HAVING track_type = max_track
il compare pas chaque SONG_FILE par rapport au max(track_type) du group SONG en procédant comme ceci :/

si vous avez éventuellement des solutions.

petit exemple de ce que ca doit donner :

avant la requête :
Code:

1 2 3 4 5 6 ID SONG_ID TRACK_TYPE 145 5400 3 146 5400 1 147 5400 1 178 3600 2 177 3600 1
apres la requête :
Code:

1 2 3 ID SONG_ID TRACK_TYPE MAX_TRACK 145 5400 3 3 178 3600 2 2
Merci pour votre aide les gars

25/09/2006, 11h40
crovette51101

bonjour,
j'ai deja rencontrer un probleme similaire, je vais te donner une technique pas trés commode (plutot armoire :P ) mais qui a porté ses fruits, mais je te conseille tout de suite de dupliqué ta table pour faire un test, alors la technique consiste a supprimer les doublons par une méthode pas commode non plus aprés avoir rangé ta table par ordre croissant sur le song id et decroissant sur le track type (dans cette ordre!), ce qui donne:

SELECT ID, song_ID ,Track_Type
FROM table
ORDER BY song_ID, Track_Type desc;

Mais ce n'est pas fini car la tu aura juste ajouter tes chanson par ordre croissant de song id et decroissant de track type, maintenant, il faut virer les doublons, pour cela tu va dans la table que tu va remplir et tu met le champs "song id" en clé primaire comme ca il va supprimer tous les doublons!!!
hihihi:lol: fallait y penser!

tiens moi au courrant mais normalement ca marche meme si la manip parrait un peu barbare
25/09/2006, 11h53
Fabouney

Citation:

Envoyé par crovette51101

Mais ce n'est pas fini car la tu aura juste ajouter tes chanson par ordre croissant de song id et decroissant de track type, maintenant, il faut virer les doublons, pour cela tu va dans la table que tu va remplir et tu met le champs "song id" en clé primaire comme ca il va supprimer tous les doublons!!!
hihihi:lol: fallait y penser!

je comprend ta requête c'est plutot astucieux, mais je comprend pas la 2eme partie, pour virer les doublons.
si tu peux être un peu plus clair.
mais je reste tout de même persuader qu'avec un simple GROUP BY cela est réalisable.
25/09/2006, 13h26
crovette51101

en fait ton group by va servir, je pense si tu aurai voulu additionner un champs, or la ce n'est pas le cas, ma deuxieme parti va supprimer tous les doublons en ne gardant que le premier de la liste, donc celui que tu cherches!
je m'explique, avec la premiere partie ca donne:
1 5000 3
2 5000 2
3 5000 1
4 5400 3
5 5400 1
6 5400 1
7 6000 2
8 6000 1...
en supprimant les doublons comme je te les montré, tu obtiendras:
1 5000 3
2 5400 3
3 6000 2

voili,voilou!

alors ca marche?:)

il faut faire une sous-requête sur SONG_FILE, en récupérant le MAX de la valeur de track_type par song_id, et faire une jointure dessus.

Voici un jeu d'essai, sous Oracle (mais cela ne devrait poser aucun problème d'adaptation) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
CREATE TABLE SONG (
id NUMBER (4));
 
CREATE TABLE SONG_FILE (
id NUMBER (4),
song_id NUMBER (4),
track_type NUMBER (4));
 
INSERT INTO SONG VALUES (5400);
INSERT INTO SONG VALUES (3600);
 
INSERT INTO SONG_FILE VALUES (145, 5400, 3);
INSERT INTO SONG_FILE VALUES (146, 5400, 1);
INSERT INTO SONG_FILE VALUES (147, 5400, 1);
INSERT INTO SONG_FILE VALUES (178, 3600, 2);
INSERT INTO SONG_FILE VALUES (177, 3600, 1);

Et la requête :

Code:

1
2
3
4
5
6
7
8
9
10
SQL> SELECT sf.id, sf.song_id, sf.track_type
  2     FROM SONG_FILE sf
  3    WHERE sf.track_type = (SELECT MAX(track_type)
  4                             FROM SONG_FILE sfmax
  5                           WHERE sfmax.song_id = sf.song_id);
 
        ID    SONG_ID TRACK_TYPE
---------- ---------- ----------
       145       5400          3
       178       3600          2

Par contre, cette requête ne t'assure pas l'unicité de ton sf.id : en effet, si plusieurs enregistrements ont la même valeur pour le champ track_type, et que cette valeur correspond au MAX, alors tu récupéreras toutes ces lignes.

pour t'en convaincre, je rajoute cette ligne à mon jeu d'essais :

Code:

INSERT INTO SONG_FILE VALUES (148, 5400, 3);

Et voici le résultat :

Code:

1
2
3
4
5
6
7
8
9
10
11
SQL> SELECT sf.id, sf.song_id, sf.track_type
  2     FROM SONG_FILE sf
  3    WHERE sf.track_type = (SELECT MAX(track_type)
  4                             FROM SONG_FILE sfmax
  5                           WHERE sfmax.song_id = sf.song_id);
 
        ID    SONG_ID TRACK_TYPE
---------- ---------- ----------
       145       5400          3
       178       3600          2
       148       5400          3

25/09/2006, 13h46
crovette51101

bien jouez Xo, sa semble plus dans les normes seulement ca parait un peu plus complexe que moi pour un resultat qui garde des doublons alors que le mien non, enfin, laissons le choix au demandeur!
mais c'est une bonne astuce!;)
25/09/2006, 14h28
Fabouney

Merci pour ta réponse Xo, en effet, j'avais fait ca tout au début. sa pose aucun pb.
seulement le serveur ou est hébergé le site est sous mysql 4.0, donc requête imbriquées impossible, c'est pouquoi je demande une solutions avec le group by.
crovette, j'ai compris lol, mais comment tu t'y prend pour supprimer les doublons.
25/09/2006, 15h33
Xo
Citation:

Envoyé par Fabouney

seulement le serveur ou est hébergé le site est sous mysql 4.0, donc requête imbriquées impossible, c'est pouquoi je demande une solutions avec le group by.

Hum :? ... d'où l'utilité de lire et de tenir compte des CONSEILS... à lire AVANT de POSTER, ça m'aurait évité de passer du temps à te proposer une solution que tu connaissais et dont tu savais qu'elle ne fonctionnait pas :roll:

Voici 2 solutions que je peux te proposer :

1) On lit la FAQ MySQL :
Comment pallier l'absence de requêtes imbriquées dans les versions < 4.1 ?
=> dans ce cas, il te faut passer par une table temporaire, pour y stocker les résultats de la requête
Code:

1 2 3 SELECT song_id, MAX(track_type) FROM SONG_FILE GROUP BY song_id
et faire ensuite ta jointure dessus.

2) Faire ta requête, rajouter une clause du type

Code:

ORDER song_id, track_type DESC

et en parcourant le résultat, ne parcourir que la première ligne pour chaque song_id : mais là on sort du cadre du SQL.
25/09/2006, 15h43
crovette51101

en fait la suppression des doublons se fai automatiquement lorsque tu met le champs 'Song_Id' (je crois que c'est lui) en clé primaire!
car qui dit clé primaire dit 'impossible de garder les enregistrements en double lorsque le champs est une clée primaire!!!!!'
j'espere que ca t'aura aidé;)
25/09/2006, 16h47
Xo

Non, non, non ... :?

Quel que soit le SGBD, on ne peut créer une contrainte en général, et donc une clé primaire en particulier, si des enregistrements ne permettent pas de valider cette contrainte !

il faut dédoublonner la table d'abord (cf un article sur le sujet : Les doublons), puis ensuite créer la contrainte.

Mais je ne pense pas que c'est ce que souhaite Fabouney, il n'a dit nulle part qu'il souhaitait dédoublonner ses données : il a juste un problème de filtre.
25/09/2006, 19h45
crovette51101

j'ai fait de mon mieux pour l'aider, je debute , je n'ai que tout juste 1 mois d'xperience lol !en tout cas moi c'est une technique que je ne trouve pas tres conforme mais qui m'a trés bien aidé donc voili voilou!
bon courrage