Devrais-je utiliser le type de données SQL_Variant?

à l'aide de SQL Server 2005 service pack 4 et je suis en train de concevoir une table de base de données.

Voici le tableau DDL

CREATE TABLE CPSync4D.ProjectProfilerOption
(
    ProjectProfilerOptionID     INT  IDENTITY(1,1) CONSTRAINT PK_ProjectProfilerOption_ProjectProfilerOptionID PRIMARY KEY 
   ,ProjectID                   INT  CONSTRAINT FK_ProjectProfilerOption_Project_ProjectID FOREIGN KEY(ProjectID) REFERENCES CPSync4D.Project(ProjectID) ON DELETE CASCADE
   ,ProfilerOptionID            TINYINT CONSTRAINT FK_ProjectProfilerOption_ProfilerOption_ProfilerOptionID  FOREIGN KEY(ProfilerOptionID) REFERENCES CPSync4D.ProfilerOption (ProfilerOptionID) 
   ,ProfilerOptionValue         sql_variant  NOT NULL   

)
Go

profileroptionvalue colonne peut contenir une chaîne de caractères jusqu'à 30 caractères, entier ou décimal des valeurs par exemple, les valeurs sont "ProfilerValueType", ou 12.52 ou 20, etc. (pas plus de deux décimales et les valeurs entières sont à moins de 100)

Dois-je utiliser sql_variant ou varchar(30)...? Je n'ai jamais utilisé sql_variant avant et de ne pas s'assurer de l'implication de ne pas utiliser en termes de conception de base de données.

Tout pièges de l'utilisation sql_variant...avec .net code

InformationsquelleAutor SQL Learner | 2012-01-27

19

10 raisons de convertir explicitement les types de données SQL Server
En règle générale, vous devriez éviter d'utiliser SQL Server sql_variant
type de données. En plus d'être un dévoreur de mémoire, sql_variant est limitée:
- Variantes peuvent pas faire partie d'un primaire ou une clé étrangère. (ce qui n'est pas de SQL Server 2005. Voir mise à jour ci-dessous)
- Variantes peuvent pas faire partie d'une colonne calculée.
- Variantes ne fonctionne pas avec les tiens dans une clause where.
- OLE DB et ODBC fournisseurs de convertir automatiquement des variantes de type nvarchar(4000) — aïe!
Pour éviter les problèmes, toujours explicitement convertir des types de données sql_variant
vous les utilisez. Utiliser n'importe quelle méthode vous s'il vous plaît, il suffit de ne pas essayer de travailler avec
un inconverti type de données sql_variant.
Je n'ai pas utilisé sql_variant avant, mais avec ces restrictions et les conséquences de performance à l'esprit, je voudrais tout d'abord chercher d'autres solutions.

Suivante serait pour moi la plus à la moins préférée solution
- Il suffit de créer trois colonnes différentes. 3 Différents types de données (devrait) moyenne de 3 différentes façons de les interpréter à la fois côté client et côté serveur.
- Si ce n'est pas une option, utilisez un VARCHAR colonne de sorte que vous pouvez au moins utiliser LIKE consolidés.
- Utiliser le sql_variant type de données.
Modifier Duco à ta.speot.est

Variantes peut sera le cadre d'une primaire de clé étrangère

