CAST et CONVERT (Transact-SQL)

Convertit une expression d'un type de données en un autre dans SQL Server 2012.

Conventions de la syntaxe Transact-SQL

Syntaxe

Syntax for CAST:
CAST ( expression AS data_type [ ( length ) ] )

Syntax for CONVERT:
CONVERT ( data_type [ ( length ) ] , expression [ , style ] )

Arguments

• expression
  Toute expression valide.

• data_type
  Type de données cible. Cela comprend xml, bigint et sql_variant. Les données de type alias ne sont pas autorisées.

• length
  Entier facultatif qui spécifie la longueur du type de données cible. La valeur par défaut est 30.

• style
  Expression entière qui spécifie comment la fonction CONVERT doit traduire expression. Si le style est NULL, une valeur NULL est retournée. La plage est déterminée par data_type. Pour plus d'informations, consultez la section Notes.

Types des valeurs retournés

Retourne l'expression traduite en data_type.

Notes

Styles de date et d'heure

Lorsque expression est un type de données de date ou d'heure, style peut être l'une des valeurs présentées dans le tableau ci-dessous. Les autres valeurs sont traitées comme étant 0. À partir de SQL Server 2012, les seuls styles pris en charge lors de la conversion des types de date et d'heure en datetimeoffset sont 0 ou 1. Tous les autres styles de conversion retournent une erreur 9809.

SQL Server prend en charge le format de date dans le style arabe à l'aide de l'algorithme koweitien.

Sans siècle (aa) (1)	Avec siècle (aaaa)	Standard	Entrée/Sortie (3)
-	0 ou 100 (1, 2)	Valeur par défaut pour datetime et smalldatetime	mois jj aaaa hh:miAM (ou PM)
1	101	États-Unis	1 = mm/jj/aa 101 = mm/jj/aaaa
2	102	ANSI	2 = aa.mm.jj 102 = aaaa.mm.jj
3	103	Anglais/Français	3 = jj/mm/aa 103 = jj/mm/aaaa
4	104	Allemand	4 = jj.mm.aa 104 = jj.mm.aaaa
5	105	Italien	5 = jj-mm-aa 105 = jj-mm-aaaa
6	106 (1)	-	6 = jj mois aa 106 = jj mois aaaa
7	107 (1)	-	7 = Mois jj, aa 107 = Mois jj, aaaa
8	108	-	hh:mi:ss
-	9 ou 109 (1, 2)	Valeur par défaut + millièmes de secondes	mois jj aaaa hh:mi:ss:mmmAM (ou PM)
10	110	États-Unis	10 = mm-jj-aa 110 = mm-jj-aaaa
11	111	Japon	11 = aa/mm/jj 111 = aaaa/mm/jj
12	112	ISO	12 = aammjj 112 = aaaammjj
-	13 ou 113 (1, 2)	Valeur par défaut Europe + millièmes de secondes	jj mois aaaa hh:mi:ss:mmm (24h)
14	114	-	hh:mi:ss:mmm(24h)
-	20 ou 120 (2)	ODBC canonique	aaaa-mm-jj hh:mi:ss (24h)
-	21 ou 121 (2)	Valeur canonique ODBC par défaut (avec millisecondes) pour time, date, datetime2 et datetimeoffset	aaaa-mm-jj hh:mi:ss.mmm (24h)
-	126 (4)	ISO8601	aaaa-mm-jjThh:mi:ss.mmm (sans espace) [!REMARQUE] Lorsque la valeur en millisecondes (mmm) est égale à 0, elle n'est pas affichée. Par exemple, la valeur « 2012-11-07T18:26:20.000 » est affichée comme suit « 2012-11-07T18:26:20 ».
-	127(6, 7)	ISO8601 avec fuseau horaire Z.	aaaa-mm-jjThh:mi:ss.mmmZ (sans espace) [!REMARQUE] Lorsque la valeur en millisecondes (mmm) est égale à 0, elle n'est pas affichée. Par exemple, la valeur « 2012-11-07T18:26:20.000 » est affichée comme suit « 2012-11-07T18:26:20 ».
-	130 (1, 2)	Hijri (5)	jj mois aaaa hh:mi:ss:mmmAM Dans ce style, « mois » représente une représentation unicode Hijri à plusieurs jetons pour le nom complet du mois. Cette valeur ne sera pas retournée correctement sur les installations en anglais américain par défaut de SSMS.
-	131 (2)	Hijri (5)	jj/mm/yyyy hh:mi:ss:mmmAM

