CAST e CONVERT (Transact-SQL)
Si applica a: 
SQL Server Database SQL di Azure Istanza gestita di SQL di Azure Azure Synapse Analytics Piattaforma di strumenti analitici (PDW) Endpoint di analisi SQL in Microsoft Fabric Warehouse in Microsoft Fabric
Queste funzioni convertono un'espressione da un tipo di dati a un altro.
Sintassi
CAST sintassi:
CAST ( expression AS data_type [ ( length ) ] )
CONVERT sintassi:
CONVERT ( data_type [ ( length ) ] , expression [ , style ] )
Convenzioni relative alla sintassi Transact-SQL
Argomenti
expression
Qualsiasi espressione valida.
data_type
Tipo di dati di destinazione. Include xml, bigint e sql_variant. Non è possibile usare tipi di dati alias.
length
Intero facoltativo che specifica la lunghezza del tipo di dati di destinazione per i tipi di dati che consentono una lunghezza specificata dall'utente. Il valore predefinito è 30.
style
Espressione integer che specifica la modalità di conversione dell'espressione da parte della CONVERT funzione. Per un valore di stile NULL, viene restituito NULL. data_type determina l'intervallo.
Tipi restituiti
Restituisce expression convertito in data_type.
Stili di data e ora
Se il tipo di dati di expression è date o time, style può avere uno dei valori indicati nella tabella seguente. Gli altri valori vengono elaborati come 0. A partire da SQL Server 2012 (11.x), gli unici stili supportati nella conversione dai tipi date e time in datetimeoffset sono 0 o 1. Tutti gli altri stili di conversione restituiscono l'errore 9809.
Nota
SQL Server supporta il formato di data in stile arabo con l'algoritmo kuwaitiano.
| Senza secolo (yy) 1 | Con il secolo (aaaa) | Standard | Input/output 3 |
|---|---|---|---|
| - | 0 o 100 1, 2 | Impostazione predefinita per datetime e smalldatetime | mon dd yyyy hh:miAM (o PM) |
| 1 | 101 | Isole | 1 = mm/dd/yy101 = mm/dd/yyyy |
| 2 | 102 | ANSI | 2 = yy.mm.dd102 = yyyy.mm.dd |
| 3 | 103 | Inglese Regno Unito/Francese | 3 = dd/mm/yy103 = dd/mm/yyyy |
| 4 | 104 | Tedesco | 4 = dd.mm.yy104 = dd.mm.yyyy |
| 5 | 105 | Italiano | 5 = dd-mm-yy105 = dd-mm-yyyy |
| 6 | 106 1 | - | 6 = dd mon yy106 = dd mon yyyy |
| 7 | 107 1 | - | 7 = Mon dd, yy107 = Mon dd, yyyy |
| 8 o 24 | 108 | - | hh:mi:ss |
| - | 9 o 109 1, 2 | Valore predefinito + millisecondi | mon dd yyyy hh:mi:ss:mmmAM (o PM) |
| 10 | 110 | USA | 10 = mm-gg-aa 110 = mm-dd-yyyy |
| 11 | 111 | Giappone | 11 = aa/mm/gg 111 = yyyy/mm/dd |
| 12 | 112 | ISO | 12 = aammgg 112 = yyyymmdd |
| - | 13 o 113 1, 2 | Valore predefinito Europa + millisecondi | dd mon yyyy hh:mi:ss:mmm (24 ore) |
| 14 | 114 | - | hh:mi:ss:mmm (24 ore) |
| - | 20 o 120 2 | ODBC canonico | yyyy-mm-dd hh:mi:ss (24 ore) |
| - | 21 o 25 o 121 2 | Odbc canonico (con millisecondi) predefinito per time, date, datetime2 e datetimeoffset | yyyy-mm-dd hh:mi:ss.mmm (24 ore) |
| 22 | - | Isole | mm/dd/yy hh:mi:ss AM (o PM) |
| - | 23 | ISO8601 | yyyy-mm-dd |
| - | 126 4 | ISO8601 | yyyy-mm-ddThh:mi:ss.mmm (senza spazi) 6 |
| - | 127 8, 9 | ISO8601 con fuso orario Z | yyyy-MM-ddThh:mm:ss.fffZ (senza spazi) 6 |
| - | 130 1, 2 | Hijri 5 | dd mon yyyy hh:mi:ss:mmmAM7 |
| - | 131 2 | Hijri 5 | dd/mm/yyyy hh:mi:ss:mmmAM |
1 Questi valori di stile restituiscono risultati non deterministici. Include tutti gli stili (yysenza secolo) e un subset di stili () (yyyycon secolo).
2 I valori predefiniti (0 o 100, 9 o 109, 13 o 113, 20 o 120, 23 e 21 o 25 o 121) restituiscono sempre il secolo (yyyy).
Importante
Per impostazione predefinita, SQL Server interpreta anni a due cifre in base a un anno di cambio data pari a 2049. Ciò significa che SQL Server interpreta l'anno a due cifre 49 come 2049 e l'anno a due cifre 50 come 1950. Numerose applicazioni client, incluse quelle basate su oggetti di automazione, usano il 2030 come anno di cambio data. SQL Server specifica l'opzione di configurazione del cambio data per anno a due cifre per modificare l'anno di cambio data usato da SQL Server. Ciò consente una gestione coerente delle date. È consigliabile specificare l'anno nel formato a quattro cifre.
3 Input quando viene eseguita la conversione nel tipo di dati datetime, output quando viene eseguita la conversione in dati di tipo carattere.
4 Progettato per l'uso in XML. Per le conversioni di dati di tipo datetime o smalldatetime in dati di tipo carattere, vedere la tabella precedente per il formato di output.
5 Hijri è un sistema di calendario con diverse variazioni. In SQL Server viene usato l'algoritmo kuwaitiano.
6 Per un valore di millisecondi (mmm) pari a 0, il valore della frazione decimale di millisecondi non verrà visualizzato. Ad esempio, il valore 2022-11-07T18:26:20.000 viene visualizzato come 2022-11-07T18:26:20.
7 In questo stile, mon rappresenta una rappresentazione Unicode Hijri multi-token del nome completo del mese. Questo valore non viene eseguito correttamente in un'installazione predefinita degli Stati Uniti di SSMS.
8 È supportato solo quando si esegue il cast da dati di tipo carattere a datetime o smalldatetime. Quando si esegue il cast dei dati di tipo carattere che rappresentano solo componenti di data o ora solo per i tipi di dati datetime o smalldatetime , il componente ora non specificata viene impostato su 00:00:00.000e il componente data non specificato viene impostato su 1900-01-01.
9 Usare l'indicatore Z di fuso orario facoltativo per semplificare il mapping dei valori datetime XML con informazioni sul fuso orario ai valori datetime di SQL Server senza fuso orario. Z indica il fuso orario alle ore UTC-0. L'offset HH:MM + , nella direzione o - , indica altri fusi orari. Ad esempio: 2022-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 da valori datetime o smalldatetime, usare la lunghezza appropriata per il tipo di dati char o varchar per troncare le parti della data superflue.
Quando si esegue la conversione di dati di tipo carattere in datetimeoffset usando uno stile che include un'ora, al risultato viene aggiunta una differenza di fuso orario.
Stili float e real
Se il tipo di dati di expression è float o real, style può avere 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. |
| 3 | Sempre 17 cifre. Usare per la conversione senza perdita di dati. Con questo stile, è garantita la conversione di ogni float Distinct in una stringa di caratteri Distinct. Si applica a: SQL Server 2016 (13.x) e versioni successive e database SQL di Azure. |
| 126, 128, 129 | Incluso per motivi legacy. Non usare questi valori per il nuovo sviluppo. |
Stili money e smallmoney
Se il tipo di dati di expression è money o smallmoney, style può avere 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 Esempio: 4235,98. |
| 1 | Separatore delle migliaia tre cifre a sinistra del separatore decimale e due cifre a destra del separatore decimale Esempio: 3.510,92. |
| 2 | Nessun separatore delle migliaia a sinistra del separatore decimale e quattro cifre a destra del separatore decimale Esempio: 4235,9819. |
| 126 | Equivalente allo stile 2, quando si esegue la conversione in char(n) o varchar(n) |
Stili xml
Se il tipo di dati di expression è xml, style può avere uno dei valori indicati nella tabella seguente. Gli altri valori vengono elaborati come 0.
| Valore | Output |
|---|---|
| 0 (predefinito) | Usare il comportamento di analisi predefinito che elimina spazi vuoti non significativi e non consente un subset DTD interno. Nota: quando si esegue la conversione nel tipo di dati xml, gli spazi vuoti non significativi di SQL Server vengono gestiti diversamente rispetto a XML 1.0. Per altre informazioni, vedere Creare istanze di dati XML. |
| 1 | Mantiene gli spazi vuoti non significativi. Questa impostazione di stile imposta la gestione predefinita xml:space in modo che corrisponda al comportamento di 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. - Vengono applicati i valori predefiniti per gli attributi - I riferimenti alle entità interne vengono risolti ed espansi - Viene controllata la correttezza della sintassi del modello di contenuti DTD Il parser ignora i subset DTD esterni. Inoltre, non valuta la dichiarazione XML per verificare se l'attributo autonomo ha un valore sì o no . Analizza invece l'istanza XML come documento autonomo. |
| 3 | Mantiene gli spazi non significativi e consente l'elaborazione limitata di subset DTD interni. |
Stili binary
Per un'espressione binary(n), char(n), varbinary(n)o varchar(n), lo stile può avere uno dei valori illustrati nella tabella seguente. I valori dello stile non indicati 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 è binario, a sinistra del risultato vengono aggiunti i caratteri 0x. |
| 1, 2 | Se data_tye è binario, l'espressione deve essere un'espressione di caratteri. expression deve includere 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 primi due caratteri dell'espressione devono essere 0x. 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 supera la lunghezza di data_type, il risultato viene troncato a destra. A data_type a lunghezza fissa maggiori del risultato convertito vengono aggiunti zeri a destra del risultato. Un data_type di tipo carattere richiede un'espressione binaria. Ogni carattere binario viene convertito in due caratteri esadecimali. Si supponga che la lunghezza dell'espressione convertita superi la lunghezza di data_type. In questo caso verrà troncata. Se data_type è un tipo di carattere di dimensioni fisse e la lunghezza del risultato convertito è inferiore a quella di data_type, a destra dell'espressione convertita vengono aggiunti spazi per mantenere un numero pari di cifre esadecimali. I caratteri 0x non vengono aggiunti a sinistra del risultato convertito per lo stile 2. |
Conversioni implicite
Le conversioni implicite non richiedono la specifica della CAST funzione o della CONVERT funzione. Le conversioni esplicite richiedono la specifica della CAST funzione o della CONVERT funzione . 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 includono bigint, sql_variant e xml. 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.
Suggerimento
Questo grafico è disponibile nell'Area download Microsoft come file PNG scaricabile.
Il grafico sopra riportato illustra tutte le conversioni esplicite e implicite consentite in SQL Server, ma il tipo di dati risultante della conversione dipende dall'operazione eseguita:
- Per le conversioni esplicite, l'istruzione stessa determina il tipo di dati risultante.
- Per le conversioni implicite, le istruzioni di assegnazione, ad esempio l'impostazione del valore di una variabile o l'inserimento di un valore in una colonna, hanno come risultato il tipo di dati definito dalla dichiarazione di variabile o dalla definizione di colonna.
- Per gli operatori di confronto o altre espressioni, il tipo di dati risultante dipenderà dalle regole di precedenza dei tipi di dati.
Suggerimento
Un esempio pratico degli effetti della precedenza dei tipi di dati nelle conversioni è disponibile più avanti in questa sezione.
Quando si esegue la conversione tra datetimeoffset e i tipi di caratteri char, nchar, nvarchar e varchar, la parte di offset del fuso orario convertito deve avere sempre cifre doppie per e HH MM. Ad esempio: -08:00.
Poiché i dati Unicode usano sempre un numero pari di byte, prestare attenzione nella conversione tra dati di tipo binary o varbinary e tipi di dati supportati da Unicode. Ad esempio, la conversione seguente non restituisce un valore esadecimale pari a 41. Restituisce un valore esadecimale pari a 4100:
SELECT CAST(CAST(0x41 AS nvarchar) AS varbinary);
Per ulteriori informazioni, vedi Supporto per Unicode e regole di confronto.
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, in particolare i tipi di dati nvarchar, varbinary e varchar. Considerare tuttavia queste indicazioni:
- La conversione di image in varbinary(max) e viceversa funziona come conversione implicita, come le conversioni tra text e varchar(max) e ntext e nvarchar(max).
- La conversione di tipi di dati per valori di grandi dimensioni, ad esempio varchar(max), in tipi di dati per valori di dimensioni minori, ad esempio varchar, è una conversione implicita, ma si verifica un troncamento se la dimensione del valore più grande supera la lunghezza specificata per il tipo di dati più piccolo.
- La conversione di varchar, nvarchar o varbinary nei corrispondenti tipi di dati per valori di grandi dimensioni avviene in modo implicito.
- La conversione del tipo di dati sql_variant in tipi di dati per valori di grandi dimensioni è una conversione esplicita.
- I tipi di dati di grandi dimensioni non possono essere convertiti nel tipo di dati sql_variant .
Per altre informazioni sulla conversione del 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 queste regole, vedere Definire la serializzazione di dati XML. Per informazioni sulla conversione di altri tipi di dati nel tipo di dati xml, vedere Creare istanze di dati XML.
Tipi di dati text e image
I tipi di dati text e image non supportano la conversione automatica dei tipi di dati. È 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 convertire un'espressione di tipo carattere contenente lettere in un tipo int, SQL Server restituisce un messaggio di errore.
Regole di confronto di output
Quando le CAST funzioni o CONVERT generano una stringa di caratteri e ricevono un input di stringa di caratteri, l'output ha le stesse regole di confronto e l'etichetta delle regole di confronto dell'input. Se l'input non è una stringa di caratteri, l'output ha le regole di confronto predefinite del database e un'etichetta delle regole di confronto coercible-default. Per altre informazioni, vedere Precedenza delle regole di confronto (Transact-SQL).
Per assegnare regole di confronto diverse all'output, applicare la clausola COLLATE all'espressione di risultato della CAST funzione o CONVERT . Ad esempio:
SELECT CAST('abc' AS varchar(5)) COLLATE French_CS_AS;
Troncamento e arrotondamento dei risultati
Durante la conversione di espressioni di caratteri o binarie (binary, char, nchar, nvarchar, varbinary o varchar) in un'espressione con tipo di dati differente, l'operazione di conversione può troncare i dati di output, visualizzare solo parzialmente i dati di output o restituire un errore. Queste situazioni si verificano se il risultato è troppo breve per essere visualizzato. Le conversioni in dati di tipo binary, char, nchar, nvarchar, varbinary o varchar vengono troncate, 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 |
Troppo breve da visualizzare |
| nchar nvarchar |
Errore 1 | |
| money, smallmoney, numeric, decimal, float o real | char varchar |
Errore 1 |
| nchar nvarchar |
Errore 1 |
1 Errore restituito perché la lunghezza del risultato è troppo breve da visualizzare.
In SQL Server la restituzione degli stessi valori in versioni diverse è garantita solo per le conversioni rount trip, ovvero le conversioni in cui 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));
GO
Avviso
Non costruire valori binari e quindi convertirli in un tipo di dati della categoria di tipi di dati 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 AdventureWorks2022;
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
INNER JOIN Person.Person p
ON e.BusinessEntityID = p.BusinessEntityID
WHERE NOT e.BusinessEntityID > 5;
GO
Il set di risultati è il seguente.
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 SQL Server restituisce un valore troncato e in altri restituisce un valore arrotondato. La tabella che segue illustra questo comportamento.
| Da | Per | Comportamento |
|---|---|---|
| numeric | numeric | Round |
| numeric | int | Truncate |
| numeric | money | Round |
| money | int | Round |
| money | numeric | Round |
| float | int | Truncate |
| float | numeric | Round 1 |
| float | datetime | Round |
| datetime | int | Round |
1 La conversione di valori float che utilizzano la notazione scientifica in decimal o numeric è limitata ai valori di precisione 17 cifre. Tutti i valori con precisione maggiore di 17 vengono arrotondati a zero.
Ad esempio, i valori 10.6496 e -10.6496 potrebbero essere troncati o arrotondati durante la conversione nei tipi int o numeric:
SELECT CAST(10.6496 AS INT) AS trunc1,
CAST(-10.6496 AS INT) AS trunc2,
CAST(10.6496 AS NUMERIC) AS round1,
CAST(-10.6496 AS NUMERIC) AS round2;
I risultati della query sono riportati nella tabella seguente:
| trunc1 | trunc2 | round1 | round2 |
|---|---|---|---|
| 10 | -10 | 11 | -11 |
Se si esegue una conversione di tipi di dati in cui il tipo di destinazione ha un numero di decimali inferiore rispetto al tipo di origine, il valore viene arrotondato. Ad esempio, questa conversione restituisce $10.3497:
SELECT CAST(10.3496847 AS money);
SQL Server restituisce un messaggio di errore quando si convertono dati char, nchar, nvarchar o varchar non numerici in decimal, float, int o numeric. SQL Server restituisce un errore anche quando una stringa vuota (" ") viene convertita in numeric o decimal.
Alcune conversioni di data/ora sono non deterministiche
Gli stili per cui la conversione da stringa al tipo datetime è di tipo non deterministico sono i seguenti:
- Tutti gli stili inferiori a 100 1
- 106
- 107
- 109
- 113
- 130
1 Ad eccezione degli stili 20 e 21
Per altre informazioni, vedere Conversione non deterministica di stringhe di valori letterali in valori DATE.
Caratteri supplementari (coppie di surrogati)
A partire da SQL Server 2012 (11.x), quando si usano regole di confronto carattere supplementare (SC), un'operazione CAST da nchar o nvarchar a un tipo nchar o nvarchar di lunghezza inferiore non tronca all'interno di una coppia di surrogati. Verrà invece troncato prima del carattere supplementare. Ad esempio, nel frammento di codice seguente @x mantiene solo 'ab'. Non c'è spazio sufficiente per contenere il carattere supplementare.
DECLARE @x NVARCHAR(10) = 'ab' + NCHAR(0x10000);
SELECT CAST(@x AS NVARCHAR(3));
Quando si usano le regole di confronto SC, il comportamento di CONVERT è analogo a quello di CAST. Per altre informazioni, vedere Regole di confronto e supporto Unicode - Caratteri supplementari.
Informazioni sulla compatibilità
Nelle versioni precedenti di SQL Server, lo stile predefinito per CAST le operazioni 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 e superiore, le CAST operazioni e CONVERT sui tipi di dati time e datetime2 hanno sempre 121 come stile predefinito. Se una 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.
| Valore di Livello di compatibilità | Stile predefinito per CAST e CONVERT 1 |
Stile predefinito per la colonna calcolata |
|---|---|---|
| <110 | 121 | 0 |
| > = 110 | 121 | 121 |
1 Ad eccezione delle colonne calcolate
L'aggiornamento del database al livello di compatibilità 110 e versioni successive non modificherà i dati utente archiviati su disco. È necessario correggere manualmente questi dati nel modo opportuno. Se ad esempio si usa 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
R. Usare sia CAST che CONVERT
Questi esempi recuperano il nome del prodotto, per i prodotti con un 3 valore come prima cifra del prezzo di listino e convertono i valori ListPrice in int.
Usare CAST:
USE AdventureWorks2022;
GO
SELECT SUBSTRING(Name, 1, 30) AS ProductName,
ListPrice
FROM Production.Product
WHERE CAST(ListPrice AS INT) LIKE '33%';
GO
Usare CONVERT:
USE AdventureWorks2022;
GO
SELECT SUBSTRING(Name, 1, 30) AS ProductName,
ListPrice
FROM Production.Product
WHERE CONVERT(INT, ListPrice) LIKE '33%';
GO
Il set di risultati è il seguente. Il set di risultati di esempio è lo stesso per e CAST CONVERT.
ProductName ListPrice
------------------------------ ---------------------
LL Road Frame - Black, 58 337.22
LL Road Frame - Black, 60 337.22
LL Road Frame - Black, 62 337.22
LL Road Frame - Red, 44 337.22
LL Road Frame - Red, 48 337.22
LL Road Frame - Red, 52 337.22
LL Road Frame - Red, 58 337.22
LL Road Frame - Red, 60 337.22
LL Road Frame - Red, 62 337.22
LL Road Frame - Black, 44 337.22
LL Road Frame - Black, 48 337.22
LL Road Frame - Black, 52 337.22
Mountain-100 Black, 38 3374.99
Mountain-100 Black, 42 3374.99
Mountain-100 Black, 44 3374.99
Mountain-100 Black, 48 3374.99
HL Road Front Wheel 330.06
LL Touring Frame - Yellow, 62 333.42
LL Touring Frame - Blue, 50 333.42
LL Touring Frame - Blue, 54 333.42
LL Touring Frame - Blue, 58 333.42
LL Touring Frame - Blue, 62 333.42
LL Touring Frame - Yellow, 44 333.42
LL Touring Frame - Yellow, 50 333.42
LL Touring Frame - Yellow, 54 333.42
LL Touring Frame - Yellow, 58 333.42
LL Touring Frame - Blue, 44 333.42
HL Road Tire 32.60
(28 rows affected)
B. Usare CAST con operatori aritmetici
In questo esempio 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). Questo valore viene arrotondato al numero intero più vicino e quindi CAST a un tipo di dati int .
USE AdventureWorks2022;
GO
SELECT CAST(ROUND(SalesYTD / CommissionPCT, 0) AS INT) AS Computed
FROM Sales.SalesPerson
WHERE CommissionPCT != 0;
GO
Il set di risultati è il seguente.
Computed
------
379753754
346698349
257144242
176493899
281101272
0
301872549
212623750
298948202
250784119
239246890
101664220
124511336
97688107
(14 row(s) affected)
C. Usare CAST per concatenare
In questo esempio vengono concatenate espressioni non carattere usando CAST. Usa il database AdventureWorksDW2022.
SELECT 'The list price is ' + CAST(ListPrice AS VARCHAR(12)) AS ListPrice
FROM dbo.DimProduct
WHERE ListPrice BETWEEN 350.00 AND 400.00;
Il set di risultati è il seguente.
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
D. Usare CAST per produrre testo più leggibile
In questo esempio viene CAST utilizzato nell'elenco SELECT per convertire la Name colonna in una colonna char(10). Usa il database AdventureWorksDW2022.
SELECT DISTINCT CAST(EnglishProductName AS CHAR(10)) AS Name,
ListPrice
FROM dbo.DimProduct
WHERE EnglishProductName LIKE 'Long-Sleeve Logo Jersey, M';
GO
Il set di risultati è il seguente.
Name ListPrice
---------- ---------
Long-Sleev 31.2437
Long-Sleev 32.4935
Long-Sleev 49.99
E. Usare CAST con la clausola LIKE
In questo esempio i valori di money colonna SalesYTD vengono convertiti in tipo di dati int e quindi nel tipo di dati char(20), in modo che la LIKE clausola possa usarla.
USE AdventureWorks2022;
GO
SELECT p.FirstName,
p.LastName,
s.SalesYTD,
s.BusinessEntityID
FROM Person.Person AS p
INNER JOIN Sales.SalesPerson AS s
ON p.BusinessEntityID = s.BusinessEntityID
WHERE CAST(CAST(s.SalesYTD AS INT) AS CHAR(20)) LIKE '2%';
GO
Il set di risultati è il seguente.
FirstName LastName SalesYTD BusinessEntityID
---------------- ------------------- ---------------- -------------
Tsvi Reiter 2811012.7151 279
Syed Abbas 219088.8836 288
Rachel Valdez 2241204.0424 289
(3 row(s) affected)
F. Usare CONVERT o CAST con XML tipizzato
Questi esempi illustrano l'uso di CONVERT per convertire i dati in xml tipizzato usando il tipo di dati XML e le colonne (SQL Server).
In questo esempio una stringa con spazi vuoti, testo e markup viene convertita in XML tipizzato e vengono rimossi tutti gli spazi non significativi (spazi vuoti limite tra i nodi):
SELECT 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):
SELECT 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:
SELECT CAST('<Name><FName>Carol</FName><LName>Elliot</LName></Name>' AS XML)
Per altri esempi, vedere Creare istanze di dati XML.
G. Usare CAST e CONVERT con dati datetime
Iniziando con i valori GETDATE(), questo esempio visualizza la data e l'ora correnti, usa CAST per modificarle in dati di tipo carattere e quindi usa CONVERT per visualizzare data e ora nel formato ISO 8601.
SELECT GETDATE() AS UnconvertedDateTime,
CAST(GETDATE() AS NVARCHAR(30)) AS UsingCast,
CONVERT(NVARCHAR(30), GETDATE(), 126) AS UsingConvertTo_ISO8601;
GO
Il set di risultati è il seguente.
UnconvertedDateTime UsingCast UsingConvertTo_ISO8601
----------------------- ---------------------- ------------------------------
2022-04-18 09:58:04.570 Apr 18 2022 9:58AM 2022-04-18T09:58:04.570
(1 row(s) affected)
Questo esempio rappresenta all'incirca l'opposto dell'esempio precedente. Questo esempio visualizza una data e un'ora come dati di tipo carattere, usa CAST per modificare i dati di tipo carattere nel tipo di dati datetime e quindi usa CONVERT per modificare i dati di tipo carattere 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
Il set di risultati è il seguente.
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. Usare CONVERT con dati binari e di tipo carattere
In questi esempi 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];
Il set di risultati è il seguente.
Style 0, binary to character
----------------------------
Name
(1 row(s) affected)
Questo esempio indica che Style 1 è in grado di forzare il troncamento del risultato. I caratteri 0x nel set di risultati forzano il troncamento.
SELECT CONVERT(CHAR(8), 0x4E616d65, 1) AS [Style 1, binary to character];
Il set di risultati è il seguente.
Style 1, binary to character
------------------------------
0x4E616D
(1 row(s) affected)
Questo esempio mostra che Style 2 non tronca il risultato, perché il risultato non include i caratteri 0x.
SELECT CONVERT(CHAR(8), 0x4E616d65, 2) AS [Style 2, binary to character];
Il set di risultati è il seguente.
Style 2, binary to character
------------------------------
4E616D65
(1 row(s) affected)
Convertire il valore di carattere 'Name' in valore binario.
SELECT CONVERT(BINARY(8), 'Name', 0) AS [Style 0, character to binary];
Il set di risultati è il seguente.
Style 0, character to binary
----------------------------
0x4E616D6500000000
(1 row(s) affected)
SELECT CONVERT(BINARY(4), '0x4E616D65', 1) AS [Style 1, character to binary];
Il set di risultati è il seguente.
Style 1, character to binary
----------------------------
0x4E616D65
(1 row(s) affected)
SELECT CONVERT(BINARY(4), '4E616D65', 2) AS [Style 2, character to binary];
Il set di risultati è il seguente.
Style 2, character to binary
----------------------------------
0x4E616D65
(1 row(s) affected)
I. Convertire i tipi di dati di data e ora
In questo esempio viene illustrata 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];
Assicurarsi che i valori si trovino all'interno di un intervallo compatibile quando si valuta una conversione da datetime a datetime o datetime2. Il valore minimo dell'anno per datetime è 1753, mentre il valore minimo dell'anno è 0001 per date e datetime2.
DECLARE @d1 DATE, @dt1 DATETIME , @dt2 DATETIME2
SET @d1 = '1492-08-03'
--This is okay; Minimum YYYY for DATE is 0001
SET @dt2 = CAST(@d1 AS DATETIME2)
--This is okay; Minimum YYYY for DATETIME2 IS 0001
SET @dt1 = CAST(@d1 AS DATETIME)
--This will error with (Msg 242) "The conversion of a date data type to a datetime data type resulted in an out-of-range value."
--Minimum YYYY for DATETIME is 1753
J. Usare CONVERT con dati datetime in formati diversi
A partire da valori GETDATE(), questo esempio usa CONVERT per visualizzare tutti gli stili di data e ora nella sezione Stili di data e ora di questo articolo.
| N. di formato | Query di esempio | Risultato di esempio |
|---|---|---|
| 0 | SELECT CONVERT(NVARCHAR, GETDATE(), 0) |
Ago 23 2019 1:39PM |
| 1 | SELECT CONVERT(NVARCHAR, GETDATE(), 1) |
08/23/19 |
| 2 | SELECT CONVERT(NVARCHAR, GETDATE(), 2) |
19.08.23 |
| 3 | SELECT CONVERT(NVARCHAR, GETDATE(), 3) |
23/08/19 |
| 4 | SELECT CONVERT(NVARCHAR, GETDATE(), 4) |
23.08.19 |
| 5 | SELECT CONVERT(NVARCHAR, GETDATE(), 5) |
23-08-19 |
| 6 | SELECT CONVERT(NVARCHAR, GETDATE(), 6) |
23 ago 19 |
| 7 | SELECT CONVERT(NVARCHAR, GETDATE(), 7) |
Ago 23, 19 |
| 8 o 24 o 108 | SELECT CONVERT(NVARCHAR, GETDATE(), 8) |
13:39:17 |
| 9 o 109 | SELECT CONVERT(NVARCHAR, GETDATE(), 9) |
Ago 23 2019 1:39:17:090PM |
| 10 | SELECT CONVERT(NVARCHAR, GETDATE(), 10) |
08-23-19 |
| 11 | SELECT CONVERT(NVARCHAR, GETDATE(), 11) |
19/08/23 |
| 12 | SELECT CONVERT(NVARCHAR, GETDATE(), 12) |
190823 |
| 13 o 113 | SELECT CONVERT(NVARCHAR, GETDATE(), 13) |
23 ago 2019 13:39:17:090 |
| 14 o 114 | SELECT CONVERT(NVARCHAR, GETDATE(), 14) |
13:39:17:090 |
| 20 o 120 | SELECT CONVERT(NVARCHAR, GETDATE(), 20) |
2019-08-23 13:39:17 |
| 21 o 25 o 121 | SELECT CONVERT(NVARCHAR, GETDATE(), 21) |
2019-08-23 13:39:17.090 |
| 22 | SELECT CONVERT(NVARCHAR, GETDATE(), 22) |
08/23/19 1:39:17 PM |
| 23 | SELECT CONVERT(NVARCHAR, GETDATE(), 23) |
2019-08-23 |
| 101 | SELECT CONVERT(NVARCHAR, GETDATE(), 101) |
08/23/2019 |
| 102 | SELECT CONVERT(NVARCHAR, GETDATE(), 102) |
2019.08.23 |
| 103 | SELECT CONVERT(NVARCHAR, GETDATE(), 103) |
23/08/2019 |
| 104 | SELECT CONVERT(NVARCHAR, GETDATE(), 104) |
23.08.2019 |
| 105 | SELECT CONVERT(NVARCHAR, GETDATE(), 105) |
23-08-2019 |
| 106 | SELECT CONVERT(NVARCHAR, GETDATE(), 106) |
23 ago 2019 |
| 107 | SELECT CONVERT(NVARCHAR, GETDATE(), 107) |
Ago 23, 2019 |
| 110 | SELECT CONVERT(NVARCHAR, GETDATE(), 110) |
08-23-2019 |
| 111 | SELECT CONVERT(NVARCHAR, GETDATE(), 111) |
2019/08/23 |
| 112 | SELECT CONVERT(NVARCHAR, GETDATE(), 112) |
20190823 |
| 113 | SELECT CONVERT(NVARCHAR, GETDATE(), 113) |
23 ago 2019 13:39:17.090 |
| 120 | SELECT CONVERT(NVARCHAR, GETDATE(), 120) |
2019-08-23 13:39:17 |
| 121 | SELECT CONVERT(NVARCHAR, GETDATE(), 121) |
2019-08-23 13:39:17.090 |
| 126 | SELECT CONVERT(NVARCHAR, GETDATE(), 126) |
2019-08-23T13:39:17.090 |
| 127 | SELECT CONVERT(NVARCHAR, GETDATE(), 127) |
2019-08-23T13:39:17.090 |
| 130 | SELECT CONVERT(NVARCHAR, GETDATE(), 130) |
22 ذو الحجة 1440 1:39:17.090P |
| 131 | SELECT CONVERT(NVARCHAR, GETDATE(), 131) |
22/12/1440 1:39:17.090PM |
K. Effetti della precedenza dei tipi di dati nelle conversioni consentite
Nell'esempio seguente viene definita una variabile di tipo varchar(10), viene assegnato un valore intero alla variabile e quindi viene selezionata una concatenazione della variabile con una stringa.
DECLARE @string VARCHAR(10);
SET @string = 1;
SELECT @string + ' is a string.' AS Result
Il set di risultati è il seguente.
Result
-----------------------
1 is a string.
Il valore int di 1 è stato convertito in varchar.
Questo esempio mostra una query simile, usando invece una variabile int :
DECLARE @notastring INT;
SET @notastring = '1';
SELECT @notastring + ' is not a string.' AS Result
In questo caso, l'istruzione SELECT genererà l'errore seguente:
Msg 245, Level 16, State 1, Line 3
Conversion failed when converting the varchar value ' is not a string.' to data type int.
Per valutare l'espressione @notastring + ' is not a string.', SQL Server deve seguire le regole di precedenza dei tipi di dati per completare la conversione implicita prima che il risultato dell'espressione possa essere calcolato. Poiché int ha una precedenza superiore a varchar, SQL Server tenta di convertire la stringa in un numero intero e non riesce perché questa stringa non può essere convertita in un numero intero.
Se si specifica una stringa che può essere convertita, l'istruzione ha esito positivo, come nell'esempio seguente:
DECLARE @notastring INT;
SET @notastring = '1';
SELECT @notastring + '1'
In questo caso, la stringa '1' può essere convertita nel valore intero 1, quindi questa istruzione SELECT restituirà il valore 2. Quando i tipi di dati forniti sono integer, l'operatore + diventa operatore matematico di addizione, anziché una concatenazione di stringhe.
Esempi: Azure Synapse Analytics e Piattaforma di strumenti analitici (PDW)
.L Usare CAST e CONVERT
In questo esempio viene recuperato il nome del prodotto per i prodotti con un 3 valore nella prima cifra del prezzo di listino e viene convertito in int.ListPrice Usa il AdventureWorksDW2022 database.
SELECT EnglishProductName AS ProductName, ListPrice
FROM dbo.DimProduct
WHERE CAST(ListPrice AS int) LIKE '3%';
In questo esempio viene illustrata la stessa query, usando CONVERT invece di CAST. Usa il database AdventureWorksDW2022.
SELECT EnglishProductName AS ProductName, ListPrice
FROM dbo.DimProduct
WHERE CONVERT(INT, ListPrice) LIKE '3%';
M. Usare CAST con operatori aritmetici
Questo esempio calcola un unico valore di colonna dividendo il prezzo unitario del prodotto (UnitPrice) per la percentuale di sconto (UnitPriceDiscountPct). Questo risultato viene quindi arrotondato al numero intero più vicino e infine convertito in un tipo di dati int . In questo esempio viene utilizzato il database AdventureWorksDW2022.
SELECT ProductKey, UnitPrice,UnitPriceDiscountPct,
CAST(ROUND (UnitPrice*UnitPriceDiscountPct,0) AS int) AS DiscountPrice
FROM dbo.FactResellerSales
WHERE SalesOrderNumber = 'SO47355'
AND UnitPriceDiscountPct > .02;
Il set di risultati è il seguente.
ProductKey UnitPrice UnitPriceDiscountPct DiscountPrice
---------- --------- -------------------- -------------
323 430.6445 0.05 22
213 18.5043 0.05 1
456 37.4950 0.10 4
456 37.4950 0.10 4
216 18.5043 0.05 1
N. Usare CAST con la clausola LIKE
Questo esempio converte nella colonna money il valore ListPrice in un tipo int e quindi in un tipo char(20) in modo che possa essere usato dalla clausola LIKE. In questo esempio viene utilizzato il database AdventureWorksDW2022.
SELECT EnglishProductName AS Name, ListPrice
FROM dbo.DimProduct
WHERE CAST(CAST(ListPrice AS INT) AS CHAR(20)) LIKE '2%';
.O Usare CAST e CONVERT con dati datetime
Questo esempio visualizza la data e l'ora correnti, usa CAST per modificare la data e l'ora correnti in un tipo di dati carattere e infine usa la CONVERT data e l'ora nel formato ISO 8601. In questo esempio viene utilizzato il database AdventureWorksDW2022.
SELECT TOP(1)
SYSDATETIME() AS UnconvertedDateTime,
CAST(SYSDATETIME() AS NVARCHAR(30)) AS UsingCast,
CONVERT(NVARCHAR(30), SYSDATETIME(), 126) AS UsingConvertTo_ISO8601
FROM dbo.DimCustomer;
Il set di risultati è il seguente.
UnconvertedDateTime UsingCast UsingConvertTo_ISO8601
--------------------- --------------------------- ---------------------------
07/20/2010 1:44:31 PM 2010-07-20 13:44:31.5879025 2010-07-20T13:44:31.5879025
Questo esempio rappresenta all'incirca l'opposto dell'esempio precedente. Questo esempio visualizza una data e un'ora come dati di tipo carattere, usa CAST per modificare i dati di tipo carattere nel tipo di dati datetime e quindi usa CONVERT per modificare i dati di tipo carattere nel tipo di dati datetime . In questo esempio viene utilizzato il database AdventureWorksDW2022.
SELECT TOP(1)
'2010-07-25T13:50:38.544' AS UnconvertedText,
CAST('2010-07-25T13:50:38.544' AS DATETIME) AS UsingCast,
CONVERT(DATETIME, '2010-07-25T13:50:38.544', 126) AS UsingConvertFrom_ISO8601
FROM dbo.DimCustomer;
Il set di risultati è il seguente.
UnconvertedText UsingCast UsingConvertFrom_ISO8601
----------------------- ----------------------- ------------------------
2010-07-25T13:50:38.544 07/25/2010 1:50:38 PM 07/25/2010 1:50:38 PM
Vedi anche
- FORMAT (Transact-SQL)
- STR (Transact-SQL)
- SELECT (Transact-SQL)
- Funzioni di sistema (Transact-SQL)
- Regole di confronto e supporto Unicode