Unique, primaire, ou une clé étrangère peut inclure des colonnes de type
sql_variant, mais la longueur totale des valeurs de données qui composent le
la clé d'une ligne spécifique ne doit pas dépasser la longueur maximale d'un
index. C'est de 900 octets
- Les deux premières raisons ne sont pas vraies en tant que de SQL 2012. Cela fonctionne bien: declare @t de la table de(k1 sql_variant clé primaire, que k1 k2) insérer @t values('aaa') select * from @t
- En règle générale, vous devez toujours être très méfiant de toute explication qui commence par "en règle générale". 😉 Et, non... c'est pas un dévoreur de mémoire, surtout lorsque vous l'utilisez pour remplacer 3 colonnes avec différents types de données comme vous l'avez suggéré. Il est également juste un peu plus rapide qu'en passant par VARCHAR conversions. Il y a une tonne de bons usages pour elle, ainsi. C'est juste que la plupart des gens ne savent pas ce qu'ils sont. 😉
- Auriez-vous un lien de comparer mémoire et de la vitesse de sql_variant à d'autres types de données?
- Le premier point n'est pas vrai depuis SQL Server 2005 au moins. msdn.microsoft.com/en-us/library/ms173829(v=sql.90).aspx Un unique, primaire, ou une clé étrangère peut inclure des colonnes de type sql_variant, mais la longueur totale des valeurs de données qui composent la clé d'une ligne spécifique ne doit pas dépasser la longueur maximale d'un index. C'est de 900 octets. je ne vois pas pourquoi le deuxième point serait vrai, que ce soit.
- la conversion automatique de type nvarchar n'est pas vrai non plus.. les fournisseurs de convertir sql_variant binaire, il ya donc un certain niveau d'inférence de la part de la demande passe.. ODBC does not fully support sql_variant. Therefore, queries of sql_variant columns are returned as binary data when you use Microsoft OLE DB Provider for ODBC (MSDASQL). For example, a sql_variant column that contains the character string data 'PS2091' is returned as 0x505332303931. msdn.microsoft.com/en-us/library/ms173829.aspx..
- aussi.. ce lien fournit pas réellement raisonnements dans les 10 raisons.. #8 n'est même pas rien avoir à faire avec sql_variant, et l'auteur est incorrect dans son affirmation de datetime composants et les conversions: SELECT CONVERT(date, GETDATE(), 0), CONVERT(time(7), GETDATE(), 0)
- ah.. en fait.. l'heure et la date sont SQL Server 2008 et les années suivantes: msdn.microsoft.com/en-us/library/ms186724(v=sql.100).aspx .. mon erreur.. (auteur de l'article était en 2008, mais sa version est indefinitive)
- Vous avez perdu ma confiance à "je n'ai pas utilisé sql_variant avant". Ce n'est pas un universitaire de site web pour les enfants des collèges. Certaines personnes FOS alors qu'ils ont déjà RTFM. Ils ont besoin de monde réel de l'aide.
- Le monde réel de l'aide pour des OP question serait "Ça dépend". Je ne vois pas de problème avec l'utilisation de lignes directrices générales, ils vous font gagner du temps. La seule façon de savoir si les lignes directrices générales ne s'appliquent pas est d'essayer et de mesurer sur votre système. Je suis sûr que vous trouverez des gens qui ont utilisé sql_variant avec un grand succès. De même, je suis sûr que vous trouverez des gens qui ont eu à s'abstenir d'eux.
- Je pense que l'article lié est contre le fait de travailler avec sql_variant, pas à l'encontre de la conception de tables qui utilisent sql_variant. "convertir explicitement sql_variant types de données que vous utilisez."
InformationsquelleAutor Lieven Keersmaekers
6

Je sais que ma réponse est un peu tardive mais la table ici ressemble un peu à une application de configuration de la table. Comme une alternative à la des suggestions, nous allons penser à ne pas nous limiter à 30 ou même 8000 caractères. Nous allons également rendre un peu plus autonome et définissables par l'utilisateur.

Avec ces pensées à l'esprit, pourquoi ne pas sauver le "profil" de l'information comme un type de données XML qui serait à même de permettre plusieurs niveaux de réglages? Vous n'auriez probablement pas besoin d'autant de colonnes que ProfilerOptionID plus et peut-être en mesure d'obtenir ce à un simple contrôle de la table.

InformationsquelleAutor Jeff Moden
3

Il est intéressant de noter qu'il n'est pas possible de copier la colonne sql_variant implicitement.

par exemple, Créer une sauvegarde de schéma de CPSync4D.ProjectProfilerOption appelé CPSync4D.ProjectProfilerOption_bkp

et puis
```
Insert into CPSync4D.ProjectProfilerOption_bkp
(
    ProjectProfilerOptionID
   ,ProjectID
   ,ProfilerOptionID
   ,ProfilerOptionValue 
)
SELECT 
    ProjectProfilerOptionID
   ,ProjectID
   ,ProfilerOptionID
   ,ProfilerOptionValue 
FROM CPSync4D.ProjectProfilerOption 
```
Toutes les valeurs pour ProfilerOptionValue dans la table de sauvegarde seront varchar

Note: j'ai dit que le SQL_Variant ne peut pas être utilisé dans la réplication, mais ce n'est pas vrai. Certes, il peut être fait avec SQL 2008 R2 (que j'utilise) parce que je viens de le faire, mais cela peut ont été vrai pour les anciennes versions (je n'ai pas toutes les anciennes versions de vérifier avec donc impossible de confirmer ou d'infirmer cette).

Ce qui est vrai, cependant, est que si vous faites reproduire un tableau avec un SQL Variante en elle et ont beaucoup de données, puis quelque chose se passe mal et vous devez corriger les données manuellement, alors vous pourriez avoir un mauvais morceau de SQL pour écrire. C'est parce que lors de la copie des données vous ne pouvez pas copier avec plusieurs types de base dans la même copie de la déclaration. Je suppose que la réplication n'a pas ce problème, car il ne permet pas de copier plusieurs lignes (à l'exception évidente de l'instantané, mais qui utilise bcp).

ps. Je me rends compte que c'est un vieux post, mais mettre ce ici pour de futurs autres visiteurs avec la même question.

InformationsquelleAutor David Bridge

Vous devez vous connecter pour publier un commentaire.