Discussion :

[Bakkach]

Bonjour, j'espère que vous allez bien..
Donc, je souhaite créer une requête sous sql server, cette dernière va me permettre de récupérer toutes ms chambres réservées(il s'agit d'une gestion de réservation alors :p) via une requête et les afficher dans un seul champ. J'explique:
1 - J'ai une table chambres(chambre_id, chambre_nom)
2 - une table resrvations(reservation_id, reservation_debut, reservation_fin)
vu qu'une réservation peut concerner plusieurs chambres alors j'ai crée:
3 - une troisième table intermédiaire concerne(reservation_id, chambre_id).
Pour conclure, je veux créer la requête qui me permettra d'afficher le résultat suivant:
"______________________________________________________
| reservation_id | reservation_debut | Reservation_fin | Chambres |
---------------------------------------------------------------
| #1 | 12-04-2013 | 16-04-2013 | 45V 36V |
---------------------------------------------------------------- "

Comme vous le voyez dans le champ "Chambres", il y'a 45V et 36V, qui sont les noms de deux chambres réservées dans la réservation "#1"..J'espère que ma question est claire, et en attente de tout type de proposition, je vous remercie infiniment d'avance ..

[iberserk]

Pouvez vous poster les DDL de vos tables? (les create tables)?

[hmira]

Ce que tu veux faire va à l’encontre du modèle relationnel ! Le résultat recherché ne respecte même pas la première forme normale !
Normalement les noms des chambres doivent être présentés en lignes (une chambre par ligne ) et non pas regroupés dans la même colonne !
Mais il est vrai, par ailleurs, qu’il s’agit, d’après mon expérience, d’une demande récurrente que de vouloir présenter des ensembles dans une colonne en l’occurrence la colonne "chambres" dans ton exemple.
Une solution, parmi d’autres, serait la suivante :
1 – Créer une fonction scalaire qui retourne la liste des chambres pour une réservation donnée

Code SQL :

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
CREATE FUNCTION dbo.Fc_ListeChambres(
@pi_Reservation_Id INT 
)
RETURNS varchar(8000)
AS
BEGIN 
 DECLARE @Resultat VARCHAR(8000); 
 SET @resultat = ''; 
 SELECT @Resultat = @Resultat + ' ' + ISNULL(C.chambre_nom,'') 
 FROM Concerne L 
 INNER JOIN chambres C 
   ON C.Chambre_Id = L.Chambre_Id
  WHERE L.Reservation_Id = @pi_Reservation_Id;   -- paramètre de la fonction : Reservation_Id    
 SET @resultat = SUBSTRING(@Resultat, 1, LEN(@Resultat)); -- pour supprimer le dernier espace séparateur 
 RETURN @Resultat; 
END

2 - Utiliser la fonction dans instruction SELECT comme le montre l'exemple ci-dessous :

Code SQL :

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

1
2
SELECT reservation_id, reservation_debut, Reservation_fin, dbo.Fc_ListeChambres(reservation_id) As Chambres 
FROM reservations

Exemple de résultat :

Code SQL :

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

1
2
reservation_id	reservation_debut	Reservation_fin	Chambres
1	      2013-05-01 	2013-05-08    45V 36V

A+

[elsuket]

Bonjour,

Ce que tu veux faire va à l’encontre du modèle relationnel ! Le résultat recherché ne respecte même pas la première forme normale !
Normalement les noms des chambres doivent être présentés en lignes (une chambre par ligne ) et non pas regroupés dans la même colonne !
Mais il est vrai, par ailleurs, qu’il s’agit, d’après mon expérience, d’une demande récurrente que de vouloir présenter des ensembles dans une colonne en l’occurrence la colonne "chambres" dans ton exemple.

Ce que vous dites est vrai, mais il ne faut pas confondre la présentation, qui n'a pas de formes normales, et le modèle, ici correct.
Effectivement on aurait pu faire cela côté applicatif puisqu'il s'agit de cosmétique; cela étant il existe des outils de reporting qui ne permettent pas de réaliser ce type d'implémentation.

D'autre part les fonctions scalaires sont contre-performantes, surtout sur des volumes de données importants, comme je l'ai montré ici, parce qu'elles ne sont pas appelées de façon ensembliste.

Enfin l'expression de cette requête, dès SQL Server 2005, ne requiert pas de fonction :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
SELECT		R.reservation_id
		, R.reservation_debut
		, R.reservation_fin
		, LEFT(S.liste_chambre_nom, LEN(S.liste_chambre_nom) - 1) AS liste_chambre_nom
FROM		dbo.concerne AS AS CN
INNER JOIN	dbo.resrvations AS R
			ON CN.reservation_id = R.reservation_id
CROSS APPLY	(
			SELECT	CH.chambre_nom + ', '
			FROM	dbo.chambres AS CH
			WHERE	CH.chambre_id = CN.chambre_id
			FOR	XML PATH('')
		) AS S (liste_chambre_nom)

Ceci sera bien plus rapide, si tant est que le code est correct parce que je n'ai pas de jeu de données

@++

[iberserk]

ne respecte même pas la première forme normale

Et même cette affirmation pourrait être âprement contestée...

Si fsmRel passe par là... :-)

[hmira]

C’est vrai que la solution proposée par Elsuket est plus élégante puisqu’elle permet d’éviter l’utilisation de la fonction scalaire externe. Merci Elsuket !

Ceci dit, et pour revenir au problème initial, personnellement, je suis très réticent pour ne pas dire contre ce genre de pratique qui consiste à concaténer les valeurs d’une colonne pour répondre à un souci de présentation. Pour moi, il n’est pas du rôle du SGBD d’effectuer ce travail ! cette tâche doit être dévolue à l’application (exemple Reporting Services Report Builder, Crystal Report etc..), la base de données se limitant à exposer de véritables relations.

Ce qui me gêne c’est d’une part, le fait que le résultat (ie concaténation des champs) doit être calculé lors de chaque utilisation, d’autre part, la relation obtenue (ou l’ensemble résultat obtenu) n’est pas en première forme normale puisque la valeur obtenue par concaténation, est sur le plan sémantique, n’est pas une valeur atomique. Je maintiens donc mes propos à propos de la première forme normale.

Je rappelle que l’algèbre relationnelle inventée par E Codd est une collection d’opérations formelles qui agissent sur les relations et produisent des relations en résultat. Et parmi ces opérations formelles il y a évidemment les opérations ensemblistes.

Pour moi, nombre d’opérations ensemblistes (l’union, la différence, le produit cartésien, la projection, la restriction, la jointure etc.), appliquées à l’ensemble des relations, doivent être considérées et perçues comme des "loi de composition interne".

PS : Si Monsieur fsmrel lit ce topic, je serais également ravi d’avoir son avis.

A+