Nota
O acesso a esta página requer autorização. Pode tentar iniciar sessão ou alterar os diretórios.
O acesso a esta página requer autorização. Pode tentar alterar os diretórios.
Aplica-se a:
SQL ServerBase de Dados SQL do AzureInstância Gerida do Azure SQLAzure Synapse AnalyticsSistema de Plataforma de Análise (PDW)Ponto de Extremidade de Análise SQL no Microsoft FabricArmazém no Microsoft FabricBase de Dados SQL no Microsoft Fabric
Essas funções convertem uma expressão de um tipo de dados em outro.
Sintaxe
CAST Sintaxe:
CAST ( expression AS data_type [ ( length ) ] )
CONVERT Sintaxe:
CONVERT ( data_type [ ( length ) ] , expression [ , style ] )
Transact-SQL convenções de sintaxe
Argumentos
expressão
Qualquer expressão válida.
data_type
O tipo de dados de destino. Isso inclui xml, bigint e sql_variant. Os tipos de dados de alias não podem ser usados.
comprimento
Um inteiro opcional que especifica o comprimento do tipo de dados de destino, para tipos de dados que permitem um comprimento especificado pelo usuário. O valor padrão é 30.
estilo
Uma expressão inteira que especifica como a função traduzirá a CONVERTexpressão. Para um valor de estilo NULL, NULL é retornado.
data_type determina o intervalo.
Tipos de devolução
Retorna expressão, traduzida para data_type.
Estilos de data e hora
Para uma expressão de tipo de dados de data ou hora, o estilo pode ter um dos valores mostrados na tabela a seguir. Outros valores são processados como 0. A partir do SQL Server 2012 (11.x), os únicos estilos suportados, ao converter de tipos de data e hora para datetimeoffset, são 0 ou 1. Todos os outros estilos de conversão retornam o erro 9809.
Observação
O SQL Server oferece suporte ao formato de data, em estilo árabe, com o algoritmo kuwaitiano.
| Sem século (aa) 1 | Com século (aaaa) | Standard | Entrada/saída 3 |
|---|---|---|---|
| - | 0 ou 1001,2 | Padrão para datetime e smalldatetime |
mon dd yyyy hh:miAM (ou PM) |
| 1 | 101 | EUA | 1 = mm/dd/yy101 = mm/dd/yyyy |
| 2 | 102 | ANSI (Instituto Nacional Americano de Normalização) | 2 = yy.mm.dd102 = yyyy.mm.dd |
| 3 | 103 | Britânico/Francês | 3 = dd/mm/yy103 = dd/mm/yyyy |
| 4 | 104 | Alemão | 4 = dd.mm.yy104 = dd.mm.yyyy |
| 5 | 105 | Italiano | 5 = dd-mm-yy105 = dd-mm-yyyy |
| 6 | 1061 | - | 6 = dd mon yy106 = dd mon yyyy |
| 7 | 1071 | - | 7 = Mon dd, yy107 = Mon dd, yyyy |
| 8 ou 24 | 108 | - | hh:mi:ss |
| - | 9 ou 1091,2 | Padrão + milissegundos |
mon dd yyyy hh:mi:ss:mmmAM (ou PM) |
| 10 | 110 | EUA | 10 = mm-dd-aa 110 = mm-dd-yyyy |
| 11 | 111 | JAPÃO | 11 = aa/mm/dd 111 = yyyy/mm/dd |
| 12 | 112 | ISO | 12 = aammdd 112 = yyyymmdd |
| - | 13 ou 1131,2 | Padrão da Europa + milissegundos |
dd mon yyyy hh:mi:ss:mmm (24 horas) |
| 14 | 114 | - |
hh:mi:ss:mmm (24 horas) |
| - | 20 ou 1202 | ODBC canônico |
yyyy-mm-dd hh:mi:ss (24 horas) |
| - | 21 ou 25 ou 1212 | Padrão canônico ODBC (com milissegundos) para time, date, datetime2 e datetimeoffset |
yyyy-mm-dd hh:mi:ss.mmm (24 horas) |
| 22 | - | EUA |
mm/dd/yy hh:mi:ss AM (ou PM) |
| - | 23 | ISO8601 | yyyy-mm-dd |
| - | 1264 | ISO8601 |
yyyy-mm-ddThh:mi:ss.mmm (sem espaços) 6º |
| - | 127, 8, 9 | ISO8601 com fuso horário Z |
yyyy-MM-ddThh:mm:ss.fffZ (sem espaços) 6º |
| - | 1301,2 | Hijri 5 |
dd mon yyyy hh:mi:ss:mmmAM
7 |
| - | 1312 | Hijri 5 | dd/mm/yyyy hh:mi:ss:mmmAM |
1 Esses valores de estilo retornam resultados não determinísticos. Inclui todos os estilos (yy) (sem século) e um subconjunto de estilos (yyyy) (com século).
2 Os valores padrão (0 ou 100, 9 ou 109, 13 ou 113, 20 ou 120, 23 e 21 ou 25 ou 121) sempre retornam o século (yyyy).
Importante
Por padrão, o SQL Server interpreta anos de dois dígitos com base em um ano de corte de 2049. Isso significa que o SQL Server interpreta o ano 49 de dois dígitos como 2049 e o ano 50 de dois dígitos como 1950. Muitos aplicativos cliente, incluindo aqueles baseados em objetos de automação, usam um ano de corte de 2030. O SQL Server fornece a opção de configuração de corte de ano de dois dígitos para alterar o ano de corte usado pelo SQL Server. Isso permite o tratamento consistente das datas. Recomendamos especificar anos de quatro dígitos.
3 Entrada quando você converte para datetime; quando você converte em dados de caracteres.
4 Projetado para uso XML. Para converter de datetime ou smalldatetime em dados de caracteres, consulte a tabela anterior para o formato de saída.
5 Hijri é um sistema de calendário com várias variações. O SQL Server usa o algoritmo kuwaitiano.
6 Para um valor de milissegundos (mmm) de 0, o valor da fração decimal de milissegundos não será exibido. Por exemplo, o valor 2022-11-07T18:26:20.000 é exibido como 2022-11-07T18:26:20.
7 Neste estilo, mon representa uma representação multi-token Hijri Unicode do nome completo do mês. Esse valor não é renderizado corretamente em uma instalação padrão do SSMS nos EUA.
8 Suportado apenas durante a transmissão de dados de caracteres para datetime ou smalldatetime. Ao transmitir dados de caracteres que representam apenas componentes de data ou hora para os tipos de dados datetime ou smalldatetime , o componente de hora não especificada é definido como 00:00:00.000, e o componente de data não especificada é definido como 1900-01-01.
9 Use o indicador Z de fuso horário opcional para facilitar o mapeamento de valores de data/hora XML com informações de fuso horário para valores de data/hora do SQL Server que não têm fuso horário.
Z indica fuso horário em UTC-0. O HH:MM deslocamento, na direção ou + indica, outros fusos - horários. Por exemplo: 2022-12-12T23:45:12-08:00.
Ao converter smalldatetime em dados de caracteres, os estilos que incluem segundos ou milissegundos mostram zeros nessas posições. Ao converter de valores datetime ou smalldatetime , use um comprimento de tipo de dados char ou varchar apropriado para truncar partes de data indesejadas.
Ao converter dados de caractere em datetimeoffset, usando um estilo que inclui uma hora, um deslocamento de fuso horário é anexado ao resultado.
flutuar e estilos reais
Para uma expressão flutuante ou real, o estilo pode ter um dos valores mostrados na tabela a seguir. Outros valores são processados como 0.
| Valor | Resultado |
|---|---|
| 0 (padrão) | Um máximo de 6 dígitos. Utilização em notação científica, quando apropriado. |
| 1 | Sempre 8 dígitos. Use sempre em notação científica. |
| 2 | Sempre 16 dígitos. Use sempre em notação científica. |
| 3 | Sempre 17 dígitos. Use para conversão sem perdas. Com esse estilo, cada flutuador distinto ou valor real é garantido para converter em uma cadeia de caracteres distinta. Aplica-se a: SQL Server 2016 (13.x) e versões posteriores e Banco de Dados SQL do Azure. |
| 126, 128, 129 | Incluído por razões hereditárias. Não use esses valores para novos desenvolvimentos. |
Estilos de dinheiro e dinheiro pequeno
Para uma expressãomoney ou smallmoney, o estilo pode ter um dos valores mostrados na tabela a seguir. Outros valores são processados como 0.
| Valor | Resultado |
|---|---|
| 0 (padrão) | Sem vírgulas a cada três dígitos à esquerda da vírgula decimal e dois dígitos à direita da vírgula decimal Exemplo: 4235.98. |
| 1 | Vírgulas a cada três dígitos à esquerda da vírgula decimal e dois dígitos à direita da vírgula decimal Exemplo: 3.510,92. |
| 2 | Sem vírgulas a cada três dígitos à esquerda da vírgula decimal e quatro dígitos à direita da vírgula decimal Exemplo: 4235.9819. |
| 126 | Equivalente ao estilo 2, ao converter para char(n) ou varchar(n) |
Estilos XML
Para uma expressãoxml, o estilo pode ter um dos valores mostrados na tabela a seguir. Outros valores são processados como 0.
| Valor | Resultado |
|---|---|
| 0 (padrão) | Use o comportamento de análise padrão que descarta espaço em branco insignificante e não permite um subconjunto DTD interno. Observação: Ao converter para o tipo de dados xml , o espaço em branco insignificante do SQL Server é tratado de forma diferente do XML 1.0. Para obter mais informações, consulte Criar instâncias de dados XML. |
| 1 | Preserve espaços em branco insignificantes. Esta definição de estilo define o tratamento predefinido xml:space para corresponder ao comportamento do xml:space="preserve". |
| 2 | Habilite o processamento limitado de subconjuntos DTD internos. Se habilitado, o servidor pode usar as seguintes informações fornecidas em um subconjunto DTD interno para executar operações de análise não validantes. - Padrões para atributos são aplicados - As referências de entidades internas são resolvidas e expandidas - O modelo de conteúdo DTD é verificado quanto à correção sintática O analisador ignora subconjuntos DTD externos. Além disso, ele não avalia a declaração XML para ver se o atributo autônomo tem um valor sim ou não . Em vez disso, ele analisa a instância XML como um documento autônomo. |
| 3 | Preserve espaços em branco insignificantes e habilite o processamento limitado de subconjuntos DTD internos. |
Estilos binários
Para uma expressão binary(n), char(n), varbinary(n) ou varchar(n), o estilo pode ter um dos valores mostrados na tabela a seguir. Os valores de estilo não listados na tabela retornarão um erro.
| Valor | Resultado |
|---|---|
| 0 (padrão) | Traduz caracteres ASCII para bytes binários ou bytes binários para caracteres ASCII. Cada caractere ou byte é convertido 1:1. Para uma data_type binária, os caracteres 0x são adicionados à esquerda do resultado. |
| 1, 2 | Para uma data_type binária, a expressão deve ser uma expressão de caractere. A expressão deve ter um número par de dígitos hexadecimais (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F, a, b, c, d, e, f). Se o estilo for definido como 1, a expressão deverá ter 0x como os dois primeiros caracteres. Se a expressão contiver um número ímpar de caracteres ou se algum dos caracteres for inválido, um erro será gerado. Se o comprimento da expressão convertida exceder o comprimento do data_type, o resultado será truncado à direita. O comprimento fixo data_types maior que o resultado convertido tem zeros adicionados à direita do resultado. Um data_type de caractere de tipo requer uma expressão binária. Cada caractere binário é convertido em dois caracteres hexadecimais. Suponha que o comprimento da expressão convertida exceda o comprimento do data_type. Nesse caso, é truncado. Para um tipo de caractere de tamanho fixo data_type, se o comprimento do resultado convertido for menor do que o comprimento do data_type, espaços serão adicionados à direita da expressão convertida para manter um número par de dígitos hexadecimais. Os caracteres 0x não são adicionados à esquerda do resultado convertido para o estilo 2. |
Conversões implícitas
As conversões implícitas não requerem especificação CAST da função ou da CONVERT função. Conversões explícitas requerem a CAST especificação da função ou da CONVERT função. A ilustração a seguir mostra todas as conversões de tipo de dados explícitas e implícitas permitidas para tipos de dados fornecidos pelo sistema SQL Server. Estes incluem bigint, sql_variant e xml. Não há conversão implícita na atribuição do tipo de dados sql_variant , mas há conversão implícita para sql_variant.
Sugestão
O Centro de Download da Microsoft tem este gráfico disponível para download como um arquivo PNG.
O gráfico acima ilustra todas as conversões explícitas e implícitas permitidas no SQL Server, mas o tipo de dados resultante da conversão depende da operação que está sendo executada:
- Para conversões explícitas, a própria instrução determina o tipo de dados resultante.
- Para conversões implícitas, instruções de atribuição, como definir o valor de uma variável ou inserir um valor em uma coluna, resultarão no tipo de dados que foi definido pela declaração de variável ou definição de coluna.
- Para operadores de comparação ou outras expressões, o tipo de dados resultante dependerá das regras de precedência do tipo de dados.
Sugestão
Um exemplo prático sobre os efeitos da precedência do tipo de dados em conversões pode ser visto mais adiante nesta seção.
Quando você converte entre datetimeoffset e os tipos de caractere char, nchar, nvarchar e varchar, a parte de deslocamento de fuso horário convertida sempre deve ter dois dígitos para ambos e . HHMM Por exemplo, -08:00.
Como os dados Unicode sempre usam um número par de bytes, tenha cuidado ao converter binários ou varbinary para ou de tipos de dados suportados por Unicode. Por exemplo, a conversão a seguir não retorna um valor hexadecimal de 41. Ele retorna um valor hexadecimal de 4100:
SELECT CAST(CAST(0x41 AS nvarchar) AS varbinary);
Para obter mais informações, consulte Collation and Unicode Support.
Tipos de dados de grande valor
Os tipos de dados de grande valor têm o mesmo comportamento de conversão implícito e explícito que seus homólogos menores - especificamente, os tipos de dados nvarchar, varbinary e varchar . No entanto, considere as seguintes diretrizes:
- A conversão de imagem para varbinary(max), e vice-versa, opera como uma conversão implícita, assim como as conversões entre texto e varchar(max), e ntext e nvarchar(max).
- A conversão de tipos de dados de valor grande, como varchar(max), para um tipo de dados de contrapartida menor, como varchar, é uma conversão implícita, mas o truncamento ocorre se o tamanho do valor grande exceder o comprimento especificado do tipo de dados menor.
- A conversão de nvarchar, varbinary ou varchar para seus tipos de dados de grande valor correspondentes acontece implicitamente.
- A conversão do tipo de dados sql_variant para os tipos de dados de grande valor é uma conversão explícita.
- Tipos de dados de grande valor não podem ser convertidos para o tipo de dados sql_variant .
Para obter mais informações sobre a conversão do tipo de dados xml , consulte Criar instâncias de dados XML.
Tipo de dados XML
Quando você converte explícita ou implicitamente o tipo de dados xml em uma cadeia de caracteres ou tipo de dados binário, o conteúdo do tipo de dados xml é serializado com base em um conjunto definido de regras. Para obter informações sobre essas regras, consulte Definir a serialização de dados XML. Para obter informações sobre a conversão de outros tipos de dados para o tipo de dados xml , consulte Criar instâncias de dados XML.
Tipos de dados de texto e imagem
Os tipos de dados de texto e imagem não suportam a conversão automática de tipos de dados. Você pode converter explicitamente dados de texto em dados de caracteres e dados de imagem em binários ou varbinary, mas o comprimento máximo é de 8000 bytes. Se você tentar uma conversão incorreta, por exemplo, tentando converter uma expressão de caractere que inclui letras para um int, o SQL Server retornará uma mensagem de erro.
Agrupamento de saída
Quando as CAST funções ou CONVERT produzem uma cadeia de caracteres e recebem uma entrada de cadeia de caracteres, a saída tem o mesmo rótulo de agrupamento e agrupamento que a entrada. Se a entrada não for uma cadeia de caracteres, a saída terá o agrupamento padrão do banco de dados e um rótulo de agrupamento de padrão coercível. Para obter mais informações, consulte Precedência de agrupamento (Transact-SQL).
Para atribuir um agrupamento diferente à saída, aplique a cláusula COLLATE à expressão de resultado da CAST função ou CONVERT . Por exemplo:
SELECT CAST('abc' AS varchar(5)) COLLATE French_CS_AS;
Resultados de truncamento e arredondamento
Ao converter expressões binárias ou de caracteres (binary, char, nchar, nvarchar, varbinary ou varchar) em uma expressão de um tipo de dados diferente, a operação de conversão pode truncar os dados de saída, exibir apenas parcialmente os dados de saída ou retornar um erro. Esses casos ocorrerão se o resultado for muito curto para ser exibido. As conversões para binário, char, nchar, nvarchar, varbinário ou varchar são truncadas, exceto para as conversões mostradas na tabela a seguir.
| Do tipo de dados | Para o tipo de dados | Resultado |
|---|---|---|
| int, smallint ou tinyint |
char Varchar |
Demasiado curto para ser apresentado |
|
Nchar Nvarchar |
Erro 1 | |
| dinheiro, dinheiro pequeno, numérico, decimal, flutuante ou real |
char Varchar |
Erro 1 |
|
Nchar Nvarchar |
Erro 1 |
1 Erro retornado porque o comprimento do resultado é muito curto para ser exibido.
O SQL Server garante que apenas conversões de ida e volta, ou seja, conversões que convertem um tipo de dados de seu tipo de dados original e vice-versa, produzem os mesmos valores de versão para versão. O exemplo a seguir mostra essa conversão de ida e volta:
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
Advertência
Não construa valores binários e, em seguida, converta-os em um tipo de dados da categoria de tipo de dados numéricos. O SQL Server não garante que o resultado de uma conversão de tipo de dados decimal ou numérico , para binário, será o mesmo entre as versões do SQL Server.
O exemplo a seguir mostra uma expressão resultante que é muito pequena para ser exibida.
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
Aqui está o 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)
Quando você converte tipos de dados que diferem em casas decimais, o SQL Server às vezes retorna um valor de resultado truncado e, em outras ocasiões, retorna um valor arredondado. Esta tabela mostra o comportamento.
| De | Para | Comportamento |
|---|---|---|
| numérico | numérico | Rodada |
| numérico | Int | Truncar |
| numérico | dinheiro | Rodada |
| dinheiro | Int | Rodada |
| dinheiro | numérico | Rodada |
| flutuar | Int | Truncar |
| flutuar | numérico | 1ª Rodada |
| flutuar | datetime | Rodada |
| datetime | Int | Rodada |
1 A conversão de valores flutuantes que usam notação científica para decimal ou numérica é restrita a valores de precisão de 17 dígitos apenas. Qualquer valor com precisão superior a 17 arredondamentos para zero.
Por exemplo, os valores 10,6496 e -10,6496 podem ser truncados ou arredondados durante a conversão para tipos int ou 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;
Os resultados da consulta são mostrados na tabela a seguir:
| trunc1 | trunc2 | Ronda1 | 2ª Rodada |
|---|---|---|---|
| 10 | -10 | 11 | -11 |
Ao converter tipos de dados em que o tipo de dados de destino tem menos casas decimais do que o tipo de dados de origem, o valor é arredondado. Por exemplo, esta conversão devolve $10.3497:
SELECT CAST(10.3496847 AS money);
O SQL Server retorna uma mensagem de erro ao converter dados não numéricos char, nchar, nvarchar ou varchar em decimal, float, int, numérico. O SQL Server também retorna um erro quando uma cadeia de caracteres vazia (" ") é convertida em numérica ou decimal.
Certas conversões de data/hora são não determinísticas
Os estilos para os quais a conversão string-to-datetime é não-determinística são os seguintes:
- Todos os estilos abaixo de 100 1
- 106
- 107
- 109
- 113
- 130
1 Com exceção dos estilos 20 e 21
Para obter mais informações, consulte Conversão não determinística de cadeias literais de data em valores DATE.
Caracteres suplementares (pares substitutos)
A partir do SQL Server 2012 (11.x), ao usar agrupamentos de caracteres suplementares (SC), uma CAST operação de nchar ou nvarchar para um tipo nchar ou nvarchar de comprimento menor não será truncada dentro de um par substituto. Em vez disso, a operação trunca antes do caractere suplementar. Por exemplo, o fragmento de código a seguir deixa @x segurando apenas 'ab'. Não há espaço suficiente para manter o caráter suplementar.
DECLARE @x NVARCHAR(10) = 'ab' + NCHAR(0x10000);
SELECT CAST(@x AS NVARCHAR(3));
Ao usar agrupamentos SC, o comportamento de CONVERT, é análogo ao de CAST. Para obter mais informações, consulte Suporte a agrupamento e Unicode - caracteres suplementares.
Suporte de compatibilidade
Em versões anteriores do SQL Server, o estilo padrão para CAST operações CONVERT nos tipos de dados time e datetime2 é 121, exceto quando qualquer um dos tipos é usado em uma expressão de coluna computada. Para colunas computadas, o estilo padrão é 0. Esse comportamento afeta colunas computadas quando elas são criadas, usadas em consultas que envolvem parametrização automática ou usadas em definições de restrição.
No nível de compatibilidade 110 e superior, as CAST operações e CONVERT nos tipos de dados time e datetime2 sempre têm 121 como estilo padrão. Se uma consulta depender do comportamento antigo, use um nível de compatibilidade menor que 110 ou especifique explicitamente o estilo 0 na consulta afetada.
| Valor do nível de compatibilidade | Estilo padrão para CAST e CONVERT1 |
Estilo padrão para coluna computada |
|---|---|---|
| < 110 | 121 | 0 |
| > = 110 | 121 | 121 |
1 Exceto colunas computadas
Atualizar o banco de dados para o nível de compatibilidade 110 e superior não alterará os dados do usuário que foram armazenados no disco. Você deve corrigir manualmente esses dados conforme apropriado. Por exemplo, se você usou SELECT INTO para criar uma tabela a partir de uma fonte contendo uma expressão de coluna computada descrita acima, os dados (usando o estilo 0) seriam armazenados em vez da própria definição de coluna computada. Você deve atualizar manualmente esses dados para corresponder ao estilo 121.
Exemplos
Um. Use CAST e CONVERT
Estes exemplos recuperam o nome do produto, para os produtos que têm um 3 como o primeiro dígito do preço de tabela, e converte seus ListPrice valores em int.
Utilize CAST:
USE AdventureWorks2022;
GO
SELECT SUBSTRING(Name, 1, 30) AS ProductName,
ListPrice
FROM Production.Product
WHERE CAST(ListPrice AS INT) LIKE '33%';
GO
Utilize CONVERT:
USE AdventureWorks2022;
GO
SELECT SUBSTRING(Name, 1, 30) AS ProductName,
ListPrice
FROM Production.Product
WHERE CONVERT(INT, ListPrice) LIKE '33%';
GO
Aqui está o conjunto de resultados. O conjunto de resultados da amostra é o mesmo para ambos 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
(28 rows affected)
B. Usar CAST com operadores aritméticos
Este exemplo calcula um cálculo de coluna única (Computed) dividindo o total de vendas do ano até a data (SalesYTD) pela porcentagem de comissão (CommissionPCT). Esse valor é arredondado para o número inteiro mais próximo e, em seguida, CAST para um tipo de dados int .
USE AdventureWorks2022;
GO
SELECT CAST(ROUND(SalesYTD / CommissionPCT, 0) AS INT) AS Computed
FROM Sales.SalesPerson
WHERE CommissionPCT != 0;
GO
Aqui está o conjunto de resultados.
Computed
------
379753754
346698349
257144242
176493899
281101272
0
301872549
212623750
298948202
250784119
239246890
101664220
124511336
97688107
(14 row(s) affected)
C. Use CAST para concatenar
Este exemplo concatena expressões sem caracteres usando CAST. Utiliza a AdventureWorksDW2025 base de dados.
SELECT 'The list price is ' + CAST(ListPrice AS VARCHAR(12)) AS ListPrice
FROM dbo.DimProduct
WHERE ListPrice BETWEEN 350.00 AND 400.00;
Aqui está o 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. Use CAST para produzir texto mais legível
Este exemplo usa CAST na lista SELECT para converter a Name coluna em uma coluna char(10 ). Utiliza a AdventureWorksDW2025 base de dados.
SELECT DISTINCT CAST(EnglishProductName AS CHAR(10)) AS Name,
ListPrice
FROM dbo.DimProduct
WHERE EnglishProductName LIKE 'Long-Sleeve Logo Jersey, M';
GO
Aqui está o conjunto de resultados.
Name ListPrice
---------- ---------
Long-Sleev 31.2437
Long-Sleev 32.4935
Long-Sleev 49.99
E. Use CAST com a cláusula LIKE
Este exemplo converte os valores de money coluna SalesYTD em tipo de dados int e, em seguida, em tipo de dados char(20), para que a LIKE cláusula possa usá-lo.
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
Aqui está o 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. Usar CONVERT ou CAST com XML digitado
Estes exemplos mostram o uso de para converter dados em XML digitado, usando o Tipo de CONVERTDados XML e Colunas (SQL Server).
Este exemplo converte uma cadeia de caracteres com espaço em branco, texto e marcação em XML digitado e remove todo o espaço em branco insignificante (espaço em branco limite entre nós):
SELECT CONVERT(XML, '<root><child/></root>')
Este exemplo converte uma cadeia de caracteres semelhante com espaço em branco, texto e marcação em XML digitado e preserva espaço em branco insignificante (espaço em branco limite entre nós):
SELECT CONVERT(XML, '<root> <child/> </root>', 1)
Este exemplo converte uma cadeia de caracteres com espaço em branco, texto e marcação em XML digitado:
SELECT CAST('<Name><FName>Carol</FName><LName>Elliot</LName></Name>' AS XML)
Consulte Criar instâncias de dados XML para obter mais exemplos.
G. Use CAST e CONVERT com dados datetime
Começando com GETDATE() valores, este exemplo exibe a data e a hora atuais, usa CAST para alterar a data e a hora atuais para um tipo de dados de caractere e, em seguida, usa CONVERT para exibir a data e a hora no ISO 8601 formato.
SELECT GETDATE() AS UnconvertedDateTime,
CAST(GETDATE() AS NVARCHAR(30)) AS UsingCast,
CONVERT(NVARCHAR(30), GETDATE(), 126) AS UsingConvertTo_ISO8601;
GO
Aqui está o 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 exemplo é aproximadamente o oposto do exemplo anterior. Este exemplo exibe uma data e hora como dados de caracteres, usa CAST para alterar os dados de caractere para o tipo de dados datetime e, em seguida, usa CONVERT para alterar os dados de caractere para o tipo de dados 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
Aqui está o 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. Use CONVERT com dados binários e de caracteres
Estes exemplos mostram os resultados da conversão de dados binários e 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];
Aqui está o conjunto de resultados.
Style 0, binary to character
----------------------------
Name
(1 row(s) affected)
Este exemplo mostra que o Estilo 1 pode forçar o truncamento de resultados. Os caracteres 0x no conjunto de resultados forçam o truncamento.
SELECT CONVERT(CHAR(8), 0x4E616d65, 1) AS [Style 1, binary to character];
Aqui está o conjunto de resultados.
Style 1, binary to character
------------------------------
0x4E616D
(1 row(s) affected)
Este exemplo mostra que o Estilo 2 não trunca o resultado, porque o resultado não inclui os caracteres 0x.
SELECT CONVERT(CHAR(8), 0x4E616d65, 2) AS [Style 2, binary to character];
Aqui está o conjunto de resultados.
Style 2, binary to character
------------------------------
4E616D65
(1 row(s) affected)
Converta o valor do caractere 'Name' em um valor binário.
SELECT CONVERT(BINARY(8), 'Name', 0) AS [Style 0, character to binary];
Aqui está o 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];
Aqui está o 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];
Aqui está o conjunto de resultados.
Style 2, character to binary
----------------------------------
0x4E616D65
(1 row(s) affected)
Eu. Converter tipos de dados de data e hora
Este exemplo mostra a conversão dos tipos de dados date, time e datetime .
DECLARE @d1 DATE,
@t1 TIME,
@dt1 DATETIME;
SET @d1 = GETDATE();
SET @t1 = GETDATE();
SET @dt1 = GETDATE();
SET @d1 = GETDATE();
-- When converting date to datetime the minutes portion becomes zero.
SELECT @d1 AS [DATE],
CAST(@d1 AS DATETIME) AS [date as datetime];
-- When converting time to datetime the date portion becomes zero
-- which converts to January 1, 1900.
SELECT @t1 AS [TIME],
CAST(@t1 AS DATETIME) AS [time as datetime];
-- When converting datetime to date or time non-applicable portion is dropped.
SELECT @dt1 AS [DATETIME],
CAST(@dt1 AS DATE) AS [datetime as date],
CAST(@dt1 AS TIME) AS [datetime as time];
Verifique se os valores estão dentro de um intervalo compatível ao considerar uma conversão de date para datetime ou datetime2. O valor mínimo de ano para datetime é 1753, enquanto o valor mínimo de year é 0001 para date e datetime2.
DECLARE @d1 DATE, @dt1 DATETIME , @dt2 DATETIME2
SET @d1 = '1492-08-03'
--This is okay; Minimum YYYY for DATE is 0001
SET @dt2 = CAST(@d1 AS DATETIME2)
--This is okay; Minimum YYYY for DATETIME2 IS 0001
SET @dt1 = CAST(@d1 AS DATETIME)
--This will error with (Msg 242) "The conversion of a date data type to a datetime data type resulted in an out-of-range value."
--Minimum YYYY for DATETIME is 1753
J. Use CONVERT com dados datetime em diferentes formatos
Começando com GETDATE() valores, este exemplo usa CONVERT para exibir todos os estilos de data e hora na seção Estilos de data e hora deste artigo.
| Formato # | Exemplo de consulta | Resultado da amostra |
|---|---|---|
| 0 | SELECT CONVERT(NVARCHAR, GETDATE(), 0) |
Ago 23, 2019 13: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) |
23 de agosto de 19 |
| 8 ou 24 ou 108 | SELECT CONVERT(NVARCHAR, GETDATE(), 8) |
13:39:17 |
| 9 ou 109 | SELECT CONVERT(NVARCHAR, GETDATE(), 9) |
23 de agosto de 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 ou 113 | SELECT CONVERT(NVARCHAR, GETDATE(), 13) |
23 ago 2019 13:39:17:090 |
| 14 ou 114 | SELECT CONVERT(NVARCHAR, GETDATE(), 14) |
13:39:17:090 |
| 20 ou 120 | SELECT CONVERT(NVARCHAR, GETDATE(), 20) |
2019-08-23 13:39:17 |
| 21 ou 25 ou 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 |
| cento e vinte | SELECT CONVERT(NVARCHAR, GETDATE(), 120) |
2019-08-23 13:39:17 |
| 121 | SELECT CONVERT(NVARCHAR, GETDATE(), 121) |
2019-08-23 13:39:17.090 |
| 126 | SELECT CONVERT(NVARCHAR, GETDATE(), 126) |
2019-08-23T13:39:17.090 |
| 127 | SELECT CONVERT(NVARCHAR, GETDATE(), 127) |
2019-08-23T13:39:17.090 |
| 130 | SELECT CONVERT(NVARCHAR, GETDATE(), 130) |
22 ذو الحجة 1440 1:39:17.090P |
| 131 | SELECT CONVERT(NVARCHAR, GETDATE(), 131) |
22/12/1440 13:39:17.090PM |
K. Efeitos da precedência do tipo de dados nas conversões permitidas
O exemplo a seguir define uma variável do tipo varchar(10), atribui um valor inteiro à variável e, em seguida, seleciona uma concatenação da variável com uma cadeia de caracteres.
DECLARE @string VARCHAR(10);
SET @string = 1;
SELECT @string + ' is a string.' AS Result
Aqui está o conjunto de resultados.
Result
-----------------------
1 is a string.
O valor int de 1 foi convertido em varchar.
Este exemplo mostra uma consulta semelhante, usando uma variável int :
DECLARE @notastring INT;
SET @notastring = '1';
SELECT @notastring + ' is not a string.' AS Result
Nesse caso, a instrução SELECT lançará o seguinte erro:
Msg 245, Level 16, State 1, Line 3
Conversion failed when converting the varchar value ' is not a string.' to data type int.
Para avaliar a expressão @notastring + ' is not a string.', o SQL Server precisa seguir as regras de precedência do tipo de dados para concluir a conversão implícita antes que o resultado da expressão possa ser calculado. Como int tem uma precedência maior do que varchar, o SQL Server tenta converter a cadeia de caracteres em um inteiro e falha porque essa cadeia de caracteres não pode ser convertida em um inteiro.
Se fornecermos uma cadeia de caracteres que possa ser convertida, a instrução terá êxito, como visto no exemplo a seguir:
DECLARE @notastring INT;
SET @notastring = '1';
SELECT @notastring + '1'
Nesse caso, a cadeia de caracteres '1' pode ser convertida para o valor inteiro 1, portanto, essa instrução SELECT retornará o valor 2. Quando os tipos de dados fornecidos são inteiros, o operador + torna-se operador matemático de adição, em vez de uma concatenação de cadeia de caracteres.
Exemplos: Azure Synapse Analytics and Analytics Platform System (PDW)
L. Usar CAST e CONVERT
Este exemplo recupera o nome do produto para os produtos que têm um 3 no primeiro dígito de seu preço de tabela e converte o ListPrice desses produtos em int. Utiliza a AdventureWorksDW2025 base de dados.
SELECT EnglishProductName AS ProductName, ListPrice
FROM dbo.DimProduct
WHERE CAST(ListPrice AS int) LIKE '3%';
Este exemplo mostra a mesma consulta, usando CONVERT em vez de CAST. Utiliza a AdventureWorksDW2025 base de dados.
SELECT EnglishProductName AS ProductName, ListPrice
FROM dbo.DimProduct
WHERE CONVERT(INT, ListPrice) LIKE '3%';
M. Usar CAST com operadores aritméticos
Este exemplo calcula um valor de coluna única dividindo o preço unitário do produto (UnitPrice) pela porcentagem de desconto (UnitPriceDiscountPct). Este resultado é então arredondado para o número inteiro mais próximo e, finalmente, convertido para um tipo de dados int . Este exemplo usa o AdventureWorksDW2025 banco de dados.
SELECT ProductKey, UnitPrice,UnitPriceDiscountPct,
CAST(ROUND (UnitPrice*UnitPriceDiscountPct,0) AS int) AS DiscountPrice
FROM dbo.FactResellerSales
WHERE SalesOrderNumber = 'SO47355'
AND UnitPriceDiscountPct > .02;
Aqui está o 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
N. Use CAST com a cláusula LIKE
Este exemplo converte a coluna ListPrice em um tipo int e, em seguida, em um tipo char(20), para que a cláusula LIKE possa usá-la. Este exemplo usa o AdventureWorksDW2025 banco de dados.
SELECT EnglishProductName AS Name, ListPrice
FROM dbo.DimProduct
WHERE CAST(CAST(ListPrice AS INT) AS CHAR(20)) LIKE '2%';
O. Use CAST e CONVERT com dados datetime
Este exemplo exibe a data e a hora atuais, usa CAST para alterar a data e a hora atuais para um tipo de dados de caractere e, finalmente, usa CONVERT exibir a data e a hora no formato ISO 8601. Este exemplo usa o AdventureWorksDW2025 banco de dados.
SELECT TOP(1)
SYSDATETIME() AS UnconvertedDateTime,
CAST(SYSDATETIME() AS NVARCHAR(30)) AS UsingCast,
CONVERT(NVARCHAR(30), SYSDATETIME(), 126) AS UsingConvertTo_ISO8601
FROM dbo.DimCustomer;
Aqui está o 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 exemplo é o oposto do exemplo anterior. Este exemplo exibe uma data e hora como dados de caracteres, usa CAST para alterar os dados de caractere para o tipo de dados datetime e, em seguida, usa CONVERT para alterar os dados de caractere para o tipo de dados datetime . Este exemplo usa o AdventureWorksDW2025 banco de dados.
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;
Aqui está o 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
Ver também
- FORMATO (Transact-SQL)
- STR (Transact-SQL)
- SELECIONAR (Transact-SQL)
- Funções do sistema (Transact-SQL)
- Suporte a agrupamento e Unicode