Requête Multi Langue

Bonjour je fais un système de gestion multi langue

Exemple table category contient un id
il y a une table language qui contient id, code(pour fr, en, es etc)
et une autre table intersection language_category qui contient id_language, id_category, name

je fais mon affichage avec cette requête

Code:

---

1 2 3 4 5

SELECT category.id_category, language_category.name FROM category INNER JOIN language_category USING(id_category) INNER JOIN language USING(id_language) WHERE language.code='fr' ORDER BY language_category.name ASC

---

Le problème est que j'aimerais s'il n'a pas la langue Français, afficher en Anglais et si pas en Anglais afficher Espagnol par exemple un sorte priorité en fonction de la langue de utilisateur

Je ne sais pas si vous avez déjà fait quelques chose de ce genre

Merci

Bonjour,


comment avez-vous modélisé cette histoire de priorité ?

Merci, je ne suis pas un expert en base de données j'apprends sur le tas je ne sais pas si j'ai fais ça comme il faut.

dans la table category il y a un id

exemple id_category

id_category(KEY)
1
2

dans la table language il y a id_language, code

id_language(KEY) code
1 fr
2 en

et dans la table language_category il y a id_language, id_category, name

exemple

id_language(KEY) id_category(KEY) name
1 1 Poulet
2 1 Chicken
2 2 Fish


si mon utilisateur est un français va voir dans la table category, voit qui il y a id 1 et 2, mais 2 voit qui y a pas de libellé en Français parce que le lui envoi fr, mais un en Anglais alors il affiche

Poulet
Fish

C'est sure quand 2e je veux aller voir le libelle en anglais

je ne sais pas si il faut faire une boucle ou autre je pourrai m’en sortir avec PHP mais je crois que le faire dans en SQL irai plus vite.

Merci

Comment gérez-vous les libellés ? vous les chargés en mémoire au démarrage de l'appli ? où vous faites des requêtes sur votre table au fure et à mesure ?

Je suppose qu'il existe une table qui identifie pour chaque utilisateur les langues qu'il utilise avec leur niveau de priorité.
Cette table aurait la structure suivante :

user_language_priority (id_user, id_language, priority)

A partir de là, la requête est assez simple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

WITH libelle AS ( SELECT cat.id_category , lct.name , lgp.priority FROM category AS cat INNER JOIN language_category AS lct ON cat.id_category = lct.id_category INNER JOIN user_language_priority AS lgp ON lct.id_language = lgp.id_language WHERE lgp.id_user = 'XXX' ) SELECT lbl.id_category , lbl.name FROM libelle AS lbl WHERE EXISTS ( SELECT NULL FROM libelle sel WHERE lbl.id_category = sel.id_category HAVING lbl.priority = MIN(sel.priority) ) ORDER BY lbl.name ASC

---

bonjour,


PgSql supportant les fonctions de fenêtrage une solution qui fera des scannages en moins :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

with tmp as ( select lca.id_category, lca.name, row_number() over(partition by lca.id_category order by priority) as rnk from language_category lca inner join language lan on lan.id_language = lca.id_language inner join user_language_priority ulp on ulp.id_language = lan.id_language where ulp.id_user = 'XXX')   select id_category, name from tmp where rnk = 1

---

Alors maintenant, si vous executez la requête à chaque fois que vous avez besoin d'un libellé il faudrai plutôt orienter la requête sur un simple ORDER BY suivit d'un FETCH FIRST 1 ROWS ...

Merci, j'avais pas pensé cette table, je vais tester ça, je vous en redonne des nouvelles.

J'ai réussi affaire quelques chose avec ça

Code:

---

1 2 3 4 5 6 7 8

WITH tmp AS (SELECT lca.id_category, lca.name, row_number() over(partition BY lca.id_category ORDER BY lca.id_language DESC) AS rnk FROM language_category lca INNER JOIN language lan ON lan.id_language = lca.id_language)   SELECT id_category, name FROM tmp WHERE rnk = 1

---

Utilise ASC et DESC un pour ASC anglais pour id 1 et l'autre pour français id 2 avec deux langues je vais pouvoir me débrouiller pensez-vous que je devrais indexer mes colonnes id

Merci

Bonjour,

Par défaut indexez systématiquement vos foreign key, sauf si celle-ci ne sont jamais utilisée pour faire des jointures.

Les primary key sont déjà indéxée.

Il peut être utile parfois d'indexer la clause where suivit de la clause de jointure sur une même table, si vous avez des problèmes spécifique de perf.

A lire : http://sqlpro.developpez.com/cours/quoi-indexer/