CAST e CONVERT (Transact-SQL)

Si applica a:SQL Server Database SQL di Azure Istanza gestita di SQL di Azure Azure Synapse Analytics Endpoint di analisi SQL in Microsoft Fabric Magazzino in Microsoft Fabric Database SQL 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

di espressione

Qualsiasi espressione valida.

data_type

Tipo di dati di destinazione. Include xml, bigint e sql_variant. Non è possibile usare tipi di dati alias.

lunghezza

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.

stile

Un'espressione intera che specifica come la CONVERT funzione traduce l'espressione. Per un valore di stile di NULL, NULL viene restituito. 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, quando si convertono dai tipi di data e ora a datetimeoffset, sono 0 oppure 1. Tutti gli altri stili di conversione restituiscono l'errore 9809.

Nota

Il Motore di database di SQL Server supporta il formato della data, in stile arabo, con l'algoritmo kuwaitiano.

Senza secolo (yy) ¹	Con il secolo (aaaa)	Normale	Input/ ^{output 3}
-	`0`oppure `100`^1,2	Impostazione predefinita per datetime e smalldatetime	`MMM dd yyyy hh:mmtt` (`tt` è `AM` o `PM`)
`1`	`101`	Isole	`1` = `MM/dd/yy` `101` = `MM/dd/yyyy`
`2`	`102`	ANSI (Istituto Nazionale Americano degli Standard)	`2` = `yy.MM.dd` `102` = `yyyy.MM.dd`
`3`	`103`	Inglese Regno Unito/Francese	`3` = `dd/MM/yy` `103` = `dd/MM/yyyy`
`4`	`104`	Tedesco	`4` = `dd.MM.yy` `104` = `dd.MM.yyyy`
`5`	`105`	Italiano	`5` = `dd-MM-yy` `105` = `dd-MM-yyyy`
`6`	`106` ¹	-	`6` = `dd MMM yy` `106` = `dd MMM yyyy`
`7`	`107` ¹	-	`7` = `MMM dd, yy` `107` = `MMM dd, yyyy`
`8` oppure `24`	`108`	-	`HH:mm:ss`
-	`9`oppure `109`^1,2	Valore predefinito + millisecondi	`MMM dd yyyy hh:mm:ss:ffftt` (`tt` è `AM` o `PM`)
`10`	`110`	USA	`10` = `MM-dd-yy` `110` = `MM-dd-yyyy`
`11`	`111`	Giappone	`11` = `yy/MM/dd` `111` = `yyyy/MM/dd`
`12`	`112`	ISO	`12` = `yyMMdd` `112` = `yyyyMMdd`
-	`13`oppure `113`^1,2	Valore predefinito Europa + millisecondi	`dd MMM yyyy HH:mm:ss:fff` (24 ore)
`14`	`114`	-	`HH:mm:ss:fff` (24 ore)
-	`20` oppure `120`²	ODBC canonico	`yyyy-MM-dd HH:mm:ss` (24 ore)
-	`21` oppure `25121`²	Odbc canonico (con millisecondi) predefinito per time, date, datetime2 e datetimeoffset	`yyyy-MM-dd HH:mm:ss.fff` (24 ore)
`22`	-	Isole	`MM/dd/yy hh:mm:ss tt` (`tt` è `AM` o `PM`)
-	`23`	ISO8601	`yyyy-MM-dd`
-	`126` ⁴	ISO8601	`yyyy-MM-ddTHH:mm:ss.fff` (senza spazi) ⁶
-	`127` ^{8, 9}	ISO8601 con fuso orario Z	`yyyy-MM-ddTHH:mm:ss.fffZ` (senza spazi) ⁶
-	`130` ^1,2	^{Hijri 5}	`dd MMMM yyyy hh:mm:ss:ffftt` ⁷
-	`131` ²	^{Hijri 5}	`dd/MM/yyyy hh:mm:ss:ffftt`

