SELECT l1.id_dossier, l1.ref, l5.nom_prenom AS nom_prenom_d1, l7.nom_prenom AS nom_prenom_d2, l8.nom_prenom AS nom_prenom_f
FROM dossiers AS l1
LEFT JOIN liaison_dossier AS l2 ON ( l1.id_dossier = l2.id_dossier AND l2.type_user = '".$type."' )
LEFT JOIN liaison_dossier AS l3 ON ( l1.id_dossier = l3.id_dossier AND l3.type_user = 'D' )
LEFT JOIN liaison_dossier AS l4 ON ( l1.id_dossier = l4.id_dossier AND l4.type_user = 'A' )
LEFT JOIN liaison_dossier AS l6 ON ( l1.id_dossier = l6.id_dossier AND l6.type_user = 'B' )
LEFT JOIN users AS l5 ON ( l4.id_user = l5.id_user )
LEFT JOIN users AS l7 ON ( l6.id_user = l7.id_user )
LEFT JOIN users AS l8 ON ( l3.id_user = l8.id_user )
WHERE ( l2.id_user = '".$id."' OR ( l3.id_user = '".$id."' AND l4.type_user IS NOT NULL AND l2.type_user IS NULL ) )
GROUP BY l1.id_dossier
ORDER BY ".$SELECTION." ".$ORDRE."
LIMIT ".$debut.",".$limit

SELECT l1.id_dossier
FROM dossiers AS l1
LEFT JOIN liaison_dossier AS l2 ON ( l1.id_dossier = l2.id_dossier
AND l2.type_user = 'A' )
LEFT JOIN liaison_dossier AS l3 ON ( l1.id_dossier = l3.id_dossier
AND l3.type_user = 'B' )
LEFT JOIN liaison_dossier AS l4 ON ( l1.id_dossier = l4.id_dossier
AND l4.type_user = 'C' )
WHERE l2.id_user = 'xxx'
OR ( l3.id_user = 'xxx'
AND l4.type_user IS NOT NULL
AND l2.type_user IS NULL )

# c'est étrange de voir un "id" en VARCHAR, si ces "id" sont des nombres il vaudrait mieux utiliser le type INT (plus rapide, plus compacte, ne risque pas d'insérer autre chose qu'un nombre, n'est pas vulnérable à un espace mal placé, etc...)

# pourquoi "type_user" est-il un CHAR(3) ? N'est-il pas destiné à stocker une seule lettre à la fois ? Auquel cas un CHAR(1) est plus adapté voire mieux encore, un ENUM('A','B','C','D')

# il faudrait un index sur (id_user,type_user)

Idéalement, il vaudrait mieux avoir un index UNIQUE sur (id_user,type_user,id_dossier) à la place, pour garantir qu'il n'y a pas de doublons (il améliorerait les performances également). D'un autre côté, les VARCHAR prennent dans un index autant de place que le CHAR équivalent donc la taille de ton index serait supérieur à celle de tes données. À toi de voir quelle importance tu accordes à la propreté des données.

SELECT d.*
FROM (
SELECT DISTINCT id_dossier
FROM liaison_dossier
WHERE id_user = 'XXX'
AND type_user = 'C'
) AS ld
JOIN dossiers d USING (id_dossier)

Maintenant, concernant le reste du sujet... je n'ai pas vraiment compris comment fonctionnait le type D. Apparemment il est considéré comme un A s'il n'y a pas de A, comme un C s'il n'y a pas de C et est ignoré dans tous les autres cas ? Ne pourrais-tu pas créer un TRIGGER pour automatiquement modifier sa valeur ? Par exemple, quelqu'un insère un D, il n'y a pas de A alors tu remplaces automatiquement le D.

Sinon, pour déterminer la valeur de D il va falloir faire plusieurs auto-jointures pour savoir si c'est un A, un B ou rien du tout. Est-ce que ta liste de 6 cas est exhaustive ? Pas de "A-D", "D", "A-C-D" ?

• c'est étrange de voir un "id" en VARCHAR, si ces "id" sont des nombres il vaudrait mieux utiliser le type INT (plus rapide, plus compacte, ne risque pas d'insérer autre chose qu'un nombre, n'est pas vulnérable à un espace mal placé, etc...)
• pourquoi "type_user" est-il un CHAR(3) ? N'est-il pas destiné à stocker une seule lettre à la fois ? Auquel cas un CHAR(1) est plus adapté voire mieux encore, un ENUM('A','B','C','D')
• il faudrait un index sur (id_user,type_user)

  Code : Tout sélectionner

  CREATE INDEX type_par_user ON liaison_dossier (id_user, type_user)
  Idéalement, il vaudrait mieux avoir un index UNIQUE sur (id_user,type_user,id_dossier) à la place, pour garantir qu'il n'y a pas de doublons (il améliorerait les performances également). D'un autre côté, les VARCHAR prennent dans un index autant de place que le CHAR équivalent donc la taille de ton index serait supérieur à celle de tes données. À toi de voir quelle importance tu accordes à la propreté des données.