Bonjour à tous,

Je viens vous demander un coup de main pour une requête toute simple mais qui me prend la tête.
Au passage, dites-moi si ce que je cherche à faire est possible ou complètement loufoque svp ?

En gros, j'ai une table qui contient certains champs (table référençant des pièces d'un produit) dont une des rubriques est de type VARCHAR.
Pour éditer cette liste de pièces, j'ai fait une requête (pas difficile en soi) qui est la suivante :

SELECT rel_pie_pla.pipl_repere, pi.pie_id, pi.pie_code, pi.pie_numchassisapplication, pi.pie_libelle_fr as libelle, pi.pie_prix_unit_ht, rel_pie_pla.pipl_qte, (SELECT COUNT(*) FROM planches WHERE pla_idpiecereference = pi.pie_id) as ssens
FROM pieces pi LEFT OUTER JOIN rel_pie_pla ON pi.pie_id = rel_pie_pla.pipl_idpiece
WHERE NULL IS NULL AND rel_pie_pla.pipl_idplanche = 324
ORDER BY rel_pie_pla.pipl_repere, CAST(REPLACE(rel_pie_pla.pipl_repere, '-', '0') AS SIGNED), pi.pie_code

Cette requête fonctionne dans 80% des cas, sauf lorsque la rubrique "rel_pie_pla.pipl_repere" (qui correspond au repère de la pièce sur un dessin) contient des valeurs du genre "1-1", "1-10", "1-10-2".

En effet, voici un exemple de résultat de cette requête :
pipl_repere     pie_id          pie_code
1                    5673            27.2.142
1-1                3874            27.2.158
1-1-1            3875            27.2.159
1-1-2            3876            27.0.549
1-1-3            3877            27.2.550
1-1-4            3878            27.0.550
1-10              3866            27.2.165
1-11              3864            27.2.464
1-12              3865            27.2.144
1-2                3858            27.2.143
1-2-1             2291            27.0.173
1-2-2             3860            27.2.153
1-2-3             3859            27.2.152
1-2-4             3861            27.2.155
1-2-5             3862            27.2.156
1-2-6             3863            27.2.151
1-3                3870            27.0.552
1-4                3873            27.2.161
1-5                3872            27.2.162
1-6                3871            27.2.160
1-7                3869            27.2.508
1-8                3868            27.2.164
1-9                3867            27.2.163
2                   2920            27.0.526
3                   3879            27.2.157

Or, la logique voudrait que les pièces en 1-10, 1-11, 1-12 viennent se placer après la pièce 1-9 ?? (dites-moi si je me trompe ...)

J'ai essayé pas mal de choses (conversions, complétions avec des 0, ...) mais rien n'y fait, c'est pour cela que je fais appel à vous pour essayer de me donner un coup de main.
A savoir que je souhaite le plus possible faire ce tri en SQL (sans algo de traitement après) car la base est utilisée par plusieurs applications que j'ai faites (au nombre de 4) dans différents langages (2 en Windev, 1 en ASP.NET et une autre en PHP) et j'ai pas trop envie de me repalucher le code dans chaque langage. D'autant que cette requête est exécutée dans plusieurs écrans de chaque application ....

Merci d'avance si vous pouvez au moins me donner une orientation, sinon une solution.

A bientôt

Pardon à tous, petite modif :

La requête :
SELECT rel_pie_pla.pipl_repere, pi.pie_id, pi.pie_code FROM pieces pi LEFT OUTER JOIN rel_pie_pla ON pi.pie_id = rel_pie_pla.pipl_idpiece WHERE NULL IS NULL AND rel_pie_pla.pipl_idplanche = 324
ORDER BY CAST(rel_pie_pla.pipl_repere AS SIGNED), CAST(REPLACE(rel_pie_pla.pipl_repere, '-', '0') AS SIGNED), pi.pie_code

et le résultat :
pipl_repere        pie_id        pie_code
1         5673    27.2.142
1-1      3874    27.2.158
1-2      3858    27.2.143
1-3      3870    27.0.552
1-4      3873    27.2.161
1-5      3872    27.2.162
1-6      3871    27.2.160
1-7      3869    27.2.508
1-8      3868    27.2.164
1-9      3867    27.2.163
1-10    3866    27.2.165
1-11    3864    27.2.464
1-12    3865    27.2.144
1-1-1   3875    27.2.159
1-1-2   3876    27.0.549
1-1-3   3877    27.2.550
1-1-4   3878    27.0.550
1-2-1   2291    27.0.173
1-2-2   3860    27.2.153
1-2-3   3859    27.2.152
1-2-4   3861    27.2.155
1-2-5   3862    27.2.156
1-2-6   3863    27.2.151
2          2920    27.0.526
3          3879    27.2.157

Or Normalement, il faudrait que les "1-1-x" soient après la pièce "1-1" mais avant la pièce "1-2" ??

Merci

Salut,
en effet complexe comme problème, voici une solution, si personne en trouve

Il te reste plus qu'a faire une colonne temporaire, qui s'alimente avec un tigger insert et qui permet de faire
un tri


1--> 1000
1-1 --> 10100
1-10 --> 1100