¹ Questi valori di stile restituiscono risultati non deterministici. Include tutti gli stili (yysenza secolo) e un subset di stili () (yyyycon secolo).

² I valori predefiniti (0 o 100, 9 o 109, 13 o 113, o 120, 20 , 23, o 2125 o ) 121restituiscono sempre il secolo (yyyy).

Importante

Per impostazione predefinita, il Motore di database di SQL Server interpreta gli anni a due cifre basandosi su un anno di soglia pari al 2049. Ciò significa che il motore di database interpreta l'anno 49 a due cifre come 2049 e l'anno 50 a due cifre come 1950. Numerose applicazioni client, incluse quelle basate su oggetti di automazione, usano il 2030 come anno di cambio data. Il motore di database fornisce l'opzione di configurazione a due cifre per l'anno di soglia per cambiare l'anno di soglia utilizzato dal motore di database. Ciò consente una gestione coerente delle date. È consigliabile specificare l'anno nel formato a quattro cifre.

³ Input quando viene eseguita la conversione nel tipo di dati datetime, output quando viene eseguita la conversione in dati di tipo carattere.

⁴ 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.

⁵ Hijri è un sistema di calendario con diverse variazioni. Il motore di database utilizza l'algoritmo kuwaitiano.

⁶ Per un valore di millisecondi (fff) 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.

⁷ In questo stile, MMMM 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.

⁸ È 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.

⁹ Utilizzare l'indicatore Z opzionale del fuso orario per facilitare la mappatura dei valori data-ora XML che contengono informazioni sul fuso orario ai valori di data-ora del motore di database che non hanno 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	Risultato
`0` (impostazione predefinita)	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	Risultato
`0` (impostazione predefinita)	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 converte 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	Risultato
`0` (impostazione predefinita)	Usare il comportamento di analisi predefinito che elimina spazi vuoti non significativi e non consente un subset DTD interno. Nota: Quando si converte al tipo di dato xml, il motore di database gestisce spazi bianchi insignificanti in modo diverso rispetto a XML 1.0. Per ulteriori informazioni, vedi Crea 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 vedere se l'attributo standalone ha un `yes` valore 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 di stile non elencati nella tabella restituiscono un errore.

Valore Risultato

0 (impostazione predefinita) Converte caratteri ASCII in byte binari e viceversa. Ogni carattere o byte viene convertito in base allo schema 1:1.

Per un data_type binario, i caratteri 0x vengono aggiunti a sinistra del risultato.

1, 2 Se data_tye è binario, l'espressione deve essere un'espressione di caratteri. L'espressione deve avere un numero pari di cifre esadecimali (0, 1, 2, 34, 5, 76, 8fedcbaFDBE9AC) Se lo stile è impostato a 1, l'espressione deve avere 0x come primi due caratteri. 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 stile2.

Valore	Risultato
`0` (impostazione predefinita)	Converte caratteri ASCII in byte binari e viceversa. Ogni carattere o byte viene convertito in base allo schema 1:1. Per un data_type binario, i caratteri `0x` vengono aggiunti a sinistra del risultato.
`1`, `2`	Se data_tye è binario, l'espressione deve essere un'espressione di caratteri. L'espressione deve avere un numero pari di cifre esadecimali (`0`, `1`, `2`, `34`, `5`, `76`, `8fedcbaFDBE9AC`) Se lo stile è impostato a `1`, l'espressione deve avere `0x` come primi due caratteri. 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 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 . L'illustrazione seguente mostra tutte le conversioni esplicite e implicite dei tipi di dati consentite per i tipi di dati forniti dal sistema motore di database. Questi includono bigint, sql_variant, xml, hierarchyid, geografia, geometria, json e vector. I tipi di dati json e vettoriale sono disponibili solo in SQL Server 2025 (17.x), database SQL di Azure, Istanza gestita di SQL di Azure e database SQL in Microsoft Fabric. Non c'è una conversione implicita all'assegnazione dal tipo di dato sql_variant , ma c'è una conversione implicita a sql_variant.

