CAST y CONVERT (Transact-SQL)
Se aplica a: 
SQL Server Azure SQL Database Azure SQL Managed Instance Azure Synapse Analytics Analytics Platform System (PDW) Punto de conexión de análisis SQL en Microsoft Fabric Almacenamiento 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
expression
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.
length
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.
style
Una expresión de tipo entero que especifica cómo traducirá la función CONVERT la expresión. Para un valor de estilo NULL, se devuelve NULL. 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 que se admiten 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
SQL Server admite el formato de fecha, en estilo árabe, con el algoritmo kuwaití.
| Sin el siglo (yy) 1 | Con el siglo (aaaa) | Estándar | Entrada/salida (3) |
|---|---|---|---|
| - | 0 o 100 1, 2 | Valor predeterminado para datetime y smalldatetime | mon dd yyyy hh:miAM (o PM) |
| 1 | 101 | EE. UU. | 1 = mm/dd/yy101 = mm/dd/yyyy |
| 2 | 102 | ANSI | 2 = yy.mm.dd102 = yyyy.mm.dd |
| 3 | 103 | Británico/Francés | 3 = dd/mm/yy103 = dd/mm/yyyy |
| 4 | 104 | Alemán | 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 | Valor predeterminado + milisegundos | mon dd yyyy hh:mi:ss:mmmAM (o PM) |
| 10 | 110 | EE. UU. | 10 = mm-dd-aa 110 = mm-dd-yyyy |
| 11 | 111 | JAPÓN | 11 = aa/mm/dd 111 = yyyy/mm/dd |
| 12 | 112 | ISO | 12 = aammdd 112 = yyyymmdd |
| - | 13 o 113 1, 2 | Europao predeterminado + milisegundos | dd mon yyyy hh:mi:ss:mmm (24 horas) |
| 14 | 114 | - | hh:mi:ss:mmm (24 horas) |
| - | 20 o 120 2 | ODBC canónico | yyyy-mm-dd hh:mi:ss (24 horas) |
| - | 21 o 25 o 121 2 | ODBC canónico (con milisegundos), valor predeterminado para time, date, datetime2 y datetimeoffset | yyyy-mm-dd hh:mi:ss.mmm (24 horas) |
| 22 | - | EE. UU. | mm/dd/yy hh:mi:ss AM (o PM) |
| - | 23 | ISO8601 | yyyy-mm-dd |
| - | 126 4 | ISO8601 | yyyy-mm-ddThh:mi:ss.mmm (sin espacios) 6 |
| - | 127 8, 9 | ISO8601 con zona horaria Z | yyyy-MM-ddThh:mm:ss.fffZ (sin espacios) 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 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).
2 Los valores predeterminados (0 o 100, 9 o 109, 13 o 113, 20 o 120, 23 y 21 o 25 o 121) siempre devuelven el siglo (yyyy).
Importante
De forma predeterminada, SQL Server interpreta los años de dos dígitos según el año límite 2049. Esto significa que SQL Server 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. SQL Server proporciona la opción de configuración de año límite de dos dígitos para cambiar el año límite usado por SQL Server. Esto permite tratar las fechas de manera coherente. Se recomienda especificar años de cuatro dígitos.
3 Entrada cuando se convierte en datetime; salida cuando se convierte en datos de caracteres.
4 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.
5 Hijri es un sistema del calendario con varias variaciones. SQL Server utiliza el algoritmo kuwaití.
6 En el caso de un valor 0 en milisegundos (mmm), 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.
7 En este estilo, mon es una representación Unicode Hijri multitoken del nombre completo del mes. Este valor no se representa correctamente en una instalación estadounidense predeterminada de SSMS.
8 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.
9 Use el indicador opcional de zona horaria Z para facilitar la asignación de valores XML de tipo datetime que contienen información de zona horaria a valores de tipo SQL Server datetime 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 expression float o real, style puede tener uno de los valores que se muestran en la siguiente tabla. Otros valores se procesan como 0.
| Value | Output |
|---|---|
| 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 expression money o smallmoney, style puede tener uno de los valores que se muestran en la siguiente tabla. Otros valores se procesan como 0.
| Value | Output |
|---|---|
| 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 al estilo 2 al convertir a char(n) o varchar(n) |
Estilos xml
En el caso de una expression xml, style puede tener uno de los valores que se muestran en la siguiente tabla. Otros valores se procesan como 0.
| Value | Output |
|---|---|
| 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 datos xml, los espacios en blanco insignificantes de SQL Server se controlan de forma distinta que en XML 1.0. Para más información, vea 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 comprobar si el atributo standalone tiene el valor yes 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 figuran en la tabla devolverán un error.
| Value | Output |
|---|---|
| 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. En el caso de un data_type binario, los caracteres 0x se agregan a la izquierda del resultado. |
| 1, 2 | Para un data_type binario, la expresión debe ser de caracteres. expression debe tener un número par de dígitos hexadecimales (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F, a, b, c, d, e, f). Si style se establece en 1, los dos primeros caracteres de la expresión deben ser 0x. 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 agregan a la izquierda del resultado convertido para style 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. En la siguiente ilustración se muestran todas las conversiones de tipos de datos explícitas e implícitas permitidas para los tipos de datos proporcionados por el sistema de SQL Server. Algunas de ellas son bigint, sql_variant y xml. No existe una conversión implícita en la asignación del tipo de datos sql_variant, pero sí hay una conversión implícita en sql_variant.
Sugerencia
Este gráfico está disponible como archivo PNG para descargar en el Centro de descarga de Microsoft.
En el gráfico anterior se muestran todas las conversiones explícitas e implícitas permitidas en SQL Server, pero el tipo de datos resultante de la conversión depende de la operación que se lleva a cabo:
- 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, generarán 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 dependerá de las reglas de prioridad de los tipos de datos.
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.
Puesto que los datos Unicode siempre usan un número par de bytes, preste atención al convertir datos binary o varbinary en o desde tipos de datos compatibles con Unicode. Por ejemplo, la siguiente conversión no devuelve el valor hexadecimal 41. Devuelve un valor hexadecimal de 4100:
SELECT CAST(CAST(0x41 AS nvarchar) AS varbinary);
Para más información, consulte Compatibilidad con la intercalación y 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 del tipo de datos xml, vea 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 más información sobre estas reglas, vea Definir la serialización de datos XML. Para más información sobre la conversión de otros tipos de datos al tipo de datos xml, vea 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 intenta una conversión incorrecta (por ejemplo, intentando convertir una expresión de caracteres que incluye letras) a un tipo int, SQL Server devolverá 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 Prioridad de intercalación (Transact-SQL).
Para asignar otra intercalación a la salida, aplique la cláusula COLLATE a la expresión de resultado de las funciones CAST 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 se producen 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 | char varchar |
No se puede mostrar porque es demasiado corto |
| nchar nvarchar |
Error 1 | |
| money, smallmoney, numeric, decimal, float o real | char varchar |
Error 1 |
| nchar nvarchar |
Error 1 |
1 Error devuelto porque el resultado es demasiado corto para mostrarse.
SQL Server garantiza que solo las conversiones circulares (dicho de otra manera, las conversiones que convierten un tipo de datos en otro y después vuelven a convertirlo en el tipo de datos original) devuelvan los mismos valores en versiones diferentes. En el siguiente ejemplo se muestra una conversión circular:
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
Advertencia
No cree valores binary. Después, conviértalos a un tipo de datos de la categoría de datos numéricos. SQL Server no garantiza que el resultado de una conversión de tipos de datos decimal o numeric a binary sea idéntica en las distintas versiones de SQL Server.
En el siguiente ejemplo se muestra una expresión resultante demasiado corta para ser mostrada.
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
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. *
(5 row(s) affected)
Al convertir tipos de datos que difieren en los decimales, SQL Server devolverá a veces un valor de resultado truncado y, otras veces, un valor redondeado. En esta tabla se muestra el comportamiento.
| De | A | Comportamiento |
|---|---|---|
| numeric | numeric | Round |
| numeric | int | Truncate |
| numeric | money | Round |
| money | int | Round |
| money | numeric | Round |
| float | int | Truncate |
| float | numeric | Ronda 1 |
| float | datetime | Round |
| datetime | int | Round |
1 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 se pueden truncar o redondear durante la conversión a los tipos 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;
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);
SQL Server devuelve un mensaje de error al convertir datos char, nchar, nvarchar o varchar no numéricos en datos decimal, float, int o numeric. SQL Server también devuelve un error cuando se convierte una cadena vacía (" ") en los tipos de datos numeric 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 de 100 1
- 106
- 107
- 109
- 113
- 130
1 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 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 de las operaciones CAST y CONVERT en tipos de datos time y datetime2 es 121, a menos que se use otro tipo en una expresión de columna calculada. Para las columnas calculadas, el estilo predeterminado es 0. Este comportamiento afecta a las columnas calculadas cuando se crean, cuando se utilizan en las consultas que implican parametrización automática o cuando se usan en definiciones de restricciones.
En el nivel de compatibilidad 110 y posteriores, las operaciones CAST y CONVERT en los tipos de datos time y datetime2 siempre tienen el estilo predeterminado 121. Si una consulta se basa en el comportamiento anterior, use un nivel de compatibilidad menor de 110, o especifique explícitamente el estilo 0 en la consulta correspondiente.
| Valor del nivel de compatibilidad | Estilo predeterminado para CAST y CONVERT 1 |
Estilo predeterminado para la columna calculada |
|---|---|---|
| <110 | 121 | 0 |
| > = 110 | 121 | 121 |
1 Excepto para las columnas calculadas
Actualizar la base de datos al nivel de compatibilidad 110 y posteriores no cambiará los datos de usuario que se hayan almacenado en disco. Debe corregir manualmente estos datos según convenga. Por ejemplo, si usara SELECT INTO para crear una tabla de un origen que contuviera una expresión de columna calculada como la descrita anteriormente, se almacenarían los datos (si se usa el estilo 0) en lugar de la propia definición de columna calculada. Debe actualizar manualmente estos datos para que coincidan con el estilo 121.
Ejemplos
A. 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.
Use CAST:
USE AdventureWorks2022;
GO
SELECT SUBSTRING(Name, 1, 30) AS ProductName,
ListPrice
FROM Production.Product
WHERE CAST(ListPrice AS INT) LIKE '33%';
GO
Use CONVERT:
USE AdventureWorks2022;
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
(28 rows affected)
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 AdventureWorks2022;
GO
SELECT CAST(ROUND(SalesYTD / CommissionPCT, 0) AS INT) AS Computed
FROM Sales.SalesPerson
WHERE CommissionPCT != 0;
GO
Este es el conjunto de resultados.
Computed
------
379753754
346698349
257144242
176493899
281101272
0
301872549
212623750
298948202
250784119
239246890
101664220
124511336
97688107
(14 row(s) affected)
C. Uso de CAST para concatenar
En este ejemplo se concatenan expresiones que no son de caracteres usando CAST. Usa la base de datos AdventureWorksDW2022.
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
En este ejemplo se usa CAST en la lista SELECT para convertir la columna Name en una columna de tipo char(10). Usa la base de datos AdventureWorksDW2022.
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 SalesYTD de la columna money al tipo de datos int y, después, al tipo de datos char(20), de modo que la cláusula LIKE pueda usarlo.
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
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
(3 row(s) affected)
F. Uso de CONVERT o CAST con XML con tipo
En estos ejemplos se muestra el uso de CONVERT para convertir datos a XML con tipo mediante Tipo de datos XML y columnas (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)
Vea Crear instancias de datos XML para ver 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
(1 row(s) affected)
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
(1 row(s) affected)
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
(1 row(s) affected)
En este ejemplo se muestra que Style 1 puede forzar el truncamiento del resultado. Los caracteres 0x del conjunto de resultados fuerzan el truncamiento.
SELECT CONVERT(CHAR(8), 0x4E616d65, 1) AS [Style 1, binary to character];
Este es el conjunto de resultados.
Style 1, binary to character
------------------------------
0x4E616D
(1 row(s) affected)
En este ejemplo se muestra que Style 2 no trunca el resultado, ya que este 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
(1 row(s) affected)
Convierta el valor del carácter 'Name' 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
(1 row(s) affected)
SELECT CONVERT(BINARY(4), '0x4E616D65', 1) AS [Style 1, character to binary];
Este es el conjunto de resultados.
Style 1, character to binary
----------------------------
0x4E616D65
(1 row(s) affected)
SELECT CONVERT(BINARY(4), '4E616D65', 2) AS [Style 2, character to binary];
Este es el conjunto de resultados.
Style 2, character to binary
----------------------------------
0x4E616D65
(1 row(s) affected)
I. 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 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];
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 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. 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 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 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 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 INT;
SET @notastring = '1';
SELECT @notastring + ' is not a string.' AS Result
En este caso, la instrucción SELECT producirá 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.', SQL Server necesita seguir las reglas de prioridad del tipo de datos para completar la conversión implícita antes de que se pueda calcular el resultado de la expresión. Dado que int tiene una prioridad más alta que varchar, SQL Server intenta convertir la cadena a un entero y produce un error porque esta cadena no se puede convertir a un entero.
Si proporcionamos una cadena que se pueda convertir, la instrucción se ejecutará correctamente, como se ve en el ejemplo siguiente:
DECLARE @notastring 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 un operador matemático de suma, en lugar de una concatenación de cadena.
Ejemplos: Azure Synapse Analytics y Sistema de la plataforma de análisis (PDW)
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 AdventureWorksDW2022.
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 AdventureWorksDW2022.
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 AdventureWorksDW2022.
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
En este ejemplo se convierte ListPrice de la columna money a un tipo int y, luego, a un tipo char(20) , de modo que la cláusula LIKE pueda usarla. En este ejemplo se usa la base de datos AdventureWorksDW2022.
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 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;
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
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. En este ejemplo se usa la base de datos 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;
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
Consulte también
- FORMAT (Transact-SQL)
- STR (Transact-SQL)
- SELECT (Transact-SQL)
- Funciones del sistema (Transact-SQL)
- Compatibilidad con la intercalación y Unicode