Et apres tu fais tes tri sur cette colonne.

Bon coding

Salut,

Merci pour l'info mais ta solution risque d'être un peu difficile à mettre en place du fait que la base est actuellement en cours d'utilisation, qu'elle contient déjà un paquet d'enregistrements et que les triggers réagissent à une action sur les données (ajout, modif, suppr). Il faudrait donc que je demande aux utilisateurs de repasser sur tous les enregistrements pour que cette colonne se mette à jour ... Ca me paraît difficile.

Par contre, comme je ne voyais vraiment pas de solution (frustration quand tu nous tiens), j'ai pris la décision de rajouter effectivement une colonne qui contient un numéro d'ordre qui me permettra de faire les tris correctement et je suis en train d'écrire une procédure de mise à jour de cette colonne en fonction du numéro de repère. (en fait c'est un peu la même solution que ce que tu me donnes, mais je n'ai pas l'intention d'utiliser un trigger, d'autant qu'il s'agit d'une base MySQL et que les trigger ne sont pas, à mon goût, encore au top ...).

Merci encore mais n'hésitez pas, si quelqu'un trouve une solution en SQL pur, ça  m'intéresse.

Une petite question, peut-être une piste que je vais essayer de creuser : n'y aurait'il pas un moyen de faire le tri sur un "codage" de la colonne repère, par exemple un cast en binaire ou en hexa, ou encore un hash ??? à voir ....

Tu mets a jour avec un update la colonne une fois,
le calcul dois bien etre testé
et apres cette fonction de calcul peut etre utilisée pour le calcul d'une clé sur les insertion

apres il faut savoir la cle est updatable ou pas?
dans ce cas il trouver une solution aussi sur les updates

et ensuite sur un insert la valeur est calculée par un trigger (si my sql ne gere pas les triggers)
il faut le mettre dans chaque insert le calcul du numero de tri.





Le probleme de ton numero d'ordre est une mauvaise solution

Exemple

1-10-9 | 5
1-11    | 6

Quand tu inseres 1-10-10 comment tu fais pour le numero d'ordre.

Salut,

Remarque très pertinente ...
La gestion du numéro d'ordre est, à mon sens, la solution la plus simple car j'ai fait en sorte que toutes mes applications travaillent avec un tableau pour présenter la liste des pièces.
Du coup, lorsque l'utilisateur fait une modification, mon numéro d'ordre correspond simplement au numéro de ligne dans le tableau. Du même coup, ça me permet de proposer aux utilisateurs la possibilité (par le biais de 2 boutons) de trier les éléments comme ils le souhaitent et je n'ai qu'une colonne à gérer pour avoir le bon ordre.
Ensuite, étant donné que les utilisateurs sont obligés de passer par ces tableaux, j'ai  uniquement un parcours du tableau à faire sur la fermeture de la fenêtre pour mettre à jour le numéro d'ordre.

Merci pour les infos et surtout de t'intéresser à mon cas.

A bientôt

Oui,

Mais il faut enregistrer tous les numéros d'ordre dans la base de données

soit n (nb element) requetes pour mettre a jour les numeros d'ordre de tes n elements.

une requete update par ligne

avec ma solution une grosse requete pour renseigner la colonne
et ensuite un calcul de valeur pour l'insertion

Re,

C'est vrai, mais pour ta solution, le problème est le même.
D'autant que je ne vois pas quelle requête je peux faire pour arriver aux exemples que tu m'as donnés :
1--> 1000
1-1 --> 10100
1-10 --> 1100

pour le 1 ok je RPAD avec '0' sur une longueur de 4, idem pour le 1-10 mais en faisant un replace du '_'.
Par contre, pour le 1-1, je vois pas comment traiter des cas différents dans une même requête ?? ou alors j'ai pas compris tes exemples, ce qui est possible aussi.

Dis m'en plus stp.

Oui,
L'algo n'est pas evident,
tu peux le faire dans ton langage de predilection a la place et le faire en SQL,
il faire faire une fonction

Exemple
function long calculNoPieceTri(string nopiece)


tabNumeroPiece = nopiece.split('-");
part1 = tabNumeroPiece[0];
part2 = tabNumeroPiece[1];
part3 = tabNumeroPiece[2];

return part1 * 10000 + part2 *100 + part3

C'est surement faisable en SQL, mais un peu plus complexe car le split n'existe pas, et les calculs seront moins rapide
car le SQL n'est pas optimisé pour des calculs de chaine de caracteres.


Et donc pour avoir le numero de piece
exemple :
2-25-2 --> 22520
2-1-30 --> 21030

Il faudra faire une fonction pour la mise a jour de toutes les pieces.

Voila

Salut,

merci pour les explications.
Maintenant, je vais voir si cela vaut plus le coup que la mise en place du numéro d'ordre.
Parceque le problème est également que le repère n'est pas forcément que sur 3 parties, il peut y en avoir jusqu'à 5 donc 1-1-1-1-1. Je pense que l'algo à mettre en place pour le calcul risque d'être plus coûteux que celui du numéro d'ordre.

Je vais étudier cela et je te tiens au courant quand j'aurai fini.

Merci en tout cas de ton aide.