Il grafico sopra illustra tutte le conversioni esplicite e implicite consentite nel motore di database, ma il tipo di dato 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 dipende dalle regole di precedenza dei tipi di dati.

Per alcuni tipi di dati, il risultato dipende da come il tipo di dato viene dichiarato:

Decimale e numerico: Il motore di database tratta ogni combinazione di precisione e scala come un tipo di dato diverso. La conversione tra i due può essere implicita. Un valore con più decimali della scala target viene arrotondato senza errore. Un valore troppo grande per la precisione del bersaglio causa l'errore 8115, a meno che ARITHABORT e ANSI_WARNINGS non siano entrambi OFF; allora il risultato è NULL.
Non puoi convertire varchar(max),nvarchar(max) e varbinary(max) in sql_variant.
La conversione tra diversi tipi CLR definiti dall'utente non è permessa.
La conversione implicita è supportata tra xml non tipizzato e xml tipizzato, e tra valori xml tipizzati che utilizzano la stessa collezione di schema XML e la stessa DOCUMENT o CONTENT facetta.
La conversione tra diverse collezioni di schemi XML, o tra diverse DOCUMENT sfaccettature CONTENT , deve essere esplicita. La conversione tra un tipo CLR definito dall'utente e un xml tipizzato non è permessa.
La conversione tra valori vettoriali è consentita solo quando le dimensioni e il tipo base (float32 o float16) sono uguali.

Una conversione che il grafico mostra come permessa può comunque fallire per un valore specifico, ad esempio una stringa che non è valida in JSON o un vettore con un numero diverso di dimensioni. I valori dei tipi di dati immagine, ntext, testo, xml, geografia, geometria, json e vettoriale non possono essere confrontati con l'operatore uguale a (=), anche quando entrambi i valori hanno lo stesso tipo di dato.

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.

I tipi di dati nchar e nvarchar memorizzano i dati Unicode in codifica UTF-16, che utilizza sempre un numero pari di byte. Fai attenzione quando converti binario o varbinario da o da nchar o nvarchar. Ad esempio, la conversione seguente non restituisce un valore esadecimale di 41. Restituisce un valore esadecimale di 4100:

SELECT CAST (CAST (0x41 AS NVARCHAR) AS VARBINARY);

Per ulteriori informazioni, vedere 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 maggiori informazioni sulla conversione dal tipo di dato xml , vedi 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, vedi Definire la serializzazione dei dati XML. Per informazioni sulla conversione da altri tipi di dati al tipo di dato xml , vedi 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 provi una conversione errata, ad esempio cercando di convertire un'espressione di carattere che include lettere in un int, il motore di database 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 ulteriori informazioni, vedere regole di confronto di precedenza.

Per assegnare una collazione diversa all'output, applica la COLLATE clausola all'espressione di risultato della CAST funzione op 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. Questi casi 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 ¹
money, smallmoney, numeric, decimal, float o real	Char varchar	Errore ¹
	nchar nvarchar	Errore ¹

¹ Errore restituito perché la lunghezza del risultato è troppo breve da visualizzare.

Il Motore di database di SQL Server garantisce che solo le conversioni di andata e ritorno, cioè quelle che convertono un tipo di dato dal suo tipo originale e viceversa, diano gli stessi valori da una versione all'altra. Nell'esempio seguente viene illustrata una conversione di questo tipo:

DECLARE @myval AS 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. Il motore di database non garantisce che il risultato di una conversione di tipo di dato decimale o numerico, in binario, sia lo stesso tra le versioni di SQL Server.

Nell'esempio seguente viene illustrata un'espressione troppo breve per essere visualizzata.

USE AdventureWorks2025;
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 AS e
     INNER JOIN Person.Person AS 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.    *

