Discussion :

[elsuket]

Bonjour,

Je ne comprend pas pourquoi, lorsqu'on dépile la cible pour traiter les messages avec un procédure stockée, on doit écrire un WHILE (1 = 1) avant de démarrer la transaction de lecture du message.

Lorsque le STATUS de la clause ACTIVATION est à ON, c'est Service Broker qui exécute la procédure stockée.

Le fait d'écrire WHILE(1 =1) signifie-t-il que la procédure stockée n'est exécutée qu'une seule fois, plutôt qu'à l'arrivée de chaque message ?
Dans le second cas, qu'est-ce qui explique ce choix ?

Merci pour vos réponses,

@++

[mikedavem]

Lut

Je ne suis pas expert en service broker mais à ce que j'ai compris .. lorsqu'on veut lire un ou plusieurs messages (et qu'on le dépile de la file d'attente donc) on traite les messages avec l'instruction RECEIVE TOP(XXX) ..

Je pense que le while 1 = 1 te permet de lancer une boucle permanente de traitement des messages.

++

[elsuket]

Salut

Voilà ce que j'ai :

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
	WHILE (1 = 1) -- Process all the messages received by the queue
	BEGIN
		BEGIN TRY
			BEGIN TRANSACTION
				WAITFOR
				(
					RECEIVE	TOP (1)	@conversation_handle = conversation_handle
							, @message_body = CAST(message_body AS xml(gcsTest))
					FROM		dbo.queue_gcsTest
				)
 
				IF @@rowcount > 0
				BEGIN
					ROLLBACK TRANSACTION
					BREAK
				END
				ELSE
				BEGIN ...

Je vois le WHILE (1 = 1) dans tous les exemples que je trouve, donc cela signifie que la procédure stockée que l'on spécifie pour le traitement de la pile n'est exécutée qu'un seule fois par autant de queue_readers que l'on spécifie dans la clause d'activation de la pile.

Cela explique d'ailleurs le test sur @@rowcount, mais là encore je ne comprend pas pourquoi il est nécessaire d'encapsuler tout cela dans une transaction ...

@++

[mikedavem]

Dans ton cas je ne vois pas pourquoi ...

En général on recoit un message, on le traite et on envoie un autre message ... Dans ce cas la transaction est utile si erreur il y a ...

La on traite les données dans la file d'attente et si aucun message n'est recupéré , on annule une transaction initiée .. Je ne vois pas trop l'intérêt

++

[elsuket]

Du coup, j'ai terminé comme suit :

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
24
25
26
27
ALTER PROCEDURE spSB_get_patient_from_queue
AS
BEGIN
	SET NOCOUNT ON
 
	DECLARE @conversation_handle uniqueidentifier
		, @message_body xml(monSchemaXML)
 
	WHILE (1 = 1) -- Process all the messages received by the queue
	BEGIN
		WAITFOR
		(
			RECEIVE	TOP (1)	@conversation_handle = conversation_handle
					, @message_body = CAST(message_body AS xml(monSchemaXML))
			FROM		dbo.maPile
		)
 
		IF @@rowcount > 0
		BEGIN
			INSERT	INTO dbo.maTable
			...
			FROM	@message_body.nodes('/node') AS MB(c)
		END
 
		END CONVERSATION @conversation_handle
END
GO

Ché pas ce que tu en penses

@++

[mikedavem]

Moi je ferais quelque chose dans le genre :

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
24
25
26
27
28
29
30
31
32
33
ALTER PROCEDURE spSB_get_patient_from_queue
AS
BEGIN
	SET NOCOUNT ON
 
	DECLARE @conversation_handle uniqueidentifier
		, @message_body xml(monSchemaXML)
 
	WHILE (1 = 1) -- Process all the messages received by the queue
	BEGIN
		-- Début transaction
		BEGIN TRANSACTION;
 
		WAITFOR
		(
			RECEIVE	TOP (1)	@conversation_handle = conversation_handle
					, @message_body = CAST(message_body AS xml(monSchemaXML))
			FROM		dbo.maPile
		) -- TIMEOUT 6000 --> attente 6s
 
		IF @@ROWCOUNT > 0
		BEGIN
			INSERT	INTO dbo.maTable
			...
			FROM	@message_body.nodes('/node') AS MB(c)
		END
 
		END CONVERSATION @conversation_handle
 
		-- Validation transaction
		COMMIT TRANSACTION;
END
GO

J'encapsulerais le tout dans une transaction .. Si jamais tu as un problème tu ne perds pas ton message dans la file d'attente.

Tu peux mettre également un TIMEOUT avec WAIT FOR pour ne pas attendre indéfiniment ... Ensuite si tu n'as aucun message tu ne fais rien (avec ton @@ROWCOUNT)

Je n'ai pas implémenté la partie traitement en cas d'erreur dans le code .. tu ne m'en voudras pas

++

[SQLpro]

C'est une boucle d'écoute. Une boucle d'écoute tourne indéfiniment !

A +

[elsuket]

D'accord, mais je n'ai rien vu dans la documentation qui le spécifie aussi simplement que toi
En effet pour l'option PROCEDURE_NAME de l'instruction CREATE QUEUE, nous avons :

Spécifie le nom de la procédure stockée à démarrer pour traiter les messages dans cette file d'attente

Et en fouillant un peu, on trouve :

Un moniteur de file d'attente vérifie toutes les deux ou trois secondes si l'activation est nécessaire et également lorsqu'un ou plusieurs des événements suivants se produisent :

* Un nouveau message arrive dans la file d'attente.

Ce qui m'a laissé penser que la procédure stockée était exécutée pour chaque message entrant dans la pile.

Je reviens sur la clause TIMEOUT de l'instruction WAITFOR.
Là encore, la documentation :

Spécifie la période de temps, en millisecondes, pendant laquelle un message peut rejoindre la file d'attente.

Et dans la documentation de RECEIVE :

Si cette clause n'est pas spécifiée ou si le délai d'expiration a la valeur -1, le délai d'attente est illimité

Tout cela est un peu obscur ... d'un côté, on comprendrai que la procédure stockée se déclenche à l'arrivée de tout message, donc on n'aurait besoin ni de WHILE, ni de TIMEOUT.
Et d'un autre côté, on voit que si on n'utilise pas ces deux derniers, on s'expose à quelques problèmes.

Pourriez-vous m'éclairer là-dessus ?

@++

[mikedavem]

Je pense que la définition du TIMEOUT est plus juste dans la documentation de l'instruction RECEIVE que tu as cité :

Indique le temps, en millisecondes, pendant lequel l'instruction attend un message. Cette clause ne peut être utilisée qu'avec la clause WAITFOR....

Maintenant, comme l'a précisé SQLPro dans ton cas tu es dans une boucle d'écoute ... (donc une boucle infinie est lancée ...) mais il me semble que tu peux tout à fait lancer une procédure stockée de traitement sur l'arrivée des messages dans la file d'attente que tu auras créé. (CREATE QUEUE + procédure à lancer + éventuellement le paramètre MAX_QUEUE_READER à initier).

Tu n'auras donc qu'à créer une procédure spécifique de traitement avec l'instruction RECEIVE sans WAITFOR ... et l'implémenter dans la file d'attente créée par la suite.

++