CAST y CONVERT (Transact-SQL)

Aplica a:SQL Server Azure SQL Database Azure SQL Managed Instance Azure Synapse Analytics Endpoint de analítica SQL en Microsoft Fabric Almacén en Microsoft Fabric Base de datos SQL en Microsoft Fabric

Estas funciones convierten una expresión de un tipo de datos a otro.

Sintaxis

Sintaxis CAST:

CAST ( expression AS data_type [ ( length ) ] )

Sintaxis CONVERT:

CONVERT ( data_type [ ( length ) ] , expression [ , style ] )

Convenciones de sintaxis de Transact-SQL

Argumentos

expresión

Cualquier expression válida.

data_type

El tipo de datos de destino. Esto engloba xml, bigint y sql_variant. No se pueden utilizar tipos de datos de alias.

largura

Entero opcional que especifica la longitud del tipo de datos de destino para los tipos de datos que permiten una longitud especificada por el usuario. El valor predeterminado es 30.

estilo

Una expresión entera que especifica cómo la CONVERT función traduce la expresión. Para un valor de estilo de NULL, NULL se devuelve. data_type determina el intervalo.

Tipos de valores devueltos

Devuelve expression, traducido a data_type.

Estilos de fecha y hora

Para una expression que tenga el tipo de datos de fecha u hora, style puede tener uno de los valores que se muestran en la siguiente tabla. Otros valores se procesan como 0. A partir de SQL Server 2012 (11.x), los únicos estilos soportados, al convertir de tipos de fecha y hora a datetimeoffset, son 0 o 1. Todos los demás estilos de conversión devuelven el error 9809.

Nota

El Motor de base de datos de SQL Server soporta el formato de fecha, en estilo árabe, con el algoritmo kuwaití.

Sin el siglo (yy) ¹	Con el siglo (aaaa)	Estándar	Entrada/salida (³)
-	`0`o `100`^1,2	Valor predeterminado para datetime y smalldatetime	`MMM dd yyyy hh:mmtt` (`tt` es `AM` o `PM`)
`1`	`101`	EE. UU.	`1` = `MM/dd/yy` `101` = `MM/dd/yyyy`
`2`	`102`	ANSI (Instituto Nacional Estadounidense de Estándares)	`2` = `yy.MM.dd` `102` = `yyyy.MM.dd`
`3`	`103`	Británico/Francés	`3` = `dd/MM/yy` `103` = `dd/MM/yyyy`
`4`	`104`	Alemán	`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` o `24`	`108`	-	`HH:mm:ss`
-	`9`o `109`^1,2	Valor predeterminado + milisegundos	`MMM dd yyyy hh:mm:ss:ffftt` (`tt` es `AM` o `PM`)
`10`	`110`	EE. UU.	`10` = `MM-dd-yy` `110` = `MM-dd-yyyy`
`11`	`111`	Japón	`11` = `yy/MM/dd` `111` = `yyyy/MM/dd`
`12`	`112`	ISO	`12` = `yyMMdd` `112` = `yyyyMMdd`
-	`13`o `113`^1,2	Europao predeterminado + milisegundos	`dd MMM yyyy HH:mm:ss:fff` (24 horas)
`14`	`114`	-	`HH:mm:ss:fff` (24 horas)
-	`20` o `120`²	ODBC canónico	`yyyy-MM-dd HH:mm:ss` (24 horas)
-	`21` o `25121`²	ODBC canónico (con milisegundos), valor predeterminado para time, date, datetime2 y datetimeoffset	`yyyy-MM-dd HH:mm:ss.fff` (24 horas)
`22`	-	EE. UU.	`MM/dd/yy hh:mm:ss tt` (`tt` es `AM` o `PM`)
-	`23`	ISO8601	`yyyy-MM-dd`
-	`126` ⁴	ISO8601	`yyyy-MM-ddTHH:mm:ss.fff` (sin espacios) ⁶
-	`127` ^{8, 9}	ISO8601 con zona horaria Z	`yyyy-MM-ddTHH:mm:ss.fffZ` (sin espacios) ⁶
-	`130` ^1,2	^{Hégira 5}	`dd MMMM yyyy hh:mm:ss:ffftt` ⁷
-	`131` ²	^{Hégira 5}	`dd/MM/yyyy hh:mm:ss:ffftt`

¹ Estos valores de estilo devuelven resultados no deterministas. Incluye todos los estilos (yy) (sin el siglo) y un subconjunto de estilos (yyyy) (con el siglo).

² Los valores por defecto (0 o 100, 9 o 109, 13 o 113, 20 o 120, 23, o 2125 o 121) siempre devuelven el siglo (yyyy).

Importante

