En SQL SERVEUR 2000, est-il possible d'identifier une=20
erreur dans un bloc d'instruction sql, sans avoir besoin=20
apr=E8s chaques ordres sql de tester la variable @@error.
Peut =EAtre que la notion d'exception existe?=20
Comme cela si une exception est soulev=E9e, elle serait=20
trait=E9e dans un bloc E_ERROR qui rollbackerait le script.
Le sch=E9ma que j'aimerai suivre est le suivant :
BEGIN TRAN T
/*DEBUT CORPS DU SCRIPT SQL*/
INSERT....
ALTER PROCEDURE....
CREATE ...
/*FIN CORPS DU SCRIPT SQL*/
IF <ERREUR ou avertissement dans le script > GOTO E_ERROR
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Akram BEN AISSI
je me suis penché sur la question il y a quelques temps, et il semblerait que contrairement à Oracle, SQLServer n'intègre pas le concept d'exception.
Pour m'en sortir, j'ai du utiliser la préhistorique, mais néamoins utilie, intruction GOTO.
Ca fait bizarre, j'avais l'impression de code l'assembleur pafois.
En gros, j'avais ca:
BEGIN TRAN DELETE FROM bla WHERE blabla=1 IF @@ERROR <> 0 GOTO onError1 ... ....
onError1: ROLLBACK GOTO onEnd
onError2:
onEnd:
c'est crade, j'avoue, et c est prise de tête surtout
SSO wrote:
Bonjour,
En SQL SERVEUR 2000, est-il possible d'identifier une erreur dans un bloc d'instruction sql, sans avoir besoin après chaques ordres sql de tester la variable @@error. Peut être que la notion d'exception existe? Comme cela si une exception est soulevée, elle serait traitée dans un bloc E_ERROR qui rollbackerait le script.
Le schéma que j'aimerai suivre est le suivant :
BEGIN TRAN T
/*DEBUT CORPS DU SCRIPT SQL*/ INSERT.... ALTER PROCEDURE.... CREATE ... /*FIN CORPS DU SCRIPT SQL*/
IF <ERREUR ou avertissement dans le script > GOTO E_ERROR
COMMIT TRAN T
E_ERROR : ROLLBACK TRAN T
GO
Merci d'avance pour votre aide.
SSO
je me suis penché sur la question il y a quelques temps, et il
semblerait que contrairement à Oracle, SQLServer n'intègre pas le
concept d'exception.
Pour m'en sortir, j'ai du utiliser la préhistorique, mais néamoins
utilie, intruction GOTO.
Ca fait bizarre, j'avais l'impression de code l'assembleur pafois.
En gros, j'avais ca:
BEGIN TRAN
DELETE FROM bla WHERE blabla=1
IF @@ERROR <> 0 GOTO onError1
...
....
onError1:
ROLLBACK
GOTO onEnd
onError2:
onEnd:
c'est crade, j'avoue, et c est prise de tête surtout
SSO wrote:
Bonjour,
En SQL SERVEUR 2000, est-il possible d'identifier une
erreur dans un bloc d'instruction sql, sans avoir besoin
après chaques ordres sql de tester la variable @@error.
Peut être que la notion d'exception existe?
Comme cela si une exception est soulevée, elle serait
traitée dans un bloc E_ERROR qui rollbackerait le script.
Le schéma que j'aimerai suivre est le suivant :
BEGIN TRAN T
/*DEBUT CORPS DU SCRIPT SQL*/
INSERT....
ALTER PROCEDURE....
CREATE ...
/*FIN CORPS DU SCRIPT SQL*/
IF <ERREUR ou avertissement dans le script > GOTO E_ERROR
je me suis penché sur la question il y a quelques temps, et il semblerait que contrairement à Oracle, SQLServer n'intègre pas le concept d'exception.
Pour m'en sortir, j'ai du utiliser la préhistorique, mais néamoins utilie, intruction GOTO.
Ca fait bizarre, j'avais l'impression de code l'assembleur pafois.
En gros, j'avais ca:
BEGIN TRAN DELETE FROM bla WHERE blabla=1 IF @@ERROR <> 0 GOTO onError1 ... ....
onError1: ROLLBACK GOTO onEnd
onError2:
onEnd:
c'est crade, j'avoue, et c est prise de tête surtout
SSO wrote:
Bonjour,
En SQL SERVEUR 2000, est-il possible d'identifier une erreur dans un bloc d'instruction sql, sans avoir besoin après chaques ordres sql de tester la variable @@error. Peut être que la notion d'exception existe? Comme cela si une exception est soulevée, elle serait traitée dans un bloc E_ERROR qui rollbackerait le script.
Le schéma que j'aimerai suivre est le suivant :
BEGIN TRAN T
/*DEBUT CORPS DU SCRIPT SQL*/ INSERT.... ALTER PROCEDURE.... CREATE ... /*FIN CORPS DU SCRIPT SQL*/
IF <ERREUR ou avertissement dans le script > GOTO E_ERROR
COMMIT TRAN T
E_ERROR : ROLLBACK TRAN T
GO
Merci d'avance pour votre aide.
SSO
Patrice Scribe
Voir peut-être SET XACT_ABORT et http://www.algonet.se/~sommar/error-handling-II.html :
Tiré de la doc : "Lorsque SET XACT_ABORT est défini sur ON et si une instruction Transact-SQL génère une erreur d'exécution, l'ensemble de la transaction est terminée et annulée. Si l'option est désactivée, seule l'instruction Transact-SQL qui a généré l'erreur est annulée et le traitement de la transaction se poursuit. Les erreurs de compilation, comme les erreurs de syntaxe, ne sont pas affectées par l'option SET XACT_ABORT."
Le problème est de "récupérer" la main ensuite. Les "exceptions" seront disponibles dans la prochaine version.
Patrice --
"SSO" a écrit dans le message de news:4f5501c3e4bb$e283c690$ Bonjour,
En SQL SERVEUR 2000, est-il possible d'identifier une erreur dans un bloc d'instruction sql, sans avoir besoin après chaques ordres sql de tester la variable @@error. Peut être que la notion d'exception existe? Comme cela si une exception est soulevée, elle serait traitée dans un bloc E_ERROR qui rollbackerait le script.
Le schéma que j'aimerai suivre est le suivant :
BEGIN TRAN T
/*DEBUT CORPS DU SCRIPT SQL*/ INSERT.... ALTER PROCEDURE.... CREATE ... /*FIN CORPS DU SCRIPT SQL*/
IF <ERREUR ou avertissement dans le script > GOTO E_ERROR
COMMIT TRAN T
E_ERROR : ROLLBACK TRAN T
GO
Merci d'avance pour votre aide.
SSO
Voir peut-être SET XACT_ABORT et
http://www.algonet.se/~sommar/error-handling-II.html :
Tiré de la doc :
"Lorsque SET XACT_ABORT est défini sur ON et si une instruction Transact-SQL
génère une erreur d'exécution, l'ensemble de la transaction est terminée et
annulée. Si l'option est désactivée, seule l'instruction Transact-SQL qui a
généré l'erreur est annulée et le traitement de la transaction se poursuit.
Les erreurs de compilation, comme les erreurs de syntaxe, ne sont pas
affectées par l'option SET XACT_ABORT."
Le problème est de "récupérer" la main ensuite. Les "exceptions" seront
disponibles dans la prochaine version.
Patrice
--
"SSO" <anonymous@discussions.microsoft.com> a écrit dans le message de
news:4f5501c3e4bb$e283c690$a401280a@phx.gbl...
Bonjour,
En SQL SERVEUR 2000, est-il possible d'identifier une
erreur dans un bloc d'instruction sql, sans avoir besoin
après chaques ordres sql de tester la variable @@error.
Peut être que la notion d'exception existe?
Comme cela si une exception est soulevée, elle serait
traitée dans un bloc E_ERROR qui rollbackerait le script.
Le schéma que j'aimerai suivre est le suivant :
BEGIN TRAN T
/*DEBUT CORPS DU SCRIPT SQL*/
INSERT....
ALTER PROCEDURE....
CREATE ...
/*FIN CORPS DU SCRIPT SQL*/
IF <ERREUR ou avertissement dans le script > GOTO E_ERROR
Voir peut-être SET XACT_ABORT et http://www.algonet.se/~sommar/error-handling-II.html :
Tiré de la doc : "Lorsque SET XACT_ABORT est défini sur ON et si une instruction Transact-SQL génère une erreur d'exécution, l'ensemble de la transaction est terminée et annulée. Si l'option est désactivée, seule l'instruction Transact-SQL qui a généré l'erreur est annulée et le traitement de la transaction se poursuit. Les erreurs de compilation, comme les erreurs de syntaxe, ne sont pas affectées par l'option SET XACT_ABORT."
Le problème est de "récupérer" la main ensuite. Les "exceptions" seront disponibles dans la prochaine version.
Patrice --
"SSO" a écrit dans le message de news:4f5501c3e4bb$e283c690$ Bonjour,
En SQL SERVEUR 2000, est-il possible d'identifier une erreur dans un bloc d'instruction sql, sans avoir besoin après chaques ordres sql de tester la variable @@error. Peut être que la notion d'exception existe? Comme cela si une exception est soulevée, elle serait traitée dans un bloc E_ERROR qui rollbackerait le script.
Le schéma que j'aimerai suivre est le suivant :
BEGIN TRAN T
/*DEBUT CORPS DU SCRIPT SQL*/ INSERT.... ALTER PROCEDURE.... CREATE ... /*FIN CORPS DU SCRIPT SQL*/
IF <ERREUR ou avertissement dans le script > GOTO E_ERROR
COMMIT TRAN T
E_ERROR : ROLLBACK TRAN T
GO
Merci d'avance pour votre aide.
SSO
SSO
Merci à toi! c'est exactement ce qu'il me fallait.
-----Message d'origine----- Voir peut-être SET XACT_ABORT et http://www.algonet.se/~sommar/error-handling-II.html :
Tiré de la doc : "Lorsque SET XACT_ABORT est défini sur ON et si une
instruction Transact-SQL
génère une erreur d'exécution, l'ensemble de la
transaction est terminée et
annulée. Si l'option est désactivée, seule l'instruction
Transact-SQL qui a
généré l'erreur est annulée et le traitement de la
transaction se poursuit.
Les erreurs de compilation, comme les erreurs de syntaxe,
ne sont pas
affectées par l'option SET XACT_ABORT."
Le problème est de "récupérer" la main ensuite.
Les "exceptions" seront
disponibles dans la prochaine version.
Patrice --
"SSO" a écrit dans
le message de
news:4f5501c3e4bb$e283c690$ Bonjour,
En SQL SERVEUR 2000, est-il possible d'identifier une erreur dans un bloc d'instruction sql, sans avoir besoin après chaques ordres sql de tester la variable @@error. Peut être que la notion d'exception existe? Comme cela si une exception est soulevée, elle serait traitée dans un bloc E_ERROR qui rollbackerait le script.
Le schéma que j'aimerai suivre est le suivant :
BEGIN TRAN T
/*DEBUT CORPS DU SCRIPT SQL*/ INSERT.... ALTER PROCEDURE.... CREATE ... /*FIN CORPS DU SCRIPT SQL*/
IF <ERREUR ou avertissement dans le script > GOTO E_ERROR
COMMIT TRAN T
E_ERROR : ROLLBACK TRAN T
GO
Merci d'avance pour votre aide.
SSO
.
Merci à toi!
c'est exactement ce qu'il me fallait.
-----Message d'origine-----
Voir peut-être SET XACT_ABORT et
http://www.algonet.se/~sommar/error-handling-II.html :
Tiré de la doc :
"Lorsque SET XACT_ABORT est défini sur ON et si une
instruction Transact-SQL
génère une erreur d'exécution, l'ensemble de la
transaction est terminée et
annulée. Si l'option est désactivée, seule l'instruction
Transact-SQL qui a
généré l'erreur est annulée et le traitement de la
transaction se poursuit.
Les erreurs de compilation, comme les erreurs de syntaxe,
ne sont pas
affectées par l'option SET XACT_ABORT."
Le problème est de "récupérer" la main ensuite.
Les "exceptions" seront
disponibles dans la prochaine version.
Patrice
--
"SSO" <anonymous@discussions.microsoft.com> a écrit dans
En SQL SERVEUR 2000, est-il possible d'identifier une
erreur dans un bloc d'instruction sql, sans avoir besoin
après chaques ordres sql de tester la variable @@error.
Peut être que la notion d'exception existe?
Comme cela si une exception est soulevée, elle serait
traitée dans un bloc E_ERROR qui rollbackerait le script.
Le schéma que j'aimerai suivre est le suivant :
BEGIN TRAN T
/*DEBUT CORPS DU SCRIPT SQL*/
INSERT....
ALTER PROCEDURE....
CREATE ...
/*FIN CORPS DU SCRIPT SQL*/
IF <ERREUR ou avertissement dans le script > GOTO E_ERROR
Merci à toi! c'est exactement ce qu'il me fallait.
-----Message d'origine----- Voir peut-être SET XACT_ABORT et http://www.algonet.se/~sommar/error-handling-II.html :
Tiré de la doc : "Lorsque SET XACT_ABORT est défini sur ON et si une
instruction Transact-SQL
génère une erreur d'exécution, l'ensemble de la
transaction est terminée et
annulée. Si l'option est désactivée, seule l'instruction
Transact-SQL qui a
généré l'erreur est annulée et le traitement de la
transaction se poursuit.
Les erreurs de compilation, comme les erreurs de syntaxe,
ne sont pas
affectées par l'option SET XACT_ABORT."
Le problème est de "récupérer" la main ensuite.
Les "exceptions" seront
disponibles dans la prochaine version.
Patrice --
"SSO" a écrit dans
le message de
news:4f5501c3e4bb$e283c690$ Bonjour,
En SQL SERVEUR 2000, est-il possible d'identifier une erreur dans un bloc d'instruction sql, sans avoir besoin après chaques ordres sql de tester la variable @@error. Peut être que la notion d'exception existe? Comme cela si une exception est soulevée, elle serait traitée dans un bloc E_ERROR qui rollbackerait le script.
Le schéma que j'aimerai suivre est le suivant :
BEGIN TRAN T
/*DEBUT CORPS DU SCRIPT SQL*/ INSERT.... ALTER PROCEDURE.... CREATE ... /*FIN CORPS DU SCRIPT SQL*/
IF <ERREUR ou avertissement dans le script > GOTO E_ERROR