1 Ces valeurs de style retournent des résultats non déterministes. Inclut tous les styles (aa, c'est-à-dire sans siècle) et un sous-ensemble de styles (aaaa, c'est-à-dire avec siècle).

2 Valeurs par défaut (style 0 ou 100, 9 ou 109, 13 ou 113, 20 ou 120, ou encore 21 ou 121) renvoient toujours le siècle (aaaa).

3  Entrée lors de la conversion en données de type datetime ; ou encore, sortie lors de la conversion en données de type caractère.

4  Conçue pour le langage XML. Pour la conversion de données datetime ou smalldatetime en données de type caractère, le format de sortie étant celui décrit dans le tableau précédent.

5 Hijri est un système de calendrier avec différentes variantes. SQL Server utilise l'algorithme koweitien.

Important

Par défaut, SQL Server interprète les années à deux chiffres par rapport à l'année de coupure 2049. Autrement dit, l'année à deux chiffres 49 est interprétée comme étant 2049 et l'année 50 comme étant 1950. De nombreuses applications clientes, comme celles basées sur les objets Automation, utilisent l'année de coupure 2030. SQL Server fournit l'option de configuration two digit year cutoff permettant de modifier l'année de coupure utilisée par SQL Server et autorise le traitement cohérent des dates. Nous vous recommandons d'utiliser la fonctionnalité d'années exprimées sur quatre chiffres.

6 Prise en charge uniquement lors de la conversion de données de type caractère en type datetime ou smalldatetime. Lorsque des données de caractères représentant des composants de date ou d'heure uniquement sont converties en type de données datetime ou smalldatetime, le composant d'heure non spécifié est défini à 00:00:00.000, et le composant de date non spécifié est défini à 1900-01-01.

7 L'indicateur de fuseau horaire facultatif Z facilite le mappage des valeurs datetime XML qui possèdent des informations de fuseau horaire avec les valeurs SQL Server datetime dépourvues d'informations de fuseau horaire. Z est l'indicateur du fuseau horaire UTC-0. Les autres fuseaux horaires sont indiqués avec le décalage HH:MM dans la direction + ou -. Exemple : 2006-12-12T23:45:12-08:00.

Lorsque vous convertissez des données smalldatetime en données de type caractère, les styles comportant les secondes ou les millièmes de secondes affichent des zéros à ces positions. Si vous convertissez des données de type datetime ou smalldatetime, vous pouvez supprimer les parties non requises de la date en spécifiant la longueur de type de données char ou varchar appropriée.

Lorsque vous effectuez une conversion en datetimeoffset de données caractères avec un style qui inclut une heure, un décalage de fuseau horaire est ajouté au résultat.

Styles float et real

Lorsque expression est float ou real, style peut être l'une des valeurs présentées dans le tableau ci-dessous. Les autres valeurs sont traitées comme étant 0.

Valeur	Sortie
0 (valeur par défaut)	6 chiffres maximum. À utiliser pour la notation scientifique si nécessaire.
1	Toujours 8 chiffres. À utiliser obligatoirement pour la notation scientifique.
2	Toujours 16 chiffres. À utiliser obligatoirement pour la notation scientifique.
126, 128, 129	Incluses pour des raisons d'héritage et peuvent être déconseillées dans une version ultérieure.

Styles money et smallmoney

Lorsque expression est money ou smallmoney, style peut être l'une des valeurs présentées dans le tableau ci-dessous. Les autres valeurs sont traitées comme étant 0.

