CAST e CONVERT (Transact-SQL)
Converte un'espressione da un tipo di dati a un altro in SQL Server 2012.
.gif "Icona di collegamento a un argomento")
Convenzioni della sintassi Transact-SQL
Sintassi
Syntax for CAST:
CAST ( expression AS data_type [ ( length ) ] )
Syntax for CONVERT:
CONVERT ( data_type [ ( length ) ] , expression [ , style ] )
Argomenti
expression
Qualsiasi espressione valida.data_type
Tipo di dati di destinazione. Sono i tipi xml, bigint e sql_variant. Non è possibile usare i tipi di dati alias.length
Numero intero facoltativo che specifica la lunghezza del tipo di dati di destinazione. Il valore predefinito è 30.style
Espressione integer che specifica il modo in cui la funzione CONVERT viene usata per convertire expression. Se il valore di style è NULL, viene restituito NULL. L'intervallo è determinato da data_type. Per altre informazioni, vedere la sezione Osservazioni.
Tipi restituiti
Restituisce l'espressione expression convertita in data_type.
Osservazioni
Stili date e time
Quando expression è di tipo date o time, style può assumere uno dei valori indicati nella tabella seguente. Gli altri valori vengono elaborati come 0. A partire da SQL Server 2012, gli unici stili supportati nella conversione di tipi date e time in datetimeoffset sono 0 e 1. Tutti gli altri stili di conversione restituiscono l'errore 9809.
In SQL Server è supportato il formato di data in stile arabo tramite l'algoritmo kuwaitiano.
Senza il secolo (aa) (1) |
Con il secolo (aaaa) |
Standard |
Input/Output (3) |
|---|---|---|---|
- |
0 o 100 (1, 2) |
Predefinito per datetime e smalldatetime |
mes gg aaaa hh:miAM (o PM) |
1 |
101 |
U.S. |
1 = mm/gg/aa 101 = mm/gg/aaaa |
2 |
102 |
ANSI |
2 = aa.mm.gg 102 = aaaa.mm.gg |
3 |
103 |
Inglese Regno Unito/Francese |
3 = gg/mm/aa 103 = gg/mm/aaaa |
4 |
104 |
Tedesco |
4 = gg.mm.aa 104 = gg.mm.aaaa |
5 |
105 |
Italiano |
5 = gg-mm-aa 105 = gg-mm-aaaa |
6 |
106 (1) |
- |
6 = gg mes aa 106 = gg mes aaaa |
7 |
107 (1) |
- |
7 = Mes gg, aa 107 = Mes gg, aaaa |
8 |
108 |
- |
hh:mi:ss |
- |
9 o 109 (1, 2) |
Valore predefinito + millisecondi |
mes gg aaaa hh:mi:ss:mmmAM (o PM) |
10 |
110 |
USA |
10 = mm-gg-aa 110 = mm-gg-aaaa |
11 |
111 |
Giappone |
11 = aa/mm/gg 111 = aaaa/mm/gg |
12 |
112 |
ISO |
12 = aammgg 112 = aaaammgg |
- |
13 o 113 (1, 2) |
Valore predefinito Europa + millisecondi |
gg mes aaaa hh:mi:ss:mmm(24h) |
14 |
114 |
- |
hh:mi:ss:mmm(24h) |
- |
20 o 120 (2) |
ODBC canonico |
aaaa-mm-gg hh:mi:ss(24h) |
- |
21 o 121 (2) |
ODBC canonico (con millisecondi) predefinito per time, date, datetime2 e datetimeoffset |
aaaa-mm-gg hh:mi:ss.mmm(24h) |
- |
126 (4) |
ISO8601 |
aaaa-mm-ggThh:mi:ss.mmm (senza spazi)
|
- |
127(6, 7) |
ISO8601 con fuso orario Z. |
aaaa-mm-ggThh:mi:ss.mmmZ (senza spazi)
|
- |
130 (1, 2) |
Hijri (5) |
gg mes aaaa hh:mi:ss:mmmAM In questo stile, mes è una rappresentazione unicode multi token Hijri del nome completo del mese. Questo valore non sarà reso correttamente in un'installazione US predefinita di SSMS. |
- |
131 (2) |
Hijri (5) |
gg/mm/aaaa hh:mi:ss:mmmAM |
1 Questi valori di stile restituiscono risultati non deterministici. Include tutti gli stili (yy) (senza secolo) e un subset di stili (yyyy) (con il secolo).
2 I valori predefiniti (style 0 o 100, 9 o 109, 13 o 113, 20 o 120 e 21 o 121) restituiscono sempre il secolo (aaaa).
3 Input quando viene eseguita la conversione nel tipo di dati datetime, output quando viene eseguita la conversione nel tipo di dati carattere.
4 Progettato per l'utilizzo in XML. Per le conversioni di dati di tipo datetime o smalldatetime in dati di tipo carattere, il formato di output corrisponde a quello indicato nella tabella.
5 Hijri è un sistema di calendario con diverse varianti. In SQL Server viene usato l'algoritmo kuwaitiano.
.gif "Nota importante") Importante |
|---|
Per impostazione predefinita, SQL Server interpreta anni a due cifre in base a un anno di cambio data pari a 2049, ovvero l'anno a due cifre 49 è interpretato come 2049 mentre l'anno a due cifre 50 è interpretato come 1950. Numerose applicazioni client, ad esempio quelle basate su oggetti di automazione, utilizzano il 2030 come anno di cambio data. In SQL Server è disponibile l'opzione di configurazione two digit year cutoff che consente di modificare l'anno di cambio data usato in SQL Server per una gestione coerente delle date. È consigliabile specificare l'anno nel formato a quattro cifre. |
6 Supportato solo per il cast di dati dal tipo carattere al tipo di dati datetime o smalldatetime. In caso di cast dei dati di tipo carattere che rappresentano solo componenti di data o di ora al tipo di dati datetime o smalldatetime, il componente di ora non specificato viene impostato su 00.00.00,000 e il componente di data non specificato viene impostato su 01-01-1900.
7L'indicatore di fuso orario facoltativo Z viene usato per semplificare il mapping tra i valori datetime XML con informazioni sul fuso orario e i valori SQL Server datetime senza fuso orario. Z è l'indicatore per UTC-0 del fuso orario. Gli altri fusi orari sono indicati con il valore di offset HH:MM nella direzione + o -. Ad esempio: 2006-12-12T23:45:12-08:00.
Quando si convertono dati di tipo smalldatetime in dati di tipo carattere, gli stili che includono secondi o millisecondi visualizzano una serie di zeri. Quando si esegue la conversione di valori datetime o smalldatetime, è possibile troncare le parti della data non desiderate specificando la lunghezza appropriata per il tipo di dati char o varchar.
Quando si esegue la conversione in datetimeoffset da dati di tipo carattere con uno stile che include un'ora, al risultato viene aggiunta una differenza di fuso orario.
Stili float e real
Quando expression è di tipo float o real, style può assumere uno dei valori indicati nella tabella seguente. Gli altri valori vengono elaborati come 0.
Valore |
Output |
|---|---|
0 (predefinito) |
Al massimo 6 cifre. Usare questo valore nella notazione scientifica, quando è appropriato. |
1 |
Sempre 8 cifre. Usare questo valore nella notazione scientifica. |
2 |
Sempre 16 cifre. Usare questo valore nella notazione scientifica. |
126, 128, 129 |
Incluso per motivi di compatibilità con le versioni precedenti. Potrebbe diventare deprecato in una versione futura. |
Stili money e smallmoney
Quando expression è di tipo money o smallmoney, style può assumere uno dei valori indicati nella tabella seguente. Gli altri valori vengono elaborati come 0.
Valore |
Output |
|---|---|
0 (predefinito) |
Nessun separatore delle migliaia a sinistra del separatore decimale e due cifre a destra del separatore decimale, ad esempio 4235,98. |
1 |
Separatore delle migliaia ogni tre cifre a sinistra del separatore decimale e due cifre a destra del separatore decimale, ad esempio 3.510,92. |
2 |
Nessun separatore delle migliaia a sinistra del separatore decimale e quattro cifre a destra del separatore decimale, ad esempio 4235,9819. |
126 |
Equivalente allo stile 2 in caso di conversione in char(n) o varchar(n) |
Stili xml
Quando expression è di tipo xml, style può assumere uno dei valori indicati nella tabella seguente. Gli altri valori vengono elaborati come 0.
Valore |
Output |
|---|---|
0 (predefinito) |
Viene usato il comportamento di analisi predefinito, ovvero vengono eliminati gli spazi vuoti non significativi e non vengono consentiti subset DTD interni.
|
1 |
Mantiene gli spazi vuoti non significativi. Con questa impostazione, il comportamento predefinito di xml:space è equivalente a xml:space="preserve". |
2 |
Abilita l'elaborazione limitata di subset DTD interni. Se abilitata, il server può usare le informazioni seguenti disponibili in un subset DTD intero per eseguire operazioni di analisi senza convalida.
Il parser ignorerà i subset DTD esterni. Non valuta, inoltre, la dichiarazione XML per verificare se l'attributo standalone è impostato su yes o no, ma analizza l'istanza XML come se fosse un documento autonomo. |
3 |
Mantiene gli spazi vuoti non significativi e consente l'elaborazione limitata di subset DTD interni. |
Stili binary
Quando expression è di tipo binary(n), varbinary(n), char(n) o varchar(n), style può assumere uno dei valori indicati nella tabella seguente. I valori dello stile non elencati nella tabella restituiscono un errore.
Valore |
Output |
|---|---|
0 (predefinito) |
Converte caratteri ASCII in byte binari e viceversa. Ogni carattere o byte viene convertito in base allo schema 1:1. Se data_type è un tipo binario, a sinistra del risultato vengono aggiunti i caratteri 0x. |
1, 2 |
Se data_type è un tipo binario, l'espressione deve essere un'espressione di caratteri. L'espressione expression deve essere costituita da un numero pari di cifre esadecimali (0, 1 2, 3 4, 5 6, 7 8, 9 A, B, C, D E, F, a, b, c, d, e, f). Se style è impostato su 1, i caratteri 0x devono essere i primi due caratteri dell'espressione. Se l'espressione contiene un numero di caratteri dispari o se un carattere qualsiasi non è valido, viene generato un errore. Se la lunghezza dell'espressione convertita è maggiore della lunghezza di data_type, il risultato verrà troncato a destra. A data_types a lunghezza fissa maggiori del risultato convertito verranno aggiunti zero a destra del risultato stesso. Se data_type è un tipo di carattere, l'espressione deve essere binaria. Ogni carattere binario viene convertito in due caratteri esadecimali. Se la lunghezza dell'espressione convertita è maggiore di quella di data_type, verrà troncata a destra. Se data_type è un tipo di carattere di dimensioni fisse e la lunghezza del risultato convertito è minore di quella di data_type, a destra dell'espressione convertita vengono aggiunti spazi per mantenere un numero pari di cifre esadecimali. Se style è uguale a 1, a sinistra del risultato convertito verranno aggiunti i caratteri 0x. |
Conversioni implicite
Le conversioni implicite sono conversioni eseguite senza specificare la funzione CAST o CONVERT. Le conversioni esplicite sono conversioni per cui è necessario specificare la funzione CAST o CONVERT. Nella figura seguente vengono illustrate le conversioni di tipi di dati esplicite e implicite consentite per i tipi di dati di sistema di SQL Server. Questi sono xml, bigint e sql_variant. Non è possibile eseguire una conversione implicita in un'assegnazione dal tipo di dati sql_variant, ma è possibile eseguire una conversione implicita verso il tipo di dati sql_variant.
.gif "Suggerimento") Suggerimento |
|---|
Questo grafico è disponibile come file PDF scaricabile dall'Area download Microsoft. |
.gif "Tabella di conversione dei tipi di dati")
Quando si esegue la conversione tra datetimeoffset e i tipi di dati character char, varchar, nchar e nvarchar la parte relativa alla differenza di fuso orario convertita deve essere sempre costituita da cifre doppie sia per HH che per MM, ad esempio -08:00.
[!NOTA]
Poiché i dati Unicode utilizzano sempre un numero pari di byte, prestare attenzione nella conversione tra dati di tipo binary o varbinary e tipi di dati supportati da Unicode. La conversione seguente, ad esempio, non restituisce il valore esadecimale 41, bensì 4100: SELECT CAST(CAST(0x41 AS nvarchar) AS varbinary).
Tipi di dati per valori di grandi dimensioni
Per quanto riguarda le conversioni implicite ed esplicite, i tipi di dati per valori di grandi dimensioni si comportano come i tipi di dati per valori di dimensioni minori, nello specifico i tipi di dati varchar, nvarchar e varbinary. Considerare, tuttavia, le linee guida seguenti:
La conversione dal tipo di dati image al tipo di dati varbinary(max) e viceversa è una conversione implicita, così come sono conversioni implicite quelle tra i tipi di dati text e varchar(max), e ntext e nvarchar(max).
La conversione da tipi di dati per valori di grandi dimensioni, ad esempio varchar(max), a tipi di dati per valori di dimensioni minori, ad esempio varchar, è una conversione implicita, ma si verifica un troncamento se le dimensioni del valore di grandi dimensioni sono eccessive rispetto alla lunghezza specificata per il tipo di dati di dimensioni minori.
La conversione da varchar, nvarchar o varbinary nei corrispondenti tipi di dati per valori di grandi dimensioni viene eseguita in modo implicito.
La conversione dal tipo di dati sql_variant in tipi di dati per valori di grandi dimensioni è una conversione esplicita.
Non è possibile convertire i tipi di dati per valori di grandi dimensioni nel tipo di dati sql_variant.
Per altre informazioni sulla conversione dal tipo di dati xml, vedere Creare istanze di dati XML.
Tipo di dati XML
Quando si esegue il cast esplicito o implicito del tipo di dati xml a un tipo string o binary, il contenuto del tipo di dati xml viene serializzato in base a un set di regole. Per informazioni su tali regole, vedere Definire la serializzazione di dati XML. Per informazioni sulla conversione di altri tipi di dati nel tipo xml, vedere Creare istanze di dati XML.
Tipi di dati text e image
La conversione automatica del tipo di dati non è supportata per i tipi di dati text e image. È possibile convertire in modo esplicito dati di tipo text in dati di tipo carattere e dati di tipo image in dati di tipo binary o varbinary, ma la lunghezza massima è di 8000 byte. Se si tenta di eseguire una conversione non corretta, ad esempio se si tenta di convertire un'espressione di tipo carattere contenente lettere in un tipo int, SQL Server restituisce un messaggio di errore.
Regole di confronto per l'output
Quando sia l'output che l'input di CAST o CONVERT sono stringhe di caratteri, le regole di confronto e la relativa etichetta dell'output corrispondono alle regole di confronto e alla relativa etichetta dell'input. Se l'input non è una stringa di caratteri, all'output sono associate le regole di confronto predefinite del database e un'etichetta delle regole di confronto a cui possono essere assegnati valori predefiniti. Per altre informazioni, vedere Precedenza delle regole di confronto (Transact-SQL).
Per assegnare all'output regole di confronto diverse, applicare la clausola COLLATE all'espressione risultante della funzione CAST o CONVERT. Ad esempio:
SELECT CAST('abc' AS varchar(5)) COLLATE French_CS_AS
Troncamento e arrotondamento dei risultati
Quando si esegue la conversione di espressioni di tipo carattere o binarie (char, nchar, nvarchar, varchar, binary o varbinary) in un'espressione con un tipo di dati diverso, i dati possono venire troncati o visualizzati solo parzialmente oppure viene restituito un errore per segnalare che il risultato è troppo breve per essere visualizzato. I risultati delle conversioni in dati di tipo char, varchar, nchar, nvarchar, binary e varbinary vengono troncati, ad eccezione delle conversioni riportate nella tabella seguente.
Tipo di dati di origine |
Tipo di dati di destinazione |
Risultato |
|---|---|---|
int, smallint o tinyint |
char |
* |
|
varchar |
* |
|
nchar |
E |
|
nvarchar |
E |
money, smallmoney, numeric, decimal, float o real |
char |
E |
|
varchar |
E |
|
nchar |
E |
|
nvarchar |
E |
* = Risultato di lunghezza insufficiente per essere visualizzato. E = Viene restituito un errore perché la lunghezza del risultato è insufficiente per la visualizzazione.
Nelle operazioni di conversione viene garantita la restituzione di valori uguali in versioni diverse di SQL Server solo quando un tipo di dati viene convertito in un altro tipo di dati e quindi riconvertito nel tipo di dati iniziale. Nell'esempio seguente viene illustrata una conversione di questo tipo:
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));
[!NOTA]
Evitare di costruire valori di tipo binary e di convertirli in un tipo di dati della categoria dei tipi numerici. SQL Server non garantisce che il risultato della conversione di un tipo di dati decimal o numeric nel tipo binary sia uguale in versioni diverse di SQL Server.
Nell'esempio seguente viene illustrata un'espressione troppo breve per essere visualizzata.
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;
Set di risultati:
FirstName LastName Title Sick Leave
--------- ------------- ------- --------
Ken Sanchez NULL *
Terri Duffy NULL *
Roberto Tamburello NULL *
Rob Walters NULL *
Gail Erickson Ms. *
(5 row(s) affected)
Quando si convertono tipi di dati con un numero di cifre decimali diverso, in alcuni casi il valore risultante viene troncato e in altri viene arrotondato. Nella tabella seguente viene illustrato questo comportamento.
Da |
in |
Comportamento |
|---|---|---|
numeric |
numeric |
Round |
numeric |
int |
Troncamento |
numeric |
money |
Round |
money |
int |
Round |
money |
numeric |
Round |
float |
int |
Troncamento |
float |
numeric |
Round La conversione dei valori float che utilizzano decimal o numeric come notazione scientifica è limitata solo ai valori di precisione a 17 cifre. Tutti i valori con precisione maggiore di 17 vengono arrotondati a zero. |
float |
datetime |
Round |
datetime |
int |
Round |
Il risultato, ad esempio, della conversione seguente è 10:
SELECT CAST(10.6496 AS int);
Se si esegue una conversione di tipi di dati in cui il tipo di destinazione prevede un numero di decimali minore rispetto al tipo di origine, il valore viene arrotondato. Il risultato, ad esempio, della conversione seguente è $10.3497:
SELECT CAST(10.3496847 AS money);
SQL Server restituisce un messaggio di errore quando i dati non numerici char, nchar, varchar o i dati nvarchar vengono convertiti in int, float, numeric o decimal. SQL Server restituisce un errore anche quando una stringa vuota (" ") viene convertita in numeric o decimal.
Alcune conversioni dei tipi datetime sono non deterministiche in SQL Server 2005 e versioni successive.
In SQL Server 2000 le conversioni da stringa al tipo datetime sono contrassegnate come deterministiche. Fanno tuttavia eccezione gli stili elencati nella tabella seguente, Per questi stili, le conversioni dipendono dalle impostazioni della lingua. In SQL Server 2005 e versioni successive queste conversioni vengono contrassegnate come non deterministiche.
Nella tabella seguente vengono elencati gli stili per i quali la conversione da stringa al tipo datetime è di tipo non deterministico.
Tutti gli stili inferiori a 1001 |
106 |
107 |
109 |
113 |
130 |
1 Ad eccezione degli stili 20 e 21
Caratteri supplementari (coppie di surrogati)
A partire da SQL Server 2012, se si utilizzano le regole di confronto per caratteri supplementari (SC), un'operazione CAST da nchar o nvarchar a un tipo nchar o nvarchar di lunghezza minore non verrà troncato in una coppia di surrogati; verrà troncato prima del carattere supplementare. Ad esempio, nel frammento di codice seguente @x mantiene solo 'ab'. Lo spazio non è sufficiente per mantenere il carattere supplementare.
DECLARE @x NVARCHAR(10) = 'ab' + NCHAR(0x10000);
SELECT CAST (@x AS NVARCHAR(3));
Quando si utilizzano le regole di confronto SC, il comportamento di CONVERT è analogo a quello di CAST.
Supporto della compatibilità
Nelle versioni precedenti di SQL Server lo stile predefinito per le operazioni CAST e CONVERT sui tipi di dati time e datetime2 è 121, tranne quando uno dei due tipi viene usato in un'espressione di colonna calcolata. Per le colonne calcolate, lo stile predefinito è 0. Questo comportamento influisce sulle colonne calcolate quando vengono create o usate nelle query con parametrizzazione automatica o nelle definizioni dei vincoli.
Con il livello di compatibilità 110, lo stile predefinito per le operazioni CAST e CONVERT sui tipi di dati time e datetime2 è sempre 121. Se la query si basa sul comportamento obsoleto, usare un livello di compatibilità inferiore a 110 oppure specificare in modo esplicito lo stile 0 nella query interessata.
L'aggiornamento del database al livello di compatibilità 110 non comporta la modifica dei dati utente archiviati su disco. È necessario correggere manualmente questi dati nel modo opportuno. Se ad esempio si utilizza SELECT INTO per creare una tabella da un'origine che contiene un'espressione di colonna calcolata descritta in precedenza, vengono archiviati i dati (con stile 0), non la definizione della colonna calcolata. Sarà necessario aggiornare manualmente questi dati in base allo stile 121.
Esempi
A.Utilizzo delle funzioni CAST e CONVERT
In ogni esempio vengono recuperati i nomi dei prodotti il cui prezzo contiene un 3 come prima cifra e i relativi valori di ListPrice vengono convertiti nel tipo 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.Utilizzo della funzione CAST con operatori aritmetici
Nell'esempio seguente viene eseguito il calcolo di una sola colonna (Computed) dividendo il totale delle vendite dell'anno in corso (SalesYTD) per la percentuale di commissione (CommissionPCT). Il risultato viene convertito in un tipo di dati int dopo l'arrotondamento al numero intero più prossimo.
USE AdventureWorks2012;
GO
SELECT CAST(ROUND(SalesYTD/CommissionPCT, 0) AS int) AS Computed
FROM Sales.SalesPerson
WHERE CommissionPCT != 0;
GO
Set di risultati:
Computed
------
379753754
346698349
257144242
176493899
281101272
0
301872549
212623750
298948202
250784119
239246890
101664220
124511336
97688107
(14 row(s) affected)
C.Utilizzo della funzione CAST per la concatenazione
Nell'esempio seguente vengono concatenate espressioni non di tipo binario e carattere mediante 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
Set di risultati:
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.Utilizzo di CAST per migliorare la leggibilità del testo
Nell'esempio seguente viene usata la funzione CAST nell'elenco di selezione per convertire la colonna Name in una colonna di tipo 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
Set di risultati:
Name UnitPrice
---------- ---------------------
Long-Sleev 31.2437
Long-Sleev 32.4935
Long-Sleev 49.99
(3 row(s) affected)
E.Utilizzo di CAST con la clausola LIKE
Nell'esempio seguente viene convertita la colonna SalesYTD di tipo money in una colonna di tipo int e quindi in una colonna di tipo char(20), utilizzabile con la clausola 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
Set di risultati:
FirstName LastName SalesYTD SalesPersonID
---------------- ------------------- ---------------- -------------
Tsvi Reiter 2811012.7151 279
Syed Abbas 219088.8836 288
Rachel Valdez 2241204.0424 289
(3 row(s) affected)
F.Utilizzo di CONVERT o CAST con XML tipizzato
Nei diversi esempi seguenti viene illustrato l'utilizzo di CONVERT per eseguire conversioni in XML tipizzato tramite Colonne e tipo di dati XML (SQL Server).
In questo esempio una stringa con spazi vuoti, testo e markup viene convertita in XML tipizzato e vengono rimossi tutti gli spazi vuoti non significativi (spazi vuoti limite tra i nodi):
CONVERT(XML, '<root><child/></root>')
In questo esempio una stringa simile con spazi vuoti, testo e markup viene convertita in XML tipizzato e vengono mantenuti gli spazi vuoti non significativi (spazi vuoti limite tra i nodi):
CONVERT(XML, '<root> <child/> </root>', 1)
In questo esempio viene eseguito il cast di una stringa con spazi vuoti, testo e markup in XML tipizzato:
CAST('<Name><FName>Carol</FName><LName>Elliot</LName></Name>' AS XML)
Per altri esempi, vedere Creare istanze di dati XML.
G.Utilizzo di CAST e CONVERT con dati datetime
Nell'esempio seguente vengono visualizzate la data e l'ora correnti, viene usato CAST per modificarle in un tipo di dati character e quindi viene usato CONVERT per visualizzarle nel formato ISO 8901.
SELECT
GETDATE() AS UnconvertedDateTime,
CAST(GETDATE() AS nvarchar(30)) AS UsingCast,
CONVERT(nvarchar(30), GETDATE(), 126) AS UsingConvertTo_ISO8601 ;
GO
Set di risultati:
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'esempio seguente rappresenta all'incirca l'opposto dell'esempio precedente. Nell'esempio vengono visualizzate una data e un'ora come dati di tipo carattere, viene usato CAST per modificare i dati di tipo carattere nel tipo di dati datetime e quindi viene usato CONVERT per modificare i dati nel tipo di dati 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
Set di risultati:
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.Utilizzo di CONVERT con dati binari e di tipo carattere
Negli esempi seguenti vengono illustrati i risultati della conversione di dati binari e di tipo carattere utilizzando stili diversi.
--Convert the binary value 0x4E616d65 to a character value.
SELECT CONVERT(char(8), 0x4E616d65, 0) AS [Style 0, binary to character];
Set di risultati:
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];
Set di risultati:
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];
Set di risultati:
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];
Set di risultati:
Style 0, character to binary
----------------------------------
0x4E616D6500000000
(1 row(s) affected)
SELECT CONVERT(binary(4), '0x4E616D65', 1) AS [Style 1, character to binary];
Set di risultati:
Style 1, character to binary
----------------------------------
0x4E616D65
(1 row(s) affected)
SELECT CONVERT(binary(4), '4E616D65', 2) AS [Style 2, character to binary];
Set di risultati:
Style 2, character to binary
----------------------------------
0x4E616D65
(1 row(s) affected)
I.Conversione dei tipi di dati date e time
Il seguente esempio illustra la conversione dei tipi di dati date, time e 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];
Vedere anche
Riferimento
Funzioni di sistema (Transact-SQL)