Por defecto, el Motor de base de datos de SQL Server interpreta los años de dos dígitos basándose en un año de corte de 2049. Eso significa que el Motor de base de datos interpreta el año 49 de dos dígitos como 2049 y el año 50 de dos dígitos como 1950. Muchas aplicaciones cliente, como las que se basan en objetos de Automation, usan el año límite de 2030. El Motor de base de datos ofrece la opción de configuración de dos dígitos para cambiar el año de corte utilizado por el Motor de base de datos. Esto permite tratar las fechas de manera coherente. Se recomienda especificar años de cuatro dígitos.

³ Entrada cuando se convierte en datetime; salida cuando se convierte en datos de caracteres.

⁴ Diseñado para usarse con XML. Para convertir datos datetime o smalldatetime en datos de caracteres, consulte la tabla anterior para ver el formato de salida.

⁵ Hijri es un sistema del calendario con varias variaciones. El Motor de base de datos utiliza el algoritmo kuwaití.

⁶ En el caso de un valor 0 en milisegundos (fff), el valor de fracción decimal en milisegundos no se mostrará. Por ejemplo, el valor 2022-11-07T18:26:20.000 se muestra como 2022-11-07T18:26:20.

⁷ En este estilo, MMMM representa una representación Unicode hijri multi token del nombre del mes completo. Este valor no se representa correctamente en una instalación estadounidense predeterminada de SSMS.

⁸ Solo se admite en la conversión de datos de caracteres a datetime o smalldatetime. Al convertir datos de caracteres que representan componentes de solo fecha o solo hora al tipo de datos datetime o smalldatetime, el componente de hora no especificado se establece en 00:00:00.000 y el componente de fecha no especificado se establece en 1900-01-01.

⁹ Utiliza el indicador Z opcional de huso horario para facilitar el mapeo de valores XML de fecha y hora que contienen información de zona horaria a valores de fecha y hora del Motor de base de datos que no tienen zona horaria. Z indica la zona horaria en UTC-0. El desplazamiento HH:mm, en sentido + o -, indica otras zonas horarias. Por ejemplo: 2022-12-12T23:45:12-08:00.

Al convertir datos smalldatetime en datos de caracteres, los estilos que incluyen segundos o milisegundos muestran ceros en dichas posiciones. Al convertir valores datetime o smalldatetime, use una longitud adecuada de valor de datos char o varchar para truncar las partes de la fecha que no quiera.

Al convertir datos de caracteres en datos datetimeoffset con un estilo que incluye una hora, se anexa un desplazamiento de zona horaria al resultado.

Estilos float y real

En el caso de una expressionfloat o real, style puede tener uno de los valores que se muestran en la siguiente tabla. Otros valores se procesan como 0.

Importancia	Salida
`0` (valor predeterminado)	Un máximo de 6 dígitos. Utilícelo en notación científica cuando proceda.
`1`	Siempre 8 dígitos. Utilícelo siempre en notación científica.
`2`	Siempre 16 dígitos. Utilícelo siempre en notación científica.
`3`	Siempre 17 dígitos. Se usa para la conversión sin pérdida de información. Con este estilo, se garantiza que cada valor de float o real distinto se va a convertir en una cadena de caracteres distinta. Se aplica a: SQL Server 2016 (13.x) y versiones posteriores, y Azure SQL Database.
`126`, `128`, `129`	Se incluye por motivos de herencia. No use estos valores para una nueva implementación.

Estilos money y smallmoney

En el caso de una expressionmoney o smallmoney, style puede tener uno de los valores que se muestran en la siguiente tabla. Otros valores se procesan como 0.

Importancia	Salida
`0` (valor predeterminado)	Sin separadores de millar cada tres dígitos a la izquierda del separador decimal y dos dígitos a la derecha del separador decimal Ejemplo: 4235,98.
`1`	Separadores de millar cada tres dígitos a la izquierda del separador decimal y dos dígitos a la derecha del separador decimal Ejemplo: 3.510,92.
`2`	Sin separadores de millar cada tres dígitos a la izquierda del separador decimal y cuatro dígitos a la derecha del separador decimal Ejemplo: 4235,9819.
`126`	Equivalente a style `2`, al convertir a char(n) o varchar(n)

Estilos xml

En el caso de una expressionxml, style puede tener uno de los valores que se muestran en la siguiente tabla. Otros valores se procesan como 0.