Quando si convertono tipi di dati che differiscono in decimali, il motore di database a volte restituisce un valore di risultato troncato, altre volte un valore arrotondato. La tabella che segue illustra questo comportamento.

Da	Per	Comportamento
numerico	numerico	Turno
numerico	Int	Troncare
numerico	denaro	Turno
denaro	Int	Turno
denaro	numerico	Turno
galleggiare	Int	Troncare
galleggiare	numerico	^Primo turno
galleggiare	datetime	Turno
datetime	Int	Turno

¹ La conversione di valori float che utilizzano la notazione scientifica in decimal onumeric è 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 in tipi int o numerici :

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:

tronc1	tronc2	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);

Il motore di database restituisce un messaggio di errore quando si convertono dati non numerici di char, nchar, nvarchar o varchar in decimale, float, int, numerico. Il motore di database restituisce anche un errore quando una stringa vuota ( ) viene convertita in numerica o decimale.

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 sotto 100¹
106
107
109
113
130

¹ 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 AS 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 e CONVERT operazioni sui tipi di dati time e datetime2 è 121, tranne quando uno dei due tipi viene utilizzato in un'espressione a colonna calcolata. Per colonne calcolate, lo stile predefinito è 0. Questo comportamento influisce sulle colonne calcolate quando vengono create, utilizzate in query che coinvolgono l'autoparametrizzazione o nelle definizioni di vincoli.

Sotto livello 110di compatibilità e superiore, le CAST operazioni e CONVERT sui tipi di dati time e datetime2 hanno 121 sempre come stile predefinito. Se una query si basa sul vecchio comportamento, usa un livello di compatibilità inferiore a 110, oppure specifica esplicitamente lo 0 stile nella query interessata.

Valore di Livello di compatibilità	Stile predefinito per `CAST` e `CONVERT`¹	Stile predefinito per la colonna calcolata
`< 110`	`121`	`0`
`>= 110`	`121`	`121`

¹ Ad eccezione delle colonne calcolate

Aggiornare il database a un livello 110 di compatibilità o superiore non modificherà i dati utente memorizzati sul disco. È necessario correggere manualmente questi dati nel modo opportuno. Ad esempio, se usassi SELECT INTO per creare una tabella da una sorgente contenente un'espressione di colonna calcolata descritta sopra, i dati (usando lo stile 0) verrebbero memorizzati invece della definizione calcolata della colonna stessa. Devi aggiornare manualmente questi dati per adattarli allo stile 121.

Esempi

Gli esempi di codice in questo articolo utilizzano il AdventureWorks2025, AdventureWorksDW2025, o AdventureWorksLT2025 database di esempi, che puoi scaricare dal repository GitHub Azure Data SQL Samples Repository.

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 AdventureWorks2025;
GO

SELECT SUBSTRING(Name, 1, 30) AS ProductName,
       ListPrice
FROM Production.Product
WHERE CAST (ListPrice AS INT) LIKE '33%';
GO

Usare CONVERT:

USE AdventureWorks2025;
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 CASTCONVERT.

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

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 AdventureWorks2025;
GO

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

Il set di risultati è il seguente.

C. Usare CAST per concatenare

In questo esempio vengono concatenate espressioni non carattere usando CAST. Usa il database AdventureWorksDW2025.

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

Questo esempio viene utilizzato CAST nella SELECT lista per convertire la Name colonna in una colonna char(10 ). Usa il database AdventureWorksDW2025.

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 AdventureWorks2025;
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

F. Usare CONVERT o CAST con XML tipizzato

Questi esempi mostrano l'uso di CONVERT per convertire dati in XML tipizzati, utilizzando il tipo di dato 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);

Vedi Creare istanze di dati XML per altri esempi.

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

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

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

Questo esempio mostra che Style 1 può forzare la troncatura del risultato. I caratteri 0x nell'insieme di risultati forzano la troncazione.

