Utilisation de types définis par l’utilisateur - Manipulation de données UDT

S’applique à :SQL Server

Transact-SQL ne fournit aucune syntaxe spécialisée pour les instructions INSERT, UPDATE ou 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 caster les types de données natives en type UDT.

Insertion de 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 en tant que propriétés de l’UDT. Vous devez utiliser la fonction CAST ou CONVERT pour caster les valeurs X et Y délimitées par des virgules en 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élection de données

L'instruction SELECT suivante sélectionne la valeur binaire du type UDT.

SELECT ID, PointValue FROM dbo.Points  

Pour voir 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;  

Ce code produit les résultats suivants.

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  

Utilisation de variables

Vous pouvez utiliser des variables à l'aide de l'instruction DECLARE pour attribuer 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 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 en utilisant SELECT plutôt que SET pour l’affectation de variable :

DECLARE @PointValue Point;  
SELECT @PointValue = PointValue FROM dbo.Points  
    WHERE ID = 2;  
SELECT @PointValue.ToString() AS PointValue;  

La différence entre SELECT et SET pour l'attribution de la variable réside dans le fait que SELECT vous permet d'attribuer plusieurs variables dans une instruction SELECT, tandis que la syntaxe SET nécessite que chaque attribution de variable possède sa propre instruction SET.

Comparaison de données

Vous pouvez utiliser des opérateurs de comparaison pour comparer des valeurs dans votre UDT si vous avez défini la propriété IsByteOrdered sur true lors de la définition de la classe. Pour plus d’informations, consultez Création d’un type User-Defined.

SELECT ID, PointValue.ToString() AS Points   
FROM dbo.Points  
WHERE PointValue > CONVERT(Point, '2,2');  

Vous pouvez comparer les valeurs internes de l’UDT indépendamment du 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 que recherche un PointValue correspondant.

DECLARE @ComparePoint Point;  
SET @ComparePoint = CONVERT(Point, '3,4');  
SELECT ID, PointValue.ToString() AS MatchingPoint   
FROM dbo.Points  
WHERE PointValue = @ComparePoint;  

Appel de 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, DistanceFrom et DistanceFromXY. Pour obtenir les listes de code définissant ces trois méthodes, consultez Codage User-Defined types.

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 la valeur 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 de la table :

ID Pnt DistanceFromPoint  
-- --- -----------------  
 1 3,4  95.0210502993942  
 2 1,5                94  
 3 1,9                90  

La méthode DistanceFromXY prend 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 .

Mise à jour de données dans une colonne UDT

Pour mettre à jour des 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 a été défini avec l’ordre d’octet défini sur true, Transact-SQL peut évaluer la colonne UDT dans une clause WHERE.

UPDATE dbo.Points  
SET PointValue = '4,5'  
WHERE PointValue = '3,4';  

Mise à jour de limitations

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 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 les éléments suivants :

UPDATE dbo.Points  
SET PointValue.SetXY(5, 99)  
WHERE ID = 3  

Suppression de 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 dans 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 dans la table seront supprimées.

DELETE FROM dbo.Points  
WHERE PointValue = CAST('1,99' AS Point)  

Utilisez l'instruction UPDATE si vous souhaitez supprimer les valeurs dans une colonne UDT tout en laissant d'autres valeurs de lignes intactes. Cet exemple attribut la valeur null à PointValue.

UPDATE dbo.Points  
SET PointValue = null  
WHERE ID = 2  

Voir aussi

Utilisation de types définis par l’utilisateur dans SQL Server