Importancia	Salida
`0` (valor predeterminado)	Usa el comportamiento de análisis predeterminado que descarta los espacios en blanco insignificantes y no permite un subconjunto DTD interno. Nota: Al convertir al tipo de dato xml, el Motor de base de datos gestiona el espacio en blanco insignificante de forma diferente a XML 1.0. Para más información, véase Crear instancias de datos XML.
`1`	Conserva los espacios en blanco insignificantes. Esta configuración de estilo establece el control predeterminado de `xml:space` para emular el comportamiento de `xml:space="preserve"` .
`2`	Habilita el procesamiento limitado de subconjuntos DTD internos. Si está habilitado, el servidor puede usar la siguiente información proporcionada en un subconjunto DTD interno para realizar operaciones de análisis que no se validan. - Se aplican los valores predeterminados de los atributos - Las referencias a entidades internas se resuelven y se amplían - Se comprueba la corrección sintáctica del modelo de contenido DTD El analizador pasa por alto los subconjuntos DTD externos. Además, no evalúa la declaración XML para ver si el atributo independiente tiene un `yes` valor o `no` . En su lugar, analiza la instancia XML como documento independiente.
`3`	Conserva los espacios en blanco insignificantes y habilita el procesamiento limitado de los subconjuntos DTD internos.

Estilos binarios

Para una expresión binary(n), char(n),varbinary(n)o varchar(n),style puede tener uno de los valores que se muestran en la tabla siguiente. Los valores de estilo que no aparecen en la tabla devolven un error.

Importancia Salida

0 (valor predeterminado) Traduce caracteres ASCII a bytes binarios o bytes binarios a caracteres ASCII. Cada carácter o byte se convierte con una proporción 1:1.

Para un data_type binario, los caracteres 0x se suman a la izquierda del resultado.

1, 2 Para un data_type binario, la expresión debe ser de caracteres. La expresión debe tener un número par de dígitos hexadecimales (0, 1, 2, 34, 5, 6, AebfdcaFEC9D78B). Si el estilo está establecido en 1, la expresión debe tener 0x como los dos primeros caracteres. Si la expresión contiene un número impar de caracteres o si alguno de los caracteres no es válido, se producirá un error.

Si la longitud de la expresión convertida supera la longitud de data_type, el resultado se truncará a la derecha.

Los valores data_type de longitud fija que sean mayores que el resultado convertido tendrán ceros agregados a la derecha del resultado.

Los data_type con el tipo carácter necesitan una expresión binaria. Cada carácter binario se convierte en dos caracteres hexadecimales. Imagine que la longitud de la expresión convertida supera la longitud de data_type. En ese caso, se trunca.

Para un valor data_type de tipo de caracteres de tamaño fijo, si la longitud del resultado convertido es menor que la longitud de data_type, se agregan espacios a la derecha de la expresión convertida para mantener un número par de dígitos hexadecimales.

Los caracteres 0x no se añaden a la izquierda del resultado convertido para darle estilo2.

Importancia	Salida
`0` (valor predeterminado)	Traduce caracteres ASCII a bytes binarios o bytes binarios a caracteres ASCII. Cada carácter o byte se convierte con una proporción 1:1. Para un data_type binario, los caracteres `0x` se suman a la izquierda del resultado.
`1`, `2`	Para un data_type binario, la expresión debe ser de caracteres. La expresión debe tener un número par de dígitos hexadecimales (`0`, `1`, `2`, `34`, `5`, `6`, `AebfdcaFEC9D78B`). Si el estilo está establecido en `1`, la expresión debe tener `0x` como los dos primeros caracteres. Si la expresión contiene un número impar de caracteres o si alguno de los caracteres no es válido, se producirá un error. Si la longitud de la expresión convertida supera la longitud de data_type, el resultado se truncará a la derecha. Los valores data_type de longitud fija que sean mayores que el resultado convertido tendrán ceros agregados a la derecha del resultado. Los data_type con el tipo carácter necesitan una expresión binaria. Cada carácter binario se convierte en dos caracteres hexadecimales. Imagine que la longitud de la expresión convertida supera la longitud de data_type. En ese caso, se trunca. Para un valor data_type de tipo de caracteres de tamaño fijo, si la longitud del resultado convertido es menor que la longitud de data_type, se agregan espacios a la derecha de la expresión convertida para mantener un número par de dígitos hexadecimales. Los caracteres `0x` no se añaden a la izquierda del resultado convertido para darle estilo`2`.

Conversiones implícitas

Las conversiones implícitas no requieren la especificación de la función CAST ni de la función CONVERT. Las conversiones explícitas requieren la especificación de la función CAST o de la función CONVERT. La siguiente ilustración muestra todas las conversiones explícitas e implícitas de tipos de datos permitidas para los tipos de datos suministrados por el sistema Motor de base de datos. Estos incluyen bigint, sql_variant, xml, hierarchyid, geography, geometry, json y vector. Los tipos de datos json y vector solo están disponibles en SQL Server 2025 (17.x), Azure SQL Database, Azure SQL Managed Instance y SQL database en Microsoft Fabric. No hay conversión implícita al asignar desde el tipo de dato sql_variant, pero sí hay conversión implícita a sql_variant.

El gráfico anterior ilustra todas las conversiones explícitas e implícitas que se permiten en el Motor de base de datos, pero el tipo de dato resultante de la conversión depende de la operación que se esté realizando:

En el caso de las conversiones explícitas, la instrucción misma determina el tipo de datos resultante.
En las conversiones implícitas, las instrucciones de asignación, como establecer el valor de una variable o insertar un valor en una columna, general el tipo de datos definido por la declaración de la variable o la definición de la columna.
En el caso de los operadores de comparación u otras expresiones, el tipo de datos resultante depende de las reglas de prioridad de los tipos de datos.

Para algunos tipos de datos, el resultado depende de cómo se declare el tipo de dato:

Decimal y numérico: El Motor de base de datos trata cada combinación de precisión y escala como un tipo de dato diferente. La conversión entre ellos puede ser implícita. Un valor con más decimales que la escala objetivo se redondea sin error. Un valor demasiado grande para la precisión objetivo provoca el error 8115, a menos que ARITHABORT y sean ambos OFF; entonces el resultado es NULLANSI_WARNINGS .
No puedes convertir varchar(max), nvarchar(max) y varbinary(max) a sql_variant.
No se permite la conversión entre diferentes tipos de CLR definidos por el usuario.
Se soporta la conversión implícita entre xml no tipado y xml tipado, y entre valores xml tipados que usan la misma colección de esquema XML y el mismo DOCUMENT o CONTENT facet.
La conversión entre diferentes colecciones de esquemas XML, o entre diferentes DOCUMENT facetas, CONTENT debe ser explícita. No se permite la conversión entre un tipo CLR definido por el usuario y un xml tipado.
La conversión entre valores vectoriales solo está permitida cuando las dimensiones y el tipo base (float32 o float16) son iguales.

Una conversión que el gráfico muestra como permitida puede fallar para un valor específico, por ejemplo, una cadena que no es JSON válida, o un vector con un número diferente de dimensiones. Los valores de los tipos de datos imagen, ntext, texto, xml, geografía, geometría, json y vector no pueden compararse con el operador igual a (=), incluso cuando ambos valores tienen el mismo tipo de dato.

Sugerencia

Más adelante en esta sección puede consultar un ejemplo práctico sobre los efectos de la prioridad de los tipos de datos en las conversiones.

Al convertir entre datetimeoffset y los tipos de caracteres char, nchar, nvarchar y varchar, la parte del ajuste de zona horaria convertida siempre debe tener dígitos dobles para HH y mm. Por ejemplo, -08:00.

Los tipos de datos nchar y nvarchar almacenan datos Unicode en codificación UTF-16, que siempre utiliza un número par de bytes. Ten cuidado al convertir binario o varbinario a o desde nchar o nvarchar. Por ejemplo, la siguiente conversión no devuelve un valor hexadecimal de 41. Devuelve un valor hexadecimal de 4100:

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

Para obtener más información, consulte Intercalación y compatibilidad con Unicode.

Tipos de datos de valor grande

Los tipos de datos de valor grande tienen el mismo comportamiento de conversión implícita y explícita que sus equivalentes más pequeños, en concreto los tipos de datos nvarchar, varbinary y varchar. Aun así, tenga en cuenta las directrices siguientes:

La conversión de datos image a datos varbinary(max) y viceversa funciona como una conversión implícita, al igual que las conversiones entre text y varchar(max) y entre ntext y nvarchar(max) .
La conversión de tipos de datos de valor grande, como varchar(max) , a un tipo de datos equivalente más pequeño, como varchar, es una conversión implícita, aunque se produce un truncamiento si el tamaño del valor grande supera la longitud especificada del tipo de datos más pequeño.
La conversión de nvarchar, varbinary o varchar a sus tipos de datos correspondientes de valor grande tiene lugar de forma implícita.
La conversión del tipo de datos sql_variant en los tipos de datos de valor grande es una conversión explícita.
Los tipos de datos de valor grande no se pueden convertir en el tipo de datos sql_variant.

Para más información sobre la conversión desde el tipo de dato xml , véase Crear instancias de datos XML.

tipo de datos xml

Cuando se convierte de forma explícita o implícita el tipo de datos xml en un tipo de datos de cadena o binario, el contenido del tipo de datos xml se serializa en función de un conjunto de reglas definido. Para información sobre estas reglas, véase Definir la serialización de datos XML. Para información sobre la conversión de otros tipos de datos al tipo de datos xml , véase Crear instancias de datos XML.

Tipos de datos text e image

Los tipos de datos text e image no admiten la conversión automática de tipos de datos. Puede convertir explícitamente datos text en datos de caracteres y datos image en binary o varbinary, pero la longitud máxima es de 8000 bytes. Si intentas una conversión incorrecta, por ejemplo intentando convertir una expresión de carácter que incluye letras a un int, el Motor de base de datos devuelve un mensaje de error.

Intercalación de salida

Si las funciones CAST o CONVERT generan una cadena de caracteres y reciben una entrada de una cadena de caracteres, la salida tiene la misma intercalación y la misma etiqueta de intercalación que la entrada. Si la entrada no es una cadena de caracteres, la salida tiene la intercalación predeterminada de la base de datos y una etiqueta de intercalación coaccionable-predeterminada. Para obtener más información, vea Precedencia de intercalación.

Para asignar una colación diferente a la salida, se aplica la COLLATE cláusula a la expresión de resultado de la CAST función o CONVERT . Por ejemplo:

SELECT CAST ('abc' AS VARCHAR (5)) COLLATE French_CS_AS;

Truncar y redondear resultados

Al convertir expresiones binarias o de caracteres (binary, char, nchar, nvarchar, varbinary o varchar) en una expresión de otro tipo de datos, la operación de conversión podría truncar los datos de salida, mostrar solo parcialmente los datos de salida o devolver un error. Estos casos ocurren si el resultado es demasiado corto para mostrarse. Las conversiones a binary, char, nchar, nvarchar, varbinary o varchar se truncan, excepto aquellas que se muestran en la siguiente tabla.

De tipo de datos	En tipo de datos	Resultado
int, smallint o tinyint	carbonizar varchar	No se puede mostrar porque es demasiado corto
	nchar nvarchar	Error ¹
money, smallmoney, numeric, decimal, float o real	carbonizar varchar	Error ¹
	nchar nvarchar	Error ¹

¹ Error devuelto porque el resultado es demasiado corto para mostrarse.

El Motor de base de datos de SQL Server garantiza que solo las conversiones de ida y vuelta, es decir, las conversiones que convierten un tipo de dato desde su tipo original y viceversa, arrojan los mismos valores de una versión a otra. En el siguiente ejemplo se muestra una conversión circular:

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

Advertencia

No cree valores binary. Después, conviértalos a un tipo de datos de la categoría de datos numéricos. El Motor de base de datos no garantiza que el resultado de una conversión de tipo de dato decimal o numérico, a binario, sea el mismo entre versiones de SQL Server.

En el siguiente ejemplo se muestra una expresión resultante demasiado corta para ser mostrada.

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

Este es el conjunto de resultados.

FirstName   LastName      Title   Sick Leave
---------   ------------- ------- --------`
Ken         Sanchez       NULL   *
Terri       Duffy         NULL   *
Roberto     Tamburello    NULL   *
Rob         Walters       NULL   *
Gail        Erickson      Ms.    *

Cuando conviertes tipos de datos que difieren en decimales, el Motor de base de datos a veces devuelve un valor de resultado truncado y, en otras ocasiones, un valor redondeado. En esta tabla se muestra el comportamiento.

De	A	Comportamiento
numérico	numérico	Redondeo
numérico	Int	Truncar
numérico	dinero	Redondeo
dinero	Int	Redondeo
dinero	numérico	Redondeo
flotar	Int	Truncar
flotar	numérico	Ronda ¹
flotar	datetime	Redondeo
datetime	Int	Redondeo

¹ La conversión de los valores float que usan la notación científica a decimal o numeric se restringe únicamente a los valores con una precisión de 17 dígitos. Cualquier valor con una precisión mayor de 17 se redondea a cero.

Por ejemplo, los valores 10.6496 y -10.6496 pueden truncarse o redondearse durante la conversión a tipos int o numéricos :

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;

Los resultados de la consulta se muestran en la siguiente tabla:

trunc1	trunc2	round1	round2
10	-10	11	-11

Al convertir tipos de datos donde el tipo de datos de destino tiene menos decimales que el tipo de datos de origen, el valor se redondea. Por ejemplo, esta conversión devuelve $10.3497:

SELECT CAST (10.3496847 AS MONEY);

El Motor de base de datos devuelve un mensaje de error al convertir datos no numéricos de char, nchar, nvarchar o varchar a decimal, float, int, numérico. El Motor de base de datos también devuelve un error cuando una cadena vacía ( ) se convierte en numérica o decimal.

Determinadas conversiones de fecha y hora son no deterministas

Los estilos para los que la conversión de cadena a fecha y hora es no determinista son los siguientes:

Todos los estilos por debajo 100 de ¹
106
107
109
113
130

¹ Con la excepción de los estilos 20 y 21

Para obtener más información, vea Conversión no determinista de las cadenas de fecha literales en valores DATE.

Caracteres adicionales (pares suplentes)

A partir de SQL Server 2012 (11.x), si se usan intercalaciones de caracteres complementarios (SC), las operaciones CAST de nchar o nvarchar a un tipo nchar o nvarchar de menor longitud no se truncarán dentro de un par suplente. sino que lo hará antes del carácter suplementario. Por ejemplo, el fragmento de código siguiente deja @x con solo ab. No hay espacio suficiente para albergar el carácter suplementario.

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

SELECT CAST (@x AS NVARCHAR (3));

Al usar intercalaciones de SC, el comportamiento de CONVERT es análogo al de CAST. Para más información, vea la sección Caracteres complementarios del artículo Compatibilidad con la intercalación y Unicode.

Soporte de compatibilidad

En versiones anteriores de SQL Server, el estilo predeterminado para CAST y CONVERT operaciones sobre los tipos de datos time y datetime2 es 121, excepto cuando cualquiera de los dos tipos se utiliza en una expresión de columna computada. Para columnas calculadas, el estilo por defecto es 0. Este comportamiento afecta a las columnas calculadas cuando se crean, se usan en consultas que implican autoparametrización o en definiciones de restricciones.

Bajo nivel 110de compatibilidad y superior, las CAST operaciones y CONVERT sobre los tipos de datos time y datetime2 siempre tienen 121 como estilo predeterminado. Si una consulta se basa en el comportamiento antiguo, utiliza un nivel de compatibilidad menor que 110, o especifica explícitamente el 0 estilo en la consulta afectada.

Valor del nivel de compatibilidad	Estilo predeterminado para `CAST` y `CONVERT`¹	Estilo predeterminado para la columna calculada
`< 110`	`121`	`0`
`>= 110`	`121`	`121`

¹ Excepto para las columnas calculadas

Actualizar la base de datos a un nivel 110 de compatibilidad o superior no cambiará los datos de usuario que se han almacenado en el disco. Debe corregir manualmente estos datos según convenga. Por ejemplo, si usaras SELECT INTO crear una tabla a partir de una fuente que contiene una expresión de columna computada descrita anteriormente, los datos (usando estilo 0) se almacenarían en lugar de la definición calculada de columna en sí. Debes actualizar manualmente estos datos para que coincidan con el estilo 121.

Ejemplos

Los ejemplos de código de este artículo utilizan la base de datos de ejemplo AdventureWorks2025, AdventureWorksDW2025 o AdventureWorksLT2025, que puedes descargar del repositorio de GitHub Azure Data SQL Samples Repository.

Un. Uso de CAST y CONVERT

En estos ejemplos se recupera el nombre de aquellos productos que tienen un 3 como primer dígito del precio y se convierte sus valores ListPrice en int.

Uso CAST:

USE AdventureWorks2025;
GO

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

Uso CONVERT:

USE AdventureWorks2025;
GO

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

Este es el conjunto de resultados. El conjunto de resultados de ejemplo es el mismo para CAST y 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

B. Uso de CAST con operadores aritméticos

En este ejemplo se calcula una única columna (Computed) mediante la división de las ventas anuales hasta la fecha (SalesYTD) entre el porcentaje de la comisión (CommissionPCT). Este valor se redondea al número entero más cercano y luego se CAST en un tipo de datos int.

USE AdventureWorks2025;
GO

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

Este es el conjunto de resultados.

C. Uso de CAST para concatenar

En este ejemplo se concatenan expresiones que no son de caracteres usando CAST. Usa la base de datos AdventureWorksDW2025.

SELECT 'The list price is ' + CAST (ListPrice AS VARCHAR (12)) AS ListPrice
FROM dbo.DimProduct
WHERE ListPrice BETWEEN 350.00 AND 400.00;

Este es el conjunto de resultados.

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. Uso de CAST para obtener texto más legible

Este ejemplo se utiliza CAST en la SELECT lista para convertir la Name columna en una columna char(10). Usa la base de datos AdventureWorksDW2025.

SELECT DISTINCT CAST (EnglishProductName AS CHAR (10)) AS Name,
                ListPrice
FROM dbo.DimProduct
WHERE EnglishProductName LIKE 'Long-Sleeve Logo Jersey, M';
GO

Este es el conjunto de resultados.

Name        ListPrice
----------  ---------
Long-Sleev  31.2437
Long-Sleev  32.4935
Long-Sleev  49.99

E. Uso de CAST con la cláusula LIKE

En este ejemplo se convierten los valores money de la columna SalesYTD al tipo de datos int y, después, al tipo de datos char(20), de modo que la cláusula LIKE pueda usarlo.

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

Este es el conjunto de resultados.

FirstName        LastName            SalesYTD         BusinessEntityID
---------------- ------------------- ---------------- -------------
Tsvi             Reiter              2811012.7151      279
Syed             Abbas               219088.8836       288
Rachel           Valdez              2241204.0424      289

F. Uso de CONVERT o CAST con XML con tipo

Estos ejemplos muestran el uso de CONVERT para convertir datos a XML tipado, utilizando el tipo de dato y columnas XML (SQL Server).

En este ejemplo se convierte una cadena con espacios en blanco, texto y marcado en XML con tipo y se quitan todos los espacios en blanco insignificantes (espacios en blanco de límite entre los nodos):

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

En este ejemplo se convierte una cadena similar con espacios en blanco, texto y marcado en XML con tipo y se conservan los espacios en blanco insignificantes (espacios en blanco de límite entre los nodos):

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

En este ejemplo se convierte una cadena con espacios en blanco, texto y marcado en XML con tipo:

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

Consulta Crear instancias de datos XML para más ejemplos.

G. Uso de CAST y CONVERT con datos de fecha y hora

A partir de los valores GETDATE(), en este ejemplo se muestran la fecha y la hora actuales, se usa CAST para cambiarlas a un tipo de datos de caracteres y, después, se usa CONVERT para mostrar la fecha y la hora en el formato ISO 8601.

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

Este es el conjunto de resultados.

UnconvertedDateTime     UsingCast              UsingConvertTo_ISO8601
----------------------- ---------------------- ------------------------------
2022-04-18 09:58:04.570 Apr 18 2022  9:58AM    2022-04-18T09:58:04.570

Este ejemplo es lo opuesto, aproximadamente, al ejemplo anterior. En este ejemplo, se muestra la fecha y la hora como datos de caracteres, se usa CAST para cambiar los datos de caracteres al tipo de datos datetime y, luego, se usa CONVERT para cambiar los datos de caracteres al tipo de datos 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

Este es el conjunto de resultados.

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. Uso de CONVERT con datos binarios y de caracteres

En estos ejemplos se muestran los resultados de la conversión de datos binarios y de caracteres usando estilos diferentes.

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

Este es el conjunto de resultados.

Style 0, binary to character
----------------------------
Name

Este ejemplo muestra que el Estilo 1 puede forzar el truncamiento del resultado. Los caracteres 0x del conjunto de resultados obligan a truncarse.

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

Este es el conjunto de resultados.

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

Este ejemplo muestra que Style 2 no trunca el resultado, porque el resultado no incluye los caracteres 0x.

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

Este es el conjunto de resultados.

Style 2, binary to character
------------------------------
4E616D65

Convierte el valor Name del carácter en un valor binario.

SELECT CONVERT (BINARY (8), 'Name', 0) AS [Style 0, character to binary];

Este es el conjunto de resultados.

Style 0, character to binary
----------------------------
0x4E616D6500000000

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

Este es el conjunto de resultados.

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

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

Este es el conjunto de resultados.

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

Yo. Convierte tipos de datos de fecha y hora

En este ejemplo se muestra la conversión de los tipos de datos date, time y 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];

Asegúrese de que los valores están dentro de un intervalo compatible al considerar una conversión de date a datetime o datetime2. El valor de año mínimo para datetime es 1753, mientras que el valor de año mínimo es 0001 para date y 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. Uso de CONVERT con datos de datetime en formatos diferentes

A partir de los valores GETDATE(), en este ejemplo se usa CONVERT para mostrar todos los estilos de fecha y hora en la sección Estilos de fecha y hora de este artículo.

Formato de número	Ejemplo de consulta	Resultado de muestra
`0`	`SELECT CONVERT(NVARCHAR, GETDATE(), 0)`	23 ago de 2019 13:39
`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`, `24` o `108`	`SELECT CONVERT(NVARCHAR, GETDATE(), 8)`	13:39:17
`9` o `109`	`SELECT CONVERT(NVARCHAR, GETDATE(), 9)`	23 ago 2019 13:39:17:090
`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`, `25` o `121`	`SELECT CONVERT(NVARCHAR, GETDATE(), 21)`	2019-08-23 13:39:17.090
`22`	`SELECT CONVERT(NVARCHAR, GETDATE(), 22)`	08/23/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)`	23 de agosto de 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.09
`127`	`SELECT CONVERT(NVARCHAR, GETDATE(), 127)`	2019-08-23T13:39:17.09
`130`	`SELECT CONVERT(NVARCHAR, GETDATE(), 130)`	22 ذو الحجة 1440 13:39:17.090P
`131`	`SELECT CONVERT(NVARCHAR, GETDATE(), 131)`	22/12/1440 13:39:17.090

K. Efectos de la prioridad de los tipos de datos en las conversiones permitidas

En el siguiente ejemplo se define una variable de tipo varchar(10), se asigna un valor de tipo entero a la variable y, luego, se selecciona una concatenación de la variable con una cadena.

DECLARE @string AS VARCHAR (10);
SET @string = 1;

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

Este es el conjunto de resultados.

Result
-----------------------
1 is a string.

El valor int de 1 se ha convertido a varchar.

En este ejemplo se muestra una consulta similar con una variable int en su lugar:

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

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

En este caso, la instrucción SELECT produce el siguiente error:

Msg 245, Level 16, State 1, Line 3
Conversion failed when converting the varchar value ' is not a string.' to data type int.

Para evaluar la expresión @notastring + ' is not a string.', el Motor de base de datos debe seguir las reglas de precedencia de tipos de datos para completar la conversión implícita antes de que se pueda calcular el resultado de la expresión. Como int tiene una precedencia mayor que varchar, el Motor de base de datos intenta convertir la cadena a entero y falla porque esta cadena no puede convertirse en entero.

Si proporcionamos una cadena que puede ser convertida, la afirmación tiene éxito, como se ve en el siguiente ejemplo:

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

SELECT @notastring + '1';

En este caso, la cadena '1' se puede convertir al valor entero 1, por lo que esta instrucción SELECT devuelve el valor 2. Cuando los tipos de datos proporcionados son enteros, el + operador se convierte en operador matemático de suma, en lugar de una concatenación de cadenas.

Ejemplos: Azure Synapse Analytics

L. Uso de CAST y CONVERT

En este ejemplo se recupera el nombre de aquellos productos que tienen un 3 como primer dígito del precio y se convierte su ListPrice en int. Usa la base de datos AdventureWorksDW2025.

SELECT EnglishProductName AS ProductName,
       ListPrice
FROM dbo.DimProduct
WHERE CAST (ListPrice AS INT) LIKE '3%';

En este ejemplo se muestra la misma consulta, pero usando CONVERT en vez de CAST. Usa la base de datos AdventureWorksDW2025.

SELECT EnglishProductName AS ProductName,
       ListPrice
FROM dbo.DimProduct
WHERE CONVERT (INT, ListPrice) LIKE '3%';

M. Uso de CAST con operadores aritméticos

En este ejemplo se calcula un único valor de columna dividiendo el precio por unidad de producto (UnitPrice) entre el porcentaje de descuento (UnitPriceDiscountPct). Este resultado se redondea al número entero más cercano y, por último, se convierte al tipo de datos int. En este ejemplo se usa la base de datos AdventureWorksDW2025.

SELECT ProductKey,
       UnitPrice,
       UnitPriceDiscountPct,
       CAST (ROUND(UnitPrice * UnitPriceDiscountPct, 0) AS INT) AS DiscountPrice
FROM dbo.FactResellerSales
WHERE SalesOrderNumber = 'SO47355'
      AND UnitPriceDiscountPct > .02;

Este es el conjunto de resultados.

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

Hora Uso de CAST con la cláusula LIKE

Este ejemplo convierte la columna ListPricede dinero en un tipo int, y luego en un tipo char(20), para que la LIKE cláusula pueda usarla. En este ejemplo se usa la base de datos AdventureWorksDW2025.

SELECT EnglishProductName AS Name,
       ListPrice
FROM dbo.DimProduct
WHERE CAST (CAST (ListPrice AS INT) AS CHAR (20)) LIKE '2%';

O. Uso de CAST y CONVERT con datos de fecha y hora

En este ejemplo se muestra la fecha y la hora actuales, se usa CAST para cambiarlas a un tipo de datos de caracteres y, por último, se usa CONVERT para mostrar la fecha y la hora en el formato ISO 8601. En este ejemplo se usa la base de datos 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;

Este es el conjunto de resultados.

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;

Este es el conjunto de resultados.

UnconvertedText         UsingCast               UsingConvertFrom_ISO8601
----------------------- ----------------------- ------------------------
2010-07-25T13:50:38.544 07/25/2010 1:50:38 PM   07/25/2010 1:50:38 PM

Comentarios

¿Le ha resultado útil esta página?

Se actualizó por última vez el 2026-10-16

CAST y CONVERT (Transact-SQL)

Sintaxis

Argumentos

expresión

data_type

largura

estilo

Tipos de valores devueltos

Estilos de fecha y hora

Estilos float y real

Estilos money y smallmoney

Estilos xml

Estilos binarios

Conversiones implícitas

Tipos de datos de valor grande

tipo de datos xml

Tipos de datos text e image

Intercalación de salida

Truncar y redondear resultados

Determinadas conversiones de fecha y hora son no deterministas

Caracteres adicionales (pares suplentes)

Soporte de compatibilidad

Ejemplos

Un. Uso de CAST y CONVERT

B. Uso de CAST con operadores aritméticos

C. Uso de CAST para concatenar

D. Uso de CAST para obtener texto más legible

E. Uso de CAST con la cláusula LIKE

F. Uso de CONVERT o CAST con XML con tipo

G. Uso de CAST y CONVERT con datos de fecha y hora

H. Uso de CONVERT con datos binarios y de caracteres

Yo. Convierte tipos de datos de fecha y hora

J. Uso de CONVERT con datos de datetime en formatos diferentes

K. Efectos de la prioridad de los tipos de datos en las conversiones permitidas

Ejemplos: Azure Synapse Analytics

L. Uso de CAST y CONVERT

M. Uso de CAST con operadores aritméticos

Hora Uso de CAST con la cláusula LIKE

O. Uso de CAST y CONVERT con datos de fecha y hora

Contenido relacionado

Comentarios

Recursos adicionales