Je recherche un best practice pour gérer des valeurs d'enum dans du code
T-SQL.
Dans les nombreuses sp, je ne souhaite pas utiliser des valeurs en dur, et
je ne souhaite pas faire référence à du code CLR pour piocher des valeurs.
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
Gislain
Pour info, je travaille avec un serveur SQL 2005.
"Gislain" wrote in message news:
Bonjour,
Je recherche un best practice pour gérer des valeurs d'enum dans du code T-SQL. Dans les nombreuses sp, je ne souhaite pas utiliser des valeurs en dur, et je ne souhaite pas faire référence à du code CLR pour piocher des valeurs.
Qui à déjà trouvé la formule magique ?
Merci d'avance.
Gislain
Pour info, je travaille avec un serveur SQL 2005.
"Gislain" <nospam@nospam.com> wrote in message
news:uvKzMbmfGHA.4776@TK2MSFTNGP05.phx.gbl...
Bonjour,
Je recherche un best practice pour gérer des valeurs d'enum dans du code
T-SQL.
Dans les nombreuses sp, je ne souhaite pas utiliser des valeurs en dur, et
je ne souhaite pas faire référence à du code CLR pour piocher des valeurs.
Je recherche un best practice pour gérer des valeurs d'enum dans du code T-SQL. Dans les nombreuses sp, je ne souhaite pas utiliser des valeurs en dur, et je ne souhaite pas faire référence à du code CLR pour piocher des valeurs.
Qui à déjà trouvé la formule magique ?
Merci d'avance.
Gislain
Rudi Bruchez
Gislain a écrit:
Bonjour,
Je recherche un best practice pour gérer des valeurs d'enum dans du code T-SQL. Dans les nombreuses sp, je ne souhaite pas utiliser des valeurs en dur, et je ne souhaite pas faire référence à du code CLR pour piocher des valeurs.
Qui à déjà trouvé la formule magique ?
Merci d'avance.
Gislain
Bonjour,
tu peux utiliser simplement une table de référence, non ? Pour gérer tes valeurs, si tu as besoin de plusieurs états, tu peux utiliser un masque de bits dans une colonne int, et la tester/modifier avec les opérateurs bitwise de SQL Server : & et | notamment.
-- Rudi Bruchez, MCDBA http://www.babaluga.com/
Gislain a écrit:
Bonjour,
Je recherche un best practice pour gérer des valeurs d'enum dans du code
T-SQL.
Dans les nombreuses sp, je ne souhaite pas utiliser des valeurs en dur, et
je ne souhaite pas faire référence à du code CLR pour piocher des valeurs.
Qui à déjà trouvé la formule magique ?
Merci d'avance.
Gislain
Bonjour,
tu peux utiliser simplement une table de référence, non ?
Pour gérer tes valeurs, si tu as besoin de plusieurs états, tu peux
utiliser un masque de bits dans une colonne int, et la tester/modifier avec
les opérateurs bitwise de SQL Server : & et | notamment.
Je recherche un best practice pour gérer des valeurs d'enum dans du code T-SQL. Dans les nombreuses sp, je ne souhaite pas utiliser des valeurs en dur, et je ne souhaite pas faire référence à du code CLR pour piocher des valeurs.
Qui à déjà trouvé la formule magique ?
Merci d'avance.
Gislain
Bonjour,
tu peux utiliser simplement une table de référence, non ? Pour gérer tes valeurs, si tu as besoin de plusieurs états, tu peux utiliser un masque de bits dans une colonne int, et la tester/modifier avec les opérateurs bitwise de SQL Server : & et | notamment.
-- Rudi Bruchez, MCDBA http://www.babaluga.com/
SQLpro [MVP]
Gislain a écrit :
Bonjour,
Je recherche un best practice pour gérer des valeurs d'enum dans du code T-SQL.
Dans les nombreuses sp, je ne souhaite pas utiliser des valeurs en dur, et je ne souhaite pas faire référence à du code CLR pour piocher des valeurs.
Qui à déjà trouvé la formule magique ?
Merci d'avance.
Gislain
-- Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com Audit, conseil, expertise, formation, modélisation, tuning, optimisation ********************* http://www.datasapiens.com ***********************
Gislain a écrit :
Bonjour,
Je recherche un best practice pour gérer des valeurs d'enum dans du code
T-SQL.
Dans les nombreuses sp, je ne souhaite pas utiliser des valeurs en dur, et
je ne souhaite pas faire référence à du code CLR pour piocher des valeurs.
Qui à déjà trouvé la formule magique ?
Merci d'avance.
Gislain
--
Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL
Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com
Audit, conseil, expertise, formation, modélisation, tuning, optimisation
********************* http://www.datasapiens.com ***********************
Dans les nombreuses sp, je ne souhaite pas utiliser des valeurs en dur, et je ne souhaite pas faire référence à du code CLR pour piocher des valeurs.
Qui à déjà trouvé la formule magique ?
Merci d'avance.
Gislain
-- Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com Audit, conseil, expertise, formation, modélisation, tuning, optimisation ********************* http://www.datasapiens.com ***********************
Gislain
Bonjour,
Alors pour être plus précis... Dans mes procédures stockées, je dois passer des paramètres "int" dont la plage de valeur est définie par un ENUM en C#.
On peut donc travailler de la sorte en C# public enum MyEnumData { Local = 0, Display = 1 }
On peut donc travailler de la sorte en T-SQL DECLARE @my_var as nvarchar(10) SET @my_var = 'toto' EXEC usp_my_proc @my_var, 1
Le problème de cette solution est difficilement maintenable. Lors du développement des procédures T-SQL, il me faut avoir à coté de moi une table des valeurs de toutes mes enum.
Une solution envisagée était de passer par une variable pour retrouver facilement une info, mais il faut toujours que le développeur connaisse la valeur de l'énum. DECLARE @my_var as nvarchar(10) DECLARE @CST_MyEnumData_Display as int SET @my_var = 'toto' SET @CST_MyEnumData_Display = 1 EXEC usp_my_proc @my_var, @CST_MyEnumData_Display
C'est aujourd'hui la solution que j'utilise, mais cela nécessite dans une équipe de développeur d'avoir à gérer des conventions de nommage si l'on veut retrouver l'ensemble des endroits où est utilisé MyEnumData.
Donc, avez vous une solution élégante, évolutive, facile à implémenter, en un mot : idéale !!!
Remarque : Pour la solution, je ne souhaite pas intégrer du code CLR.
Merci d'avance
Gislain
"SQLpro [MVP]" wrote in message news:%
Gislain a écrit :
Bonjour,
Je recherche un best practice pour gérer des valeurs d'enum dans du code T-SQL.
Dans les nombreuses sp, je ne souhaite pas utiliser des valeurs en dur, et je ne souhaite pas faire référence à du code CLR pour piocher des valeurs.
Qui à déjà trouvé la formule magique ?
Merci d'avance.
Gislain
-- Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com Audit, conseil, expertise, formation, modélisation, tuning, optimisation ********************* http://www.datasapiens.com ***********************
Bonjour,
Alors pour être plus précis...
Dans mes procédures stockées, je dois passer des paramètres "int" dont la
plage de valeur est définie par un ENUM en C#.
On peut donc travailler de la sorte en C#
public enum MyEnumData
{
Local = 0,
Display = 1
}
On peut donc travailler de la sorte en T-SQL
DECLARE @my_var as nvarchar(10)
SET @my_var = 'toto'
EXEC usp_my_proc @my_var, 1
Le problème de cette solution est difficilement maintenable. Lors du
développement des procédures T-SQL, il me faut avoir à coté de moi une table
des valeurs de toutes mes enum.
Une solution envisagée était de passer par une variable pour retrouver
facilement une info, mais il faut toujours que le développeur connaisse la
valeur de l'énum.
DECLARE @my_var as nvarchar(10)
DECLARE @CST_MyEnumData_Display as int
SET @my_var = 'toto'
SET @CST_MyEnumData_Display = 1
EXEC usp_my_proc @my_var, @CST_MyEnumData_Display
C'est aujourd'hui la solution que j'utilise, mais cela nécessite dans une
équipe de développeur d'avoir à gérer des conventions de nommage si l'on
veut retrouver l'ensemble des endroits où est utilisé MyEnumData.
Donc, avez vous une solution élégante, évolutive, facile à implémenter, en
un mot : idéale !!!
Remarque : Pour la solution, je ne souhaite pas intégrer du code CLR.
Merci d'avance
Gislain
"SQLpro [MVP]" <brouardf@club-internet.fr> wrote in message
news:%23dLgoKnfGHA.1320@TK2MSFTNGP04.phx.gbl...
Gislain a écrit :
Bonjour,
Je recherche un best practice pour gérer des valeurs d'enum dans du code
T-SQL.
Dans les nombreuses sp, je ne souhaite pas utiliser des valeurs en dur,
et je ne souhaite pas faire référence à du code CLR pour piocher des
valeurs.
Qui à déjà trouvé la formule magique ?
Merci d'avance.
Gislain
--
Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL
Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com
Audit, conseil, expertise, formation, modélisation, tuning, optimisation
********************* http://www.datasapiens.com ***********************
Alors pour être plus précis... Dans mes procédures stockées, je dois passer des paramètres "int" dont la plage de valeur est définie par un ENUM en C#.
On peut donc travailler de la sorte en C# public enum MyEnumData { Local = 0, Display = 1 }
On peut donc travailler de la sorte en T-SQL DECLARE @my_var as nvarchar(10) SET @my_var = 'toto' EXEC usp_my_proc @my_var, 1
Le problème de cette solution est difficilement maintenable. Lors du développement des procédures T-SQL, il me faut avoir à coté de moi une table des valeurs de toutes mes enum.
Une solution envisagée était de passer par une variable pour retrouver facilement une info, mais il faut toujours que le développeur connaisse la valeur de l'énum. DECLARE @my_var as nvarchar(10) DECLARE @CST_MyEnumData_Display as int SET @my_var = 'toto' SET @CST_MyEnumData_Display = 1 EXEC usp_my_proc @my_var, @CST_MyEnumData_Display
C'est aujourd'hui la solution que j'utilise, mais cela nécessite dans une équipe de développeur d'avoir à gérer des conventions de nommage si l'on veut retrouver l'ensemble des endroits où est utilisé MyEnumData.
Donc, avez vous une solution élégante, évolutive, facile à implémenter, en un mot : idéale !!!
Remarque : Pour la solution, je ne souhaite pas intégrer du code CLR.
Merci d'avance
Gislain
"SQLpro [MVP]" wrote in message news:%
Gislain a écrit :
Bonjour,
Je recherche un best practice pour gérer des valeurs d'enum dans du code T-SQL.
Dans les nombreuses sp, je ne souhaite pas utiliser des valeurs en dur, et je ne souhaite pas faire référence à du code CLR pour piocher des valeurs.
Qui à déjà trouvé la formule magique ?
Merci d'avance.
Gislain
-- Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com Audit, conseil, expertise, formation, modélisation, tuning, optimisation ********************* http://www.datasapiens.com ***********************
SQLpro [MVP]
Excusez moi, mais je ne suis pas familiarisé avec les enum de C#... De manière CONCRETE quel est votre problème ???
A +
Gislain a écrit :
Bonjour,
Alors pour être plus précis... Dans mes procédures stockées, je dois passer des paramètres "int" dont la plage de valeur est définie par un ENUM en C#.
On peut donc travailler de la sorte en C# public enum MyEnumData { Local = 0, Display = 1 }
On peut donc travailler de la sorte en T-SQL DECLARE @my_var as nvarchar(10) SET @my_var = 'toto' EXEC usp_my_proc @my_var, 1
Le problème de cette solution est difficilement maintenable. Lors du développement des procédures T-SQL, il me faut avoir à coté de moi une table des valeurs de toutes mes enum.
Une solution envisagée était de passer par une variable pour retrouver facilement une info, mais il faut toujours que le développeur connaisse la valeur de l'énum. DECLARE @my_var as nvarchar(10) DECLARE @CST_MyEnumData_Display as int SET @my_var = 'toto' SET @CST_MyEnumData_Display = 1 EXEC usp_my_proc @my_var, @CST_MyEnumData_Display
C'est aujourd'hui la solution que j'utilise, mais cela nécessite dans une équipe de développeur d'avoir à gérer des conventions de nommage si l'on veut retrouver l'ensemble des endroits où est utilisé MyEnumData.
Donc, avez vous une solution élégante, évolutive, facile à implémenter, en un mot : idéale !!!
Remarque : Pour la solution, je ne souhaite pas intégrer du code CLR.
Merci d'avance
Gislain
"SQLpro [MVP]" wrote in message news:%
Gislain a écrit :
Bonjour,
Je recherche un best practice pour gérer des valeurs d'enum dans du code T-SQL.
Dans les nombreuses sp, je ne souhaite pas utiliser des valeurs en dur, et je ne souhaite pas faire référence à du code CLR pour piocher des valeurs.
Qui à déjà trouvé la formule magique ?
Merci d'avance.
Gislain
-- Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com Audit, conseil, expertise, formation, modélisation, tuning, optimisation ********************* http://www.datasapiens.com ***********************
-- Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com Audit, conseil, expertise, formation, modélisation, tuning, optimisation ********************* http://www.datasapiens.com ***********************
Excusez moi, mais je ne suis pas familiarisé avec les enum de C#... De
manière CONCRETE quel est votre problème ???
A +
Gislain a écrit :
Bonjour,
Alors pour être plus précis...
Dans mes procédures stockées, je dois passer des paramètres "int" dont la
plage de valeur est définie par un ENUM en C#.
On peut donc travailler de la sorte en C#
public enum MyEnumData
{
Local = 0,
Display = 1
}
On peut donc travailler de la sorte en T-SQL
DECLARE @my_var as nvarchar(10)
SET @my_var = 'toto'
EXEC usp_my_proc @my_var, 1
Le problème de cette solution est difficilement maintenable. Lors du
développement des procédures T-SQL, il me faut avoir à coté de moi une table
des valeurs de toutes mes enum.
Une solution envisagée était de passer par une variable pour retrouver
facilement une info, mais il faut toujours que le développeur connaisse la
valeur de l'énum.
DECLARE @my_var as nvarchar(10)
DECLARE @CST_MyEnumData_Display as int
SET @my_var = 'toto'
SET @CST_MyEnumData_Display = 1
EXEC usp_my_proc @my_var, @CST_MyEnumData_Display
C'est aujourd'hui la solution que j'utilise, mais cela nécessite dans une
équipe de développeur d'avoir à gérer des conventions de nommage si l'on
veut retrouver l'ensemble des endroits où est utilisé MyEnumData.
Donc, avez vous une solution élégante, évolutive, facile à implémenter, en
un mot : idéale !!!
Remarque : Pour la solution, je ne souhaite pas intégrer du code CLR.
Merci d'avance
Gislain
"SQLpro [MVP]" <brouardf@club-internet.fr> wrote in message
news:%23dLgoKnfGHA.1320@TK2MSFTNGP04.phx.gbl...
Gislain a écrit :
Bonjour,
Je recherche un best practice pour gérer des valeurs d'enum dans du code
T-SQL.
Dans les nombreuses sp, je ne souhaite pas utiliser des valeurs en dur,
et je ne souhaite pas faire référence à du code CLR pour piocher des
valeurs.
Qui à déjà trouvé la formule magique ?
Merci d'avance.
Gislain
--
Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL
Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com
Audit, conseil, expertise, formation, modélisation, tuning, optimisation
********************* http://www.datasapiens.com ***********************
--
Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL
Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com
Audit, conseil, expertise, formation, modélisation, tuning, optimisation
********************* http://www.datasapiens.com ***********************
Excusez moi, mais je ne suis pas familiarisé avec les enum de C#... De manière CONCRETE quel est votre problème ???
A +
Gislain a écrit :
Bonjour,
Alors pour être plus précis... Dans mes procédures stockées, je dois passer des paramètres "int" dont la plage de valeur est définie par un ENUM en C#.
On peut donc travailler de la sorte en C# public enum MyEnumData { Local = 0, Display = 1 }
On peut donc travailler de la sorte en T-SQL DECLARE @my_var as nvarchar(10) SET @my_var = 'toto' EXEC usp_my_proc @my_var, 1
Le problème de cette solution est difficilement maintenable. Lors du développement des procédures T-SQL, il me faut avoir à coté de moi une table des valeurs de toutes mes enum.
Une solution envisagée était de passer par une variable pour retrouver facilement une info, mais il faut toujours que le développeur connaisse la valeur de l'énum. DECLARE @my_var as nvarchar(10) DECLARE @CST_MyEnumData_Display as int SET @my_var = 'toto' SET @CST_MyEnumData_Display = 1 EXEC usp_my_proc @my_var, @CST_MyEnumData_Display
C'est aujourd'hui la solution que j'utilise, mais cela nécessite dans une équipe de développeur d'avoir à gérer des conventions de nommage si l'on veut retrouver l'ensemble des endroits où est utilisé MyEnumData.
Donc, avez vous une solution élégante, évolutive, facile à implémenter, en un mot : idéale !!!
Remarque : Pour la solution, je ne souhaite pas intégrer du code CLR.
Merci d'avance
Gislain
"SQLpro [MVP]" wrote in message news:%
Gislain a écrit :
Bonjour,
Je recherche un best practice pour gérer des valeurs d'enum dans du code T-SQL.
Dans les nombreuses sp, je ne souhaite pas utiliser des valeurs en dur, et je ne souhaite pas faire référence à du code CLR pour piocher des valeurs.
Qui à déjà trouvé la formule magique ?
Merci d'avance.
Gislain
-- Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com Audit, conseil, expertise, formation, modélisation, tuning, optimisation ********************* http://www.datasapiens.com ***********************
-- Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com Audit, conseil, expertise, formation, modélisation, tuning, optimisation ********************* http://www.datasapiens.com ***********************
Rudi Bruchez
Gislain a écrit:
C'est aujourd'hui la solution que j'utilise, mais cela nécessite dans une équipe de développeur d'avoir à gérer des conventions de nommage si l'on veut retrouver l'ensemble des endroits où est utilisé MyEnumData.
Bonjour,
Une suggestion : vous essayez de stocker des valeurs dans votre code client, et de retrouver leur sens dans le code appelé dans SQL Server. Pourquoi ne pas maintenir vos tables de référence dans SQL server, les charger au lancement de votre exécutable (éventuellement en utilisant Notification Services pour avertir votre appli que la table a été modifiée, mais bon, si vous compilez votre code avec vos enum, ça ne doit pas changer bien souvent...), dans des resultsets, des tableaux, des collections d'objets..., et gérer vos requêtes à l'aide de vos tables de référence?
A moins que vous utilisiez ces enum pour faire du code conditionnel dans vos sprocs, auquel cas, il y a peut-être un redesign à faire dans le code T-SQL. Il n'est pas si mauvais de créer plusieurs sprocs selon les cas, notamment pour des raisons de performance.
-- Rudi Bruchez, MCDBA http://www.babaluga.com/
Gislain a écrit:
C'est aujourd'hui la solution que j'utilise, mais cela nécessite dans une
équipe de développeur d'avoir à gérer des conventions de nommage si l'on
veut retrouver l'ensemble des endroits où est utilisé MyEnumData.
Bonjour,
Une suggestion : vous essayez de stocker des valeurs dans votre code
client, et de retrouver leur sens dans le code appelé dans SQL Server.
Pourquoi ne pas maintenir vos tables de référence dans SQL server, les
charger au lancement de votre exécutable (éventuellement en utilisant
Notification Services pour avertir votre appli que la table a été modifiée,
mais bon, si vous compilez votre code avec vos enum, ça ne doit pas changer
bien souvent...), dans des resultsets, des tableaux, des collections
d'objets..., et gérer vos requêtes à l'aide de vos tables de référence?
A moins que vous utilisiez ces enum pour faire du code conditionnel dans
vos sprocs, auquel cas, il y a peut-être un redesign à faire dans le code
T-SQL. Il n'est pas si mauvais de créer plusieurs sprocs selon les cas,
notamment pour des raisons de performance.
C'est aujourd'hui la solution que j'utilise, mais cela nécessite dans une équipe de développeur d'avoir à gérer des conventions de nommage si l'on veut retrouver l'ensemble des endroits où est utilisé MyEnumData.
Bonjour,
Une suggestion : vous essayez de stocker des valeurs dans votre code client, et de retrouver leur sens dans le code appelé dans SQL Server. Pourquoi ne pas maintenir vos tables de référence dans SQL server, les charger au lancement de votre exécutable (éventuellement en utilisant Notification Services pour avertir votre appli que la table a été modifiée, mais bon, si vous compilez votre code avec vos enum, ça ne doit pas changer bien souvent...), dans des resultsets, des tableaux, des collections d'objets..., et gérer vos requêtes à l'aide de vos tables de référence?
A moins que vous utilisiez ces enum pour faire du code conditionnel dans vos sprocs, auquel cas, il y a peut-être un redesign à faire dans le code T-SQL. Il n'est pas si mauvais de créer plusieurs sprocs selon les cas, notamment pour des raisons de performance.