Valeur	Sortie
0 (valeur par défaut)	Pas de virgule tous les trois chiffres à gauche du point décimal, et deux chiffres à droite de celui-ci. Par exemple, 4235.98.
1	Insertion d'une virgule tous les trois chiffres à gauche du point décimal, et deux chiffres à droite de celui-ci. Par exemple 3,510.92.
2	Pas de virgule tous les trois chiffres à gauche du point décimal, et quatre chiffres à droite de celui-ci. Par exemple 4235.9819.
126	Équivalent du style 2 lors de la conversion en char(n) ou varchar(n)

Styles xml

Lorsque expression est xml, style peut être l'une des valeurs présentées dans le tableau ci-dessous. Les autres valeurs sont traitées comme étant 0.

Valeur	Sortie
0 (valeur par défaut)	Utilisez le comportement d'analyse par défaut permettant de supprimer les espaces non significatifs et n'autorisant pas de sous-ensemble DTD interne. [!REMARQUE] Si vous effectuez une conversion vers le type de données xml, les espaces non significatifs sont gérés différemment par SQL Server que pour les documents au format XML 1.0. Pour plus d'informations, consultez Créer des instances de données XML.
1	Maintient des espaces non significatifs. Ce paramètre de style définit la gestion par défaut de xml:space pour qu'elle soit plutôt équivalente à l'option xml:space="preserve".
2	Activation du traitement limité de sous-ensembles DTD internes. Si cette option est activée, le serveur peut utiliser les informations suivantes fournies dans un sous-ensemble DTD interne afin de procéder à des opérations d'analyse autres que celles de validation des données. Les valeurs par défaut concernant les attributs sont alors appliquées. Les références à des entités internes sont résolues et développées. Le modèle de contenu DTD fait ensuite l'objet d'une vérification syntaxique. L'analyseur ignore les sous-ensembles DTD externes. Il n'évalue cependant pas la déclaration des balises XML au niveau de l'attribut standalone pour vérifier s'il est défini sur yes ou no, mais analyse cependant l'instance XML comme s'il s'agissait d'un document autonome.
3	Maintien des espaces non significatifs et activation du traitement limité de sous-ensembles DTD internes.

Styles Binary

Lorsque expression est binary(n), varbinary(n), char(n) ou varchar(n), style peut être l'une des valeurs présentées dans le tableau ci-dessous. Les valeurs de style qui ne sont pas répertoriées dans le tableau retournent une erreur.

Valeur	Sortie
0 (valeur par défaut)	Traduit des caractères ASCII en octets binaires ou des octets de binaire en caractères ASCII. Chaque caractère ou octet est converti 1:1. Si le data_type est un type binaire, les caractères 0x sont ajoutés à gauche du résultat.
1, 2	Si le data_type est un type binaire, l'expression doit être une expression de caractères. L'expression doit être composée d'un nombre pair de chiffres hexadécimaux (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F, a, b, c, d, e, f). Si le style a la valeur 1, les caractères 0x doivent être les deux premiers caractères de l'expression. Si l'expression contient un nombre impair de caractères ou si l'un des caractères n'est pas valide, une erreur est générée. Si la longueur de l'expression convertie est supérieure à la longueur du data_type, le résultat est tronqué à droite. Les data_types de longueur fixe qui sont plus longs que le résultat converti se voient ajouter des zéros à droite du résultat. Si le data_type est un type caractère, l'expression doit être une expression binaire. Chaque caractère binaire est converti en deux caractères hexadécimaux. Si la longueur de l'expression convertie est supérieure à la longueur du data_type, le résultat est tronqué à droite. Si le data_type est un type caractère de taille fixe et que la longueur du résultat converti est inférieure à la longueur du data_type, des espaces sont ajoutés à droite de l'expression convertie pour conserver un nombre pair de chiffres hexadécimaux. Des caractères 0x sont ajoutés à gauche du résultat converti pour style 1.

Conversions implicites

