Manipuler des données de type défini par l’utilisateur (UDT)
S'applique à :
SQL Server
Transact-SQL ne fournit aucune syntaxe spécialisée pour les instructions INSERT, UPDATEou DELETE lors de la modification de données dans des colonnes de type défini par l’utilisateur (UDT). Les fonctions Transact-SQL CAST ou CONVERT sont utilisées pour convertir les types de données natifs en type UDT.
Insérer des données dans une colonne UDT
Les instructions Transact-SQL suivantes insèrent trois lignes d’exemples de données dans la table Points. Le type de données Point se compose de valeurs entières X et Y exposées sous forme de propriétés de l’UDT. Vous devez utiliser la fonction CAST ou CONVERT pour convertir les valeurs X et Y délimitées par des virgules vers le type Point. Les deux premières instructions utilisent la fonction CONVERT pour convertir une valeur de chaîne en type Point, et la troisième instruction utilise la fonction CAST :
INSERT INTO dbo.Points (PointValue)
VALUES (CONVERT (Point, '3,4'));
INSERT INTO dbo.Points (PointValue)
VALUES (CONVERT (Point, '1,5'));
INSERT INTO dbo.Points (PointValue)
VALUES (CAST ('1,99' AS Point));
Sélectionner des données
L’instruction SELECT suivante sélectionne la valeur binaire de l’UDT.
SELECT ID, PointValue
FROM dbo.Points;
Pour afficher la sortie affichée dans un format lisible, appelez la méthode ToString de l’UDT Point, qui convertit la valeur en sa représentation sous forme de chaîne.
SELECT ID, PointValue.ToString() AS PointValue
FROM dbo.Points;
Voici le jeu de résultats.
ID PointValue
-- ----------
1 3,4
2 1,5
3 1,99
Vous pouvez également utiliser les fonctions Transact-SQL CAST et CONVERT pour obtenir les mêmes résultats.
SELECT ID, CAST (PointValue AS VARCHAR)
FROM dbo.Points;
SELECT ID, CONVERT (VARCHAR, PointValue)
FROM dbo.Points;
L’UDT Point expose ses coordonnées X et Y en tant que propriétés, que vous pouvez ensuite sélectionner individuellement. L’instruction Transact-SQL suivante sélectionne les coordonnées X et Y séparément :
SELECT ID,
PointValue.X AS xVal,
PointValue.Y AS yVal
FROM dbo.Points;
Les propriétés X et Y retournent une valeur entière qui est affichée dans le jeu de résultats.
ID xVal yVal
-- ---- ----
1 3 4
2 1 5
3 1 99
Utiliser des variables
Vous pouvez utiliser des variables à l’aide de l’instruction DECLARE pour affecter une variable à un type UDT. Les instructions suivantes attribuent une valeur à l’aide de l’instruction Transact-SQL SET et affichent les résultats en appelant la méthode ToString de l’UDT sur la variable :
DECLARE @PointValue AS Point;
SET @PointValue = (SELECT PointValue
FROM dbo.Points
WHERE ID = 2);
SELECT @PointValue.ToString() AS PointValue;
Le jeu de résultats affiche la valeur de la variable :
PointValue
----------
-1,5
Les instructions Transact-SQL suivantes obtiennent le même résultat à l’aide de SELECT plutôt que de SET pour l’affectation de variable :
DECLARE @PointValue AS Point;
SELECT @PointValue = PointValue
FROM dbo.Points
WHERE ID = 2;
SELECT @PointValue.ToString() AS PointValue;
La différence entre l’utilisation de SELECT et SET pour l’attribution de variables est que SELECT vous permet d’affecter plusieurs variables dans une instruction SELECT, tandis que la syntaxe SET exige que chaque affectation de variable ait sa propre instruction SET.
Comparer des données
Vous pouvez utiliser des opérateurs de comparaison pour comparer des valeurs dans votre UDT si vous définissez la propriété IsByteOrdered sur true lors de la définition de la classe. Pour plus d’informations, consultez Créer des types définis par l’utilisateur.
SELECT ID, PointValue.ToString() AS Points
FROM dbo.Points
WHERE PointValue > CONVERT (Point, '2,2');
Vous pouvez comparer les valeurs internes de l’UDT, quel que soit le paramètre IsByteOrdered si les valeurs elles-mêmes sont comparables. L’instruction Transact-SQL suivante sélectionne les lignes où X est supérieur à Y :
SELECT ID, PointValue.ToString() AS PointValue
FROM dbo.Points
WHERE PointValue.X < PointValue.Y;
Vous pouvez également utiliser des opérateurs de comparaison avec des variables, comme indiqué dans cette requête qui recherche une PointValuecorrespondante.
DECLARE @ComparePoint AS Point;
SET @ComparePoint = CONVERT (Point, '3,4');
SELECT ID, PointValue.ToString() AS MatchingPoint
FROM dbo.Points
WHERE PointValue = @ComparePoint;
Appeler des méthodes UDT
Vous pouvez également appeler des méthodes définies dans votre UDT dans Transact-SQL. La classe Point contient trois méthodes, Distance, DistanceFromet DistanceFromXY. Pour connaître les listes de code définissant ces trois méthodes, consultez Créer des types définis par l’utilisateur avec ADO.NET.
L’instruction Transact-SQL suivante appelle la méthode PointValue.Distance :
SELECT ID,
PointValue.X AS [Point.X],
PointValue.Y AS [Point.Y],
PointValue.Distance() AS DistanceFromZero
FROM dbo.Points;
Les résultats sont affichés dans la colonne Distance :
ID X Y Distance
-- -- -- ----------------
1 3 4 5
2 1 5 5.09901951359278
3 1 99 99.0050503762308
La méthode DistanceFrom prend un argument de type de données Point et affiche la distance entre le point spécifié et le PointValue:
SELECT ID,
PointValue.ToString() AS Pnt,
PointValue.DistanceFrom(CONVERT (Point, '1,99')) AS DistanceFromPoint
FROM dbo.Points;
Les résultats affichent les résultats de la méthode DistanceFrom pour chaque ligne du tableau :
ID Pnt DistanceFromPoint
-- --- -----------------
1 3,4 95.0210502993942
2 1,5 94
3 1,9 90
La méthode DistanceFromXY accepte les points individuellement en tant qu’arguments :
SELECT ID,
PointValue.X AS X,
PointValue.Y AS Y,
PointValue.DistanceFromXY(1, 99) AS DistanceFromXY
FROM dbo.Points;
Le jeu de résultats est identique à la méthode DistanceFrom.
Mettre à jour les données dans une colonne UDT
Pour mettre à jour les données dans une colonne UDT, utilisez l’instruction Transact-SQL UPDATE. Vous pouvez également utiliser une méthode du type UDT pour mettre à jour l'état de l'objet. L’instruction Transact-SQL suivante met à jour une seule ligne dans la table :
UPDATE dbo.Points
SET PointValue = CAST ('1,88' AS Point)
WHERE ID = 3;
Vous pouvez également mettre à jour des éléments UDT séparément. L’instruction Transact-SQL suivante met à jour uniquement la coordonnée Y :
UPDATE dbo.Points
SET PointValue.Y = 99
WHERE ID = 3;
Si l’UDT est défini avec l’ordre d’octet défini sur true, Transact-SQL pouvez évaluer la colonne UDT dans une clause WHERE.
UPDATE dbo.Points
SET PointValue = '4,5'
WHERE PointValue = '3,4';
Limitations des mises à jour
Vous ne pouvez pas mettre à jour plusieurs propriétés à la fois à l’aide de Transact-SQL. Par exemple, l’instruction UPDATE suivante échoue avec une erreur, car vous ne pouvez pas utiliser le même nom de colonne deux fois dans une instruction UPDATE.
UPDATE dbo.Points
SET PointValue.X = 5, PointValue.Y = 99
WHERE ID = 3;
Pour mettre à jour chaque point individuellement, vous devez créer une méthode de mutateur dans l’assembly UDT Point. Vous pouvez ensuite appeler la méthode mutator pour mettre à jour l’objet dans une instruction Transact-SQL UPDATE, comme dans l’exemple suivant :
UPDATE dbo.Points
SET PointValue.SetXY(5, 99)
WHERE ID = 3;
Supprimer des données dans une colonne UDT
Pour supprimer des données dans un UDT, utilisez l’instruction Transact-SQL DELETE. L’instruction suivante supprime toutes les lignes de la table qui correspondent aux critères spécifiés dans la clause WHERE. Si vous omettez la clause WHERE dans une instruction DELETE, toutes les lignes de la table sont supprimées.
DELETE dbo.Points
WHERE PointValue = CAST ('1,99' AS Point);
Utilisez l’instruction UPDATE si vous souhaitez supprimer les valeurs d’une colonne UDT tout en laissant les autres valeurs de ligne intactes. Cet exemple montre comment définir la valeur null PointValue.
UPDATE dbo.Points
SET PointValue = NULL
WHERE ID = 2;