Discussion :

[davland7]

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 :

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

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

[punkoff]

Bonjour,


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

[davland7]

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

[punkoff]

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 ?

[al1_24]

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 :

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

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

[punkoff]

bonjour,


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

Code :

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

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 ...