Une conversion implicite est une conversion pour laquelle il n'est pas nécessaire de spécifier les fonctions CAST ou CONVERT. À l'inverse, une conversion explicite requiert que la fonction CAST ou CONVERT soit indiquée. L'illustration ci-dessous reprend toutes les conversions de types de données explicites et implicites autorisées pour les types de données SQL Server fournis par le système. Ceux-ci comprennent notamment xml, bigint et sql_variant. Aucune conversion implicite d'attribution de valeur n'est effectuée à partir du type de données sql_variant, mais une conversion implicite vers sql_variant existe.

Conseil
Ce graphique est disponible en fichier PDF téléchargeable dans le Centre de téléchargement Microsoft.

Lorsque vous effectuez une conversion entre datetimeoffset et les types de caractère char, varchar, nchar ou nvarchar, la partie du décalage de fuseau horaire convertie doit toujours comporter des chiffres doubles pour HH et pour MM, par exemple : -08:00.

[!REMARQUE]

Les données Unicode utilisent toujours un nombre pair d'octets et vous devez par conséquent faire attention lorsque vous convertissez des données de type binary ou varbinary vers ou à partir des types de données pris en charge par Unicode. Ainsi, la conversion suivante retourne la valeur hexadécimale 4100 et non pas 41 : SELECT CAST(CAST(0x41 AS nvarchar) AS varbinary).

Types de données de valeur élevée

Les types de données correspondant à des valeurs élevées font preuve du même comportement de conversion, à la fois implicite et explicite, que leur contreparties de poids plus faible, plus particulièrement en ce qui concerne les types varchar, nvarchar et varbinary. Vous devez cependant prendre en compte les recommandations suivantes :

• La conversion du type image en varbinary(max) et vice versa est une conversion implicite ; il en va de même pour la conversion entre text et varchar(max) d'une part et ntext et nvarchar(max) d'autre part.

• La conversion de types de données de valeurs élevées, comme c'est le cas pour le type varchar(max), en type équivalent mais de poids plus faible, par exemple varchar, reste aussi une conversion implicite, mais la valeur trop grande risque d'être tronquée si elle dépasse la longueur indiquée autorisée pour le type de données de poids dont l'espace mémoire alloué reste plus modeste.

• Les conversions de varchar, de nvarchar ou de varbinary à leur équivalent plus volumineux en espace mémoire sont également opérées de façon implicite.

• Enfin, les conversions du type de données sql_variant en type plus conséquent correspondent cependant à une conversion explicite.

• Il reste à savoir que les types de données de valeurs élevées ne peuvent pas être convertis en sql_variant.

Pour plus d'informations sur la façon d'effectuer une conversion à partir du type de données xml, consultez Créer des instances de données XML.

Type de données xml

Lors de la conversion explicite ou implicite du type de données xml en type de données de chaîne ou de caractères, le contenu du type de données xml est sérialisé par rapport à un ensemble de règles. Pour plus d'informations sur ces règles, consultez Définir la sérialisation des données XML. Pour plus d'informations sur la façon d'effectuer une conversion à partir d'autres types de données vers le type de données xml, consultez Créer des instances de données XML.

Types de données text et image

Les types de données text et image ne prennent pas en charge la conversion automatique de types de données. Vous pouvez explicitement convertir des données de type text en type caractère et des données de type image en binary ou en varbinary, mais la longueur maximale admise est de 8 000 octets. Si vous tentez une conversion non prévue, par exemple une expression de type caractère incluant des lettres et convertie en type int, SQL Server retourne alors un message d'erreur.

Classement des résultats

Lorsque l'entrée et la sortie de CAST ou CONVERT sont des chaînes de caractères, l'entrée et la sortie présentent les mêmes classement et étiquette de classement. Si l'entrée n'est pas une chaîne de caractères, la sortie présente le classement par défaut de la base de données et une étiquette de classement de contrainte par défaut. Pour plus d'informations, consultez Priorité de classement (Transact-SQL).

Pour attribuer un classement différent à la sortie, appliquez la clause COLLATE à l'expression de résultat de la fonction CAST ou CONVERT. Exemple :

SELECT CAST('abc' AS varchar(5)) COLLATE French_CS_AS

Troncation et arrondi des résultats

Lors de la conversion d'une expression de type binaire ou caractère (char, nchar, nvarchar, varchar, binary ou varbinary) en une expression d'un type différent, les données peuvent être tronquées ou partiellement affichées, ou une erreur est retournée si le résultat est trop court pour pouvoir être affiché. Une expression convertie en donnée de type char, varchar, nchar, nvarchar, binary et varbinary est par conséquent tronquée, sauf pour les conversions répertoriées dans le tableau suivant.

Du type de données	Au type de données	Résultat
int, smallint ou tinyint	char	*
	varchar	*
	nchar	E
	nvarchar	E
money, smallmoney, numeric, decimal, float ou real	char	E
	varchar	E
	nchar	E
	nvarchar	E

* = Expression résultante trop courte pour être affichée. E = Erreur retournée car l'expression résultante est trop courte pour être affichée.

SQL Server garantit que seules des conversions en boucle, c'est-à-dire qui convertissent un type de données en un autre puis à nouveau en son type d'origine, restitueront les mêmes valeurs d'une version à l'autre de l'application. L'exemple suivant illustre un tel cas de figure :

DECLARE @myval decimal (5, 2);
SET @myval = 193.57;
SELECT CAST(CAST(@myval AS varbinary(20)) AS decimal(10,5));
-- Or, using CONVERT
SELECT CONVERT(decimal(10,5), CONVERT(varbinary(20), @myval));

[!REMARQUE]

N'essayez pas de construire des valeurs binary puis de les convertir en un type de données de catégorie numérique. SQL Server ne garantit pas que le résultat d'une conversion de type de données decimal ou numeric en binary sera le même entre les différentes versions d'SQL Server.

L'exemple suivant illustre une expression résultante trop petite pour être affichée.

USE AdventureWorks2012;
GO
SELECT p.FirstName, p.LastName, SUBSTRING(p.Title, 1, 25) AS Title, CAST(e.SickLeaveHours AS char(1)) AS [Sick Leave]
FROM HumanResources.Employee e JOIN Person.Person p ON e.BusinessEntityID = p.BusinessEntityID
WHERE NOT e.BusinessEntityID >5;

Voici l'ensemble des résultats.

FirstName   LastName      Title   Sick Leave

---------   ------------- ------- --------

Ken         Sanchez       NULL   *

Terri       Duffy         NULL   *

Roberto     Tamburello    NULL   *

Rob         Walters       NULL   *

Gail        Erickson      Ms.    *

(5 row(s) affected)

Si vous convertissez des données dont le type diffère sur l'emplacement de la virgule, la valeur résultante peut parfois être tronquée, parfois être arrondie. Le tableau suivant illustre ce comportement.

De	en	Comportement
numeric	numeric	Arrondi
numeric	int	Tronqué
numeric	money	Arrondi
money	int	Arrondi
money	numeric	Arrondi
float	int	Tronqué
float	numeric	Arrondi La conversion des valeurs float qui utilisent la notation scientifique en decimal ou en numeric est limitée à des valeurs d'une précision de 17 chiffres uniquement. Toute valeur avec une précision plus élevée que 17 sera arrondie à zéro.
float	datetime	Arrondi
datetime	int	Arrondi

Par exemple, le résultat découlant de la conversion suivante est 10 :

SELECT CAST(10.6496 AS int);

Lors des conversions entre divers types de données dans lesquelles les types de données cibles comptent moins de chiffres décimaux que les types de données sources, la valeur obtenue est arrondie. Par exemple, le résultat découlant de la conversion suivante est $10.3497 :

SELECT CAST(10.3496847 AS money);

SQL Server retourne un message d'erreur lorsque des données non numériques de type char, nchar, varchar ou nvarchar sont converties en données int, float, numeric ou decimal. SQL Server retourne également un message d'erreur lorsqu'une chaîne vide (« ») est convertie en données de type numeric ou decimal.

Certaines conversions de valeurs datetime sont non déterministes dans SQL Server 2005 et versions ultérieures