SELECT CONVERT (CHAR (8), 0x4E616d65, 1) AS [Style 1, binary to character];

Il set di risultati è il seguente.

Style 1, binary to character
------------------------------
0x4E616D

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

Converti il valore Name del carattere in un 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

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

Il set di risultati è il seguente.

Style 1, character to binary
----------------------------
0x4E616D65

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

Il set di risultati è il seguente.

Style 2, character to binary
----------------------------------
0x4E616D65

Io. 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 AS DATE,
        @t1 AS TIME,
        @dt1 AS 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 AS DATE,
        @dt1 AS DATETIME,
        @dt2 AS 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 returns an 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` oppure `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` oppure `113`	`SELECT CONVERT(NVARCHAR, GETDATE(), 13)`	23 ago 2019 13:39:17:090
`14` oppure `114`	`SELECT CONVERT(NVARCHAR, GETDATE(), 14)`	13:39:17:090
`20` oppure `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)`	23/08/19 13:39:17
`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 ذو الاا440 1:39:17.090P
`131`	`SELECT CONVERT(NVARCHAR, GETDATE(), 131)`	12/22/1440 1:39:17.090

Okay. 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 AS 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 AS INT;
SET @notastring = '1';

SELECT @notastring + ' is not a string.' AS Result;

In questo caso, l'istruzione SELECT genera 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.', il motore di database 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, il motore di database tenta di convertire la stringa in un intero ma fallisce perché questa stringa non può essere convertita in un intero.

Se forniamo una stringa che può essere convertita, l'affermazione ha successo, come si vede nel seguente esempio:

DECLARE @notastring AS INT;
SET @notastring = '1';

SELECT @notastring + '1';

In questo caso, la stringa '1' può essere convertita nel valore intero 1, quindi questa istruzione SELECT restituisce il valore 2. Quando i tipi di dati forniti sono interi, l'operatore + diventa operatore matematico di addizione, anziché una concatenazione di stringhe.

Esempi: Azure Synapse Analytics

.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 AdventureWorksDW2025 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 AdventureWorksDW2025.

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 AdventureWorksDW2025.

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 la colonnaListPrice money in un tipo int , e poi in un tipo char(20 ), così che la LIKE clausola possa usarla. In questo esempio viene utilizzato il database AdventureWorksDW2025.

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 AdventureWorksDW2025.

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

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

Commenti e suggerimenti

Questa pagina è stata utile?

Ultimo aggiornamento: 2026-10-16

CAST e CONVERT (Transact-SQL)

Sintassi

Argomenti

di espressione

data_type

lunghezza

stile

Tipi restituiti

Stili di data e ora

Stili float e real

Stili money e smallmoney

Stili xml

Stili binary

Conversioni implicite

Tipi di dati per valori di grandi dimensioni

Tipo di dati XML.

Tipi di dati text e image

Regole di confronto di output

Troncamento e arrotondamento dei risultati

Alcune conversioni di data/ora sono non deterministiche

Caratteri supplementari (coppie di surrogati)

Informazioni sulla compatibilità

Esempi

R. Usare sia CAST che CONVERT

B. Usare CAST con operatori aritmetici

C. Usare CAST per concatenare

D. Usare CAST per produrre testo più leggibile

E. Usare CAST con la clausola LIKE

F. Usare CONVERT o CAST con XML tipizzato

G. Usare CAST e CONVERT con dati datetime

H. Usare CONVERT con dati binari e di tipo carattere

Io. Convertire i tipi di dati di data e ora

J. Usare CONVERT con dati datetime in formati diversi

Okay. Effetti della precedenza dei tipi di dati nelle conversioni consentite

Esempi: Azure Synapse Analytics

.L Usare CAST e CONVERT

M. Usare CAST con operatori aritmetici

N. Usare CAST con la clausola LIKE

.O Usare CAST e CONVERT con dati datetime

Contenuti correlati

Commenti e suggerimenti

Risorse aggiuntive