Dans SQL Server 2000, les conversions de chaînes en dates et heures sont marquées comme étant déterministes. Toutefois, cela n'est pas le cas pour les styles répertoriés dans le tableau ci-dessous. Pour ces styles, les conversions dépendent des paramètres de langue. SQL Server 2005 et les versions ultérieures marquent ces conversions comme non déterministes.

Le tableau ci-dessous répertorie les styles pour lesquels la conversion chaîne-datetime est non déterministe.

Tous les styles inférieurs à 1001	106
107	109
113	130

1  À l'exception des styles 20 et 21

Caractères supplémentaires (paires de substitution)

À compter de SQL Server 2012, si vous utilisez les classements de caractères supplémentaires (SC), une opération de conversion CAST de nchar ou nvarchar en un type nchar ou nvarchar de plus petite longueur ne sera pas tronquée à l'intérieur d'une paire de substitution ; elle sera tronquée avant le caractère supplémentaire. Par exemple, le fragment de code suivant laisse @x avec seulement 'ab'. Il n'y a pas assez d'espace pour conserver le caractère supplémentaire.

DECLARE @x NVARCHAR(10) = 'ab' + NCHAR(0x10000);
SELECT CAST (@x AS NVARCHAR(3));

Lors de l'utilisation de classements SC, le comportement de CONVERT, est analogue à celui de CAST.

Prise en charge de la compatibilité

Dans les versions antérieures de SQL Server, le style par défaut pour les opérations CAST et CONVERT sur les types de données time et datetime2 est 121, sauf si l'un des types est utilisé dans une expression de colonne calculée. Pour les colonnes calculées, le style par défaut est 0. Ce comportement influe sur les colonnes calculées lorsqu'elles sont créées, utilisées dans des requêtes impliquant le paramétrage automatique, ou utilisées dans des définitions de contraintes.

Lorsque le niveau de compatibilité est 110, le style par défaut pour les opérations CAST et CONVERT sur les types de données time et datetime2 est toujours 121. Si votre requête repose sur l'ancien comportement, utilisez un niveau de compatibilité inférieur à 110, ou spécifiez explicitement le style 0 dans la requête affectée.

La mise à niveau de la base de données vers le niveau de compatibilité 110 ne modifie pas les données utilisateur stockées sur le disque. Vous devez corriger manuellement ces données comme il convient. Par exemple, si vous avez utilisé SELECT INTO pour créer une table à partir d'une source qui contenait une expression de colonne calculée décrite ci-dessus, les données (utilisant le style 0) sont stockées à la place de la définition de colonne calculée. Vous devez mettre à jour manuellement ces données pour qu'elles correspondent au style 121.

Exemples

A.Utilisation simultanée de CAST et CONVERT

Chacun des exemples récupère le nom de chaque produit possédant un 3 au premier chiffre de son prix et convertit son champ ListPrice en type int.

-- Use CAST
USE AdventureWorks2012;
GO
SELECT SUBSTRING(Name, 1, 30) AS ProductName, ListPrice
FROM Production.Product
WHERE CAST(ListPrice AS int) LIKE '3%';
GO

-- Use CONVERT.
USE AdventureWorks2012;
GO
SELECT SUBSTRING(Name, 1, 30) AS ProductName, ListPrice
FROM Production.Product
WHERE CONVERT(int, ListPrice) LIKE '3%';
GO

B.Utilisation de CAST avec des opérateurs arithmétiques

L'exemple suivant illustre le calcul effectué sur une colonne unique (intitulée Computed) où le total des ventes de l'année en cours (SalesYTD) est divisé par le pourcentage de commission (dont la valeur se trouve dans CommissionPCT). Le résultat est converti en données de type int après avoir été arrondi au chiffre entier le plus proche.

USE AdventureWorks2012;
GO
SELECT CAST(ROUND(SalesYTD/CommissionPCT, 0) AS int) AS Computed
FROM Sales.SalesPerson 
WHERE CommissionPCT != 0;
GO

Voici l'ensemble des résultats.

Computed

------

379753754

346698349

257144242

176493899

281101272

0

301872549

212623750

298948202

250784119

239246890

101664220

124511336

97688107

(14 row(s) affected)

C.Utilisation de CAST pour la concaténation d'expressions

L'exemple suivant illustre la concaténation d'expressions de type non caractère et non binaire par le biais de CAST.

USE AdventureWorks2012;
GO
SELECT 'The list price is ' + CAST(ListPrice AS varchar(12)) AS ListPrice
FROM Production.Product
WHERE ListPrice BETWEEN 350.00 AND 400.00;
GO

Voici l'ensemble des résultats.

ListPrice

------------------

The list price is 357.06

The list price is 364.09

The list price is 364.09

The list price is 364.09

The list price is 364.09

(5 row(s) affected)

D.Utilisation de CAST pour faciliter la lecture des résultats

L'exemple suivant s'appuie sur CAST dans la liste de sélection afin de convertir la colonne Name en colonne de type char(10).

USE AdventureWorks2012;
GO
SELECT DISTINCT CAST(p.Name AS char(10)) AS Name, s.UnitPrice
FROM Sales.SalesOrderDetail AS s 
JOIN Production.Product AS p 
    ON s.ProductID = p.ProductID
WHERE Name LIKE 'Long-Sleeve Logo Jersey, M';
GO

Voici l'ensemble des résultats.

Name       UnitPrice

---------- ---------------------

Long-Sleev 31.2437

Long-Sleev 32.4935

Long-Sleev 49.99

(3 row(s) affected)

E.Utilisation de CAST avec la clause LIKE

L'exemple suivant convertit la colonne SalesYTD de type money en colonne de type int, puis en colonne de type char(20) de façon à pouvoir l'utiliser avec la clause LIKE.

USE AdventureWorks2012;
GO
SELECT p.FirstName, p.LastName, s.SalesYTD, s.BusinessEntityID
FROM Person.Person AS p 
JOIN Sales.SalesPerson AS s 
    ON p.BusinessEntityID = s.BusinessEntityID
WHERE CAST(CAST(s.SalesYTD AS int) AS char(20)) LIKE '2%';
GO

Voici l'ensemble des résultats.

FirstName        LastName            SalesYTD         SalesPersonID

---------------- ------------------- ---------------- -------------

Tsvi             Reiter              2811012.7151      279

Syed             Abbas               219088.8836       288

Rachel           Valdez              2241204.0424      289

(3 row(s) affected)

F.Utilisation de CONVERT ou de CAST avec des données au format XML typé

Voici une série d'exemples illustrant l'utilisation de la fonction CONVERT pour convertir des données en XML typé en utilisant le Type et colonnes de données XML (SQL Server).

Cet exemple convertit une chaîne incluant des espaces, du texte et des balises en XML typé, puis supprime tous les espaces non significatifs (correspondant aux espaces délimitant les nœuds) :

CONVERT(XML, '<root><child/></root>')

Cet exemple convertit une chaîne similaire incluant des espaces, du texte et des balises en XML typé, mais conserve les espaces non significatifs (correspondant aux espaces délimitant les nœuds) :

CONVERT(XML, '<root>          <child/>         </root>', 1)

Enfin, cet exemple convertit une chaîne similaire incluant des espaces, du texte et des balises en XML typé :

CAST('<Name><FName>Carol</FName><LName>Elliot</LName></Name>'  AS XML)

Pour obtenir d'autres exemples, consultez Créer des instances de données XML.

G.Utilisation de CAST et de CONVERT avec des données de type datetime

L'exemple suivant affiche la date et l'heure actuelles, utilise CAST pour convertir la date et l'heure actuelles en données de type caractère, puis utilise CONVERT pour afficher la date et l'heure au format ISO 8901.

SELECT 
   GETDATE() AS UnconvertedDateTime,
   CAST(GETDATE() AS nvarchar(30)) AS UsingCast,
   CONVERT(nvarchar(30), GETDATE(), 126) AS UsingConvertTo_ISO8601  ;
GO

Voici l'ensemble des résultats.

UnconvertedDateTime     UsingCast                      UsingConvertTo_ISO8601

----------------------- ------------------------------ ------------------------------

2006-04-18 09:58:04.570 Apr 18 2006 9:58AM            2006-04-18T09:58:04.570

(1 row(s) affected)

L'exemple suivant est plus ou moins l'inverse de l'exemple précédent. Cet exemple affiche la date et l'heure sous forme de données de type caractère, utilise CAST pour convertir les données caractère en données de type datetime, puis utilise CONVERT pour convertir les données caractère en données de type datetime.

SELECT 
   '2006-04-25T15:50:59.997' AS UnconvertedText,
   CAST('2006-04-25T15:50:59.997' AS datetime) AS UsingCast,
   CONVERT(datetime, '2006-04-25T15:50:59.997', 126) AS UsingConvertFrom_ISO8601 ;
GO

Voici l'ensemble des résultats.

UnconvertedText         UsingCast               UsingConvertFrom_ISO8601

----------------------- ----------------------- ------------------------

2006-04-25T15:50:59.997 2006-04-25 15:50:59.997 2006-04-25 15:50:59.997

(1 row(s) affected)

H.Utilisation de CONVERT avec des données binaires et caractères

Les exemples suivants montrent les résultats de la conversion de données binaires et caractères en utilisant des styles différents.

--Convert the binary value 0x4E616d65 to a character value.
SELECT CONVERT(char(8), 0x4E616d65, 0) AS [Style 0, binary to character];

Voici l'ensemble des résultats.

Style 0, binary to character

----------------------------

Name

(1 row(s) affected)

--The following example shows how Style 1 can force the result
--to be truncated. The truncation is caused by
--including the characters 0x in the result.
SELECT CONVERT(char(8), 0x4E616d65, 1) AS [Style 1, binary to character];

Voici l'ensemble des résultats.

Style 1, binary to character

------------------------------

0x4E616D

(1 row(s) affected)

--The following example shows that Style 2 does not truncate the
--result because the characters 0x are not included in
--the result.
SELECT CONVERT(char(8), 0x4E616d65, 2) AS [Style 2, binary to character];

Voici l'ensemble des résultats.

Style 2, binary to character

------------------------------

4E616D65

(1 row(s) affected)

--Convert the character value 'Name' to a binary value.
SELECT CONVERT(binary(8), 'Name', 0) AS [Style 0, character to binary];

Voici l'ensemble des résultats.

Style 0, character to binary

----------------------------------

0x4E616D6500000000

(1 row(s) affected)

SELECT CONVERT(binary(4), '0x4E616D65', 1) AS [Style 1, character to binary];

Voici l'ensemble des résultats.

Style 1, character to binary

----------------------------------

0x4E616D65

(1 row(s) affected)

SELECT CONVERT(binary(4), '4E616D65', 2) AS [Style 2, character to binary];

Voici l'ensemble des résultats.

Style 2, character to binary

----------------------------------

0x4E616D65

(1 row(s) affected)

I.Conversion des types de données de date et d'heure

L'exemple suivant illustre la conversion de types de données date, time et datetime.

DECLARE @d1 date, @t1 time, @dt1 datetime;
SET @d1 = GETDATE();
SET @t1 = GETDATE();
SET @dt1 = GETDATE();
SET @d1 = GETDATE();
-- When converting date to datetime the minutes portion becomes zero.
SELECT @d1 AS [date], CAST (@d1 AS datetime) AS [date as datetime];
-- When converting time to datetime the date portion becomes zero 
-- which converts to January 1, 1900.
SELECT @t1 AS [time], CAST (@t1 AS datetime) AS [time as datetime];
-- When converting datetime to date or time non-applicable portion is dropped.
SELECT @dt1 AS [datetime], CAST (@dt1 AS date) AS [datetime as date], CAST (@dt1 AS time) AS [datetime as time];

Voir aussi

Référence

SELECT (Transact-SQL)

Fonctions système (Transact-SQL)

Concepts

Conversion de types de données (moteur de base de données)

Rédiger des instructions Transact-SQL internationales