CAST och CONVERT (Transact-SQL)

Gäller för:SQL ServerAzure SQL DatabaseAzure SQL Managed InstanceAzure Synapse AnalyticsSQL-analysendpoint i Microsoft FabricLager i Microsoft FabricSQL-databas i Microsoft Fabric

Dessa funktioner konverterar ett uttryck av en datatyp till en annan.

Syntax

CAST Syntax:

CAST ( expression AS data_type [ ( length ) ] )

CONVERT Syntax:

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

Transact-SQL syntaxkonventioner

Argumentpunkter

uttryck

Valfritt giltigt uttryck.

data_type

Måldatatypen. Detta omfattar xml, bigint och sql_variant. Aliasdatatyper kan inte användas.

längd

Ett valfritt heltal som anger längden på måldatatypen för datatyper som tillåter en användares angivna längd. Standardvärdet är 30.

stil

Ett heltalsuttryck som specificerar hur CONVERT funktionen översätter uttrycket. För ett stilvärde på NULL, NULL returneras. data_type avgör intervallet.

Returtyper

Returnerar uttryck, översatt till data_type.

Datum- och tidsformat

För ett datum- eller tidsdatatyputtryck kan formatmallen ha något av värdena som visas i följande tabell. Andra värden bearbetas som 0. Från och med SQL Server 2012 (11.x) är 0 de enda stilar som stöds vid konvertering från datum- och tidstyper till datumtidsoffset, eller 1. Alla andra konverteringsformat returnerar fel 9809.

¹ Dessa formatvärden returnerar icke-terministiska resultat. Innehåller alla () (yyutan århundrade) stilar och en delmängd av (yyyy) (med århundradet) stilar.

² Standardvärdena (0 eller 100, 9 eller 109, eller , 13 eller 113, 20 eller 120, 23, och 21 eller 25 eller ) 121returnerar alltid århundradet (yyyy).

³ Indata när du konverterar till datetime; utdata när du konverterar till teckendata.

⁴ Utformad för XML-användning. För konvertering från datetime eller smalldatetime till teckendata, se föregående tabell för utdataformatet.

⁵ Hijri är ett kalendersystem med flera varianter. Database Engine använder Kuwaits algoritm.

⁶ För ett millisekundersvärde (fff) på 0 visas inte decimaltalsvärdet för millisekunder. Värdet 2022-11-07T18:26:20.000 visas till exempel som 2022-11-07T18:26:20.

⁷ I det här formatet MMMM representerar en Hijri Unicode-representation med flera token av det fullständiga månadsnamnet. Det här värdet återges inte korrekt vid en standardinstallation av SSMS i USA.

⁸ Stöds endast vid gjutning från teckendata till datetime eller smalldatetime. När gjutning av teckendata som endast representerar datum- eller endast tidskomponenter till datatyperna datetime eller smalldatetime anges den ospecificerade tidskomponenten till 00:00:00.000och den ospecificerade datumkomponenten är inställd på 1900-01-01.

⁹ Använd den valfria tidszonindikatorn Z för att göra det enklare att mappa XML-datumtidsvärden som har tidszonsinformation till Database Engine datumtidsvärden utan tidszon. Z anger tidszon vid UTC-0. Förskjutningen HH:mm , i + eller - riktningen, anger andra tidszoner. Till exempel: 2022-12-12T23:45:12-08:00.

När du konverterar smalldatetime till teckendata visar formatmallarna som innehåller sekunder eller millisekunder nollor i dessa positioner. När du konverterar från datetime - eller smalldatetime-värden använder du en lämplig tecken - eller varchar-datatyp för att trunkera oönskade datumdelar.

När du konverterar teckendata till datetimeoffset läggs en tidszonsförskjutning till i resultatet med hjälp av ett format som innehåller en tid.

flyttal och riktiga formatmallar

För ett flyttal eller ett verkligtuttryck kan formatmallen ha ett av värdena som visas i följande tabell. Andra värden bearbetas som 0.

pengar och smallmoney stilar

För ett money- eller smallmoney-uttryck kan formatmallen ha ett av värdena som visas i följande tabell. Andra värden bearbetas som 0.

xml-formatmallar

För ett XML-uttryck kan formatmallen ha ett av värdena som visas i följande tabell. Andra värden bearbetas som 0.

Binära formatmallar

För ett binärt(n), char(n), varbinary(n)eller varchar(n)-uttryck kan formatmallen ha ett av värdena som visas i följande tabell. Stilvärden som inte listas i tabellen ger ett felmeddelande.

Implicita konverteringar

Implicita konverteringar kräver inte specifikation av antingen CAST funktionen eller CONVERT funktionen. Explicita konverteringar kräver specifikation av CAST funktionen eller CONVERT funktionen. Följande illustration visar alla explicita och implicita datatypkonverteringar som tillåts för Database Engine-systemets tillhandahållna datatyper. Dessa inkluderar bigint, sql_variant, xml, hierarchyid, geography, geometry, json och vector. Json- och vektordatatyperna finns endast tillgängliga i SQL Server 2025 (17.x), Azure SQL Database, Azure SQL Managed Instance och SQL database i Microsoft Fabric. Det finns ingen implicit konvertering vid tilldelning från sql_variant datatyp, men det finns en implicit konvertering till sql_variant.

Diagrammet ovan illustrerar alla explicita och implicita konverteringar som är tillåtna i Database Engine, men den resulterande datatypen för konverteringen beror på den operation som utförs:

• För explicita konverteringar avgör själva instruktionen den resulterande datatypen.
• För implicita konverteringar resulterar tilldelningsuttryck som att ange värdet för en variabel eller infoga ett värde i en kolumn i datatypen som definierades av variabeldeklarationen eller kolumndefinitionen.
• För jämförelseoperatorer eller andra uttryck beror den resulterande datatypen på reglerna för datatypprioritet.

För vissa datatyper beror resultatet på hur datatypen deklareras:

• Decimal och numerisk: Database Engine behandlar varje kombination av precision och skala som en annan datatyp. Omvändelse mellan dem kan vara underförstådd. Ett värde med fler decimaler än målskalan avrundas utan fel. Ett värde som är för stort för målprecisionen orsakar fel 8115, om ARITHABORT inte och ANSI_WARNINGS är båda OFF; då blir NULLresultatet .
• Du kan inte konvertera varchar(max),nvarchar(max) och varbinary(max) till sql_variant.
• Konvertering mellan olika CLR-användardefinierade typer är inte tillåten.
• Implicit konvertering stöds mellan otypad xml och typad xml, samt mellan typade xml-värden som använder samma XML-schemasamling och samma DOCUMENT eller CONTENT facet.
• Konvertering mellan olika XML-schemasamlingar, eller mellan olika DOCUMENT och CONTENT fasetter, måste vara explicit. Konvertering mellan en CLR-användardefinierad typ och en typad xml är inte tillåten.
• Konvertering mellan vektorvärden är endast tillåten när dimensionerna och bastypen (float32 eller float16) är desamma.

En konvertering som diagrammet visar som tillåten kan fortfarande misslyckas för ett specifikt värde, till exempel en sträng som inte är giltig JSON, eller en vektor med ett annat antal dimensioner. Värden för bild-, ntext-, text-, xml-, geografi-, geometri-, json- och vektordatatyperna kan inte jämföras med operatorn lika med (=), även om båda värdena har samma datatyp.

När du konverterar mellan datetimeoffset och teckentyperna char, nchar, nvarchar och varchar bör den konverterade tidszonsförskjutningsdelen alltid ha tvåsiffriga tal för både HH och mm. Till exempel -08:00.

Nchar- och nvarchar-datatyperna lagrar Unicode-data i UTF-16-kodning, som alltid använder ett jämnt antal byte. Var försiktig när du konverterar binär eller varbinary till eller från nchar eller nvarchar. Till exempel ger följande omvandling inte ett hexadecimalt värde av 41. Den returnerar ett hexadecimalt värde av 4100:

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

För mer information, se Sortering och Unicode-stöd.

Datatyper med stort värde

Datatyper med stora värden har samma implicita och explicita konverteringsbeteende som deras mindre motsvarigheter – mer specifikt datatyperna nvarchar, varbinary och varchar . Tänk dock på följande riktlinjer:

• Konvertering från bild till varbinary(max) och vice versa fungerar som en implicit konvertering, liksom konverteringar mellan text och varchar(max), och ntext och nvarchar(max).
• Konvertering från datatyper med stort värde, till exempel varchar(max), till en mindre motsvarighetsdatatyp, till exempel varchar, är en implicit konvertering, men trunkering sker om storleken på det stora värdet överskrider den angivna längden på den mindre datatypen.
• Konvertering från nvarchar, varbinary eller varchar till motsvarande datatyper med stort värde sker implicit.
• Konvertering från sql_variant datatyp till datatyper med stort värde är en explicit konvertering.
• Datatyper med stort värde kan inte konverteras till sql_variant datatyp.

För mer information om konvertering från xml-datatypen , se Skapa instanser av XML-data.

xml-datatyp

När du uttryckligen eller implicit omvandlar XML-datatypen till en sträng eller binär datatyp serialiseras innehållet i xml-datatypen baserat på en definierad uppsättning regler. För information om dessa regler, se Definiera serialiseringen av XML-data. För information om konvertering från andra datatyper till xml-datatypen, se Skapa instanser av XML-data.

text- och bilddatatyper

Text- och bilddatatyperna stöder inte automatisk datatypskonvertering. Du kan uttryckligen konvertera textdata till teckendata och bilddata till binära data eller varbinära, men den maximala längden är 8 000 byte. Om du försöker en felaktig konvertering, till exempel att konvertera ett teckenuttryck som inkluderar bokstäver till en int, returnerar Database Engine ett felmeddelande.

Utdatasortering

CAST När funktionerna eller CONVERT matar ut en teckensträng och de får en teckensträngsinmatning, har utdata samma sorterings- och sorteringsetikett som indata. Om indata inte är en teckensträng har utdata standardsortering av databasen och en sorteringsetikett med tvångsstandard. Mer information finns i sorteringsprioritet.

För att tilldela en annan sortering till utdatan, applicera klausulen COLLATE på resultatuttrycket av CAST eller-funktionen CONVERT . Till exempel:

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

Trunkera och avrunda resultat

När du konverterar tecken eller binära uttryck (binärt, tecken, nchar, nvarchar, varbinary eller varchar) till ett uttryck av en annan datatyp, kan konverteringsåtgärden trunkera utdata, endast delvis visa utdata eller returnera ett fel. Dessa fall uppstår om resultatet är för kort för att visas. Konverteringar till binärt, tecken, nchar, nvarchar, varbinary eller varchar trunkeras, förutom de konverteringar som visas i följande tabell.

¹ Fel returnerades eftersom resultatlängden är för kort för att visas.

Databasmotor för SQL Server garanterar att endast rundomvandlingar, det vill säga konverteringar som konverterar en datatyp från dess ursprungliga datatyp och tillbaka igen, ger samma värden från version till version. I följande exempel visas en sådan tur och retur-konvertering:

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

I följande exempel visas ett resulterande uttryck som är för litet för att visas.

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

Här är resultatet.

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

När du konverterar datatyper som skiljer sig åt i decimaler, returnerar Database Engine ibland ett trunkerat resultatvärde, och andra gånger ett avrundat värde. Den här tabellen visar beteendet.

¹ Konvertering av flyttalsvärden som använder vetenskaplig notation till decimal eller numerisk är begränsad till endast värden med precision 17 siffror. Alla värden med en precision som är högre än 17 avrundar till noll.

Till exempel kan värdena 10,6496 och -10,6496 trunkeras eller avrundas vid konvertering till int- eller numeriska typer:

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;

Resultatet av frågan visas i följande tabell:

När du konverterar datatyper där måldatatypen har färre decimaler än källdatatypen avrundas värdet. Den här konverteringen returnerar $10.3497till exempel :

SELECT CAST (10.3496847 AS MONEY);

Database Engine returnerar ett felmeddelande när icke-numeriska char-, nchar-, nvarchar- eller varchar-data konverteras till decimal, flytta,int, numerisk. Database Engine ger också ett fel när en tom sträng ( ) konverteras till numerisk eller decimal.

Vissa datetime-konverteringar är icke-terministiska

De format som sträng-till-datetime-konverteringen är nondeterministisk för är följande:

• Alla stilar under 100¹
• 106
• 107
• 109
• 113
• 130

¹ Med undantag för stilar 20 och 21

Mer information finns i icke-deterministisk konvertering av bokstavliga datumsträngar till DATE-värden.

Tilläggstecken (surrogatpar)

Från och med SQL Server 2012 (11.x), när du använder extra teckensortering (SC), trunkerar inte en CAST åtgärd från nchar eller nvarchar till en nchar - eller nvarchar-typ av mindre längd inuti ett surrogatpar. I stället trunkerar åtgärden före det kompletterande tecknet. Följande kodfragment lämnar @x till exempel bara ab. Det finns inte tillräckligt med utrymme för att lagra tilläggstecknet.

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

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

När du använder SC-sortering är beteendet CONVERTför , detsamma som för CAST. Mer information finns i Sortering och Unicode-stöd – tilläggstecken.

Stöd för kompatibilitet

I tidigare versioner av SQL Server är 121standardstilen för CAST och CONVERT operationer på tid- och datumtid2-datatyper , utom när någon av typerna används i ett beräknat kolumnuttryck. För beräknade kolumner är 0standardstilen . Detta beteende påverkar beräknade kolumner när de skapas, används i frågor som involverar autoparametrisering, eller används i begränsningsdefinitioner.

Under kompatibilitetsnivå110 och högre har 121 och CONVERT operationerna CAST på tid- och datumtid2-datatyperna alltid standardstil. Om en fråga förlitar sig på det gamla beteendet, använd en kompatibilitetsnivå mindre än 110, eller specificera 0 uttryckligen stilen i den berörda frågan.

¹ Förutom beräknade kolumner

Att uppgradera databasen till kompatibilitetsnivå 110 och högre ändrar inte användardata som har lagrats på disken. Du måste korrigera dessa data manuellt efter behov. Till exempel, om du skulle skapa SELECT INTO en tabell från en källa som innehåller ett beräknat kolumnuttryck som beskrivits ovan, skulle datan (med stil 0) lagras istället för själva den beräknade kolumndefinitionen. Du måste manuellt uppdatera denna data för att matcha stil.121

Exempel

Kodexemplen i denna artikel använder AdventureWorks2025, AdventureWorksDW2025, eller AdventureWorksLT2025 exempeldatabasen, som du kan ladda ner från Azure Data SQL Samples Repository GitHub-arkivet.

A. Använd både CAST och CONVERT

De här exemplen hämtar namnet på produkten för de produkter som har en 3 som den första siffran i listpriset och konverterar sina ListPrice värden till int.

Använd CAST:

USE AdventureWorks2025;
GO

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

Använd CONVERT:

USE AdventureWorks2025;
GO

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

Här är resultatet. Exempelresultatuppsättningen är densamma för både CAST och 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. Använda CAST med aritmetiska operatorer

Det här exemplet beräknar en enskild kolumnberäkning (Computed) genom att dividera den totala försäljningen hittills i år (SalesYTD) med provisionprocenten (CommissionPCT). Det här värdet avrundas till närmaste heltal och är sedan CAST till en int-datatyp .

USE AdventureWorks2025;
GO

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

Här är resultatet.

Computed
------
379753754
346698349
257144242
176493899
281101272
0
301872549
212623750
298948202
250784119
239246890
101664220
124511336
97688107

C. Använda CAST för att sammanfoga

Det här exemplet sammanfogar icke-teckenuttryck med hjälp CASTav . Den använder databasen AdventureWorksDW2025 .

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

Här är resultatet.

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. Använd CAST för att skapa mer läsbar text

Detta exempel använder CAST i SELECT listan för att konvertera kolumnen Name till en kolumn (char(10). Den använder databasen AdventureWorksDW2025 .

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

Här är resultatet.

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

E. Använda CAST med LIKE-satsen

I det här exemplet konverteras money kolumnvärdena SalesYTD till int för datatypen och sedan till datatypen char(20), så att LIKE satsen kan använda den.

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

Här är resultatet.

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

F. Använda KONVERTERA eller CAST med skrivet XML

Dessa exempel visar användningen av CONVERT för att konvertera data till typad XML, genom att använda xml-datatypen och kolumnerna (SQL Server).

I det här exemplet konverteras en sträng med tomt utrymme, text och markering till skrivet XML och tar bort allt obetydligt tomt utrymme (gränsens blanksteg mellan noder):

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

I det här exemplet konverteras en liknande sträng med blanksteg, text och markering till skrivet XML och bevarar ett obetydligt tomt utrymme (gränsens blanksteg mellan noder):

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

I det här exemplet omvandlas en sträng med blanksteg, text och markering till skrivet XML:

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

Se Create instances of XML data för fler exempel.

G. Använda CAST och CONVERT med datetime-data

Från och med GETDATE() värden visar det här exemplet aktuellt datum och tid, använder CAST för att ändra aktuellt datum och tid till en teckendatatyp och använder CONVERT sedan för att visa datum och tid i ISO 8601 formatet.

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

Här är resultatet.

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

Det här exemplet är ungefär motsatsen till föregående exempel. I det här exemplet visas ett datum och en tid som teckendata, används CAST för att ändra teckendata till datatypen datetime och använder CONVERT sedan för att ändra teckendata till datatypen 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

Här är resultatet.

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. Använda KONVERTERA med binära data och teckendata

De här exemplen visar resultatet av konvertering av binära data och teckendata med olika format.

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

Här är resultatet.

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

Detta exempel visar att Style 1 kan tvinga fram resultattrunkering. Tecknen 0x i resultatmängden tvingar fram trunkeringen.

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

Här är resultatet.

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

Detta exempel visar att Style 2 inte förkortar resultatet, eftersom resultatet inte inkluderar tecknen 0x.

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

Här är resultatet.

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

Konvertera teckenvärdet Name till ett binärt värde.

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

Här är resultatet.

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

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

Här är resultatet.

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

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

Här är resultatet.

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

Jag. Konvertera datatyper för datum och tid

Det här exemplet visar konverteringen av datatyperna datum, tid och 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];

Se till att värdena ligger inom ett kompatibelt intervall när du överväger en konvertering från datum till datetime eller datetime2. Det minsta årsvärdet för datetime är 1753, medan det minsta årsvärdet är 0001 för datum och 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. Använda KONVERTERA med datetime-data i olika format

Från och med GETDATE() värden används CONVERT det här exemplet för att visa alla datum- och tidsformat i avsnittet Datum- och tidsformat i den här artikeln.

K. Effekter av datatypsprioriteten i tillåtna konverteringar

I följande exempel definieras en variabel av typen varchar(10), ett heltalsvärde tilldelas variabeln och sedan en sammanlänkning av variabeln med en sträng.

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

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

Här är resultatet.

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

Int-värdet för 1 konverterades till ett varchar.

I det här exemplet visas en liknande fråga med hjälp av en int-variabel i stället:

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

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

I det här fallet utlöser -instruktionen SELECT följande fel:

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

För att utvärdera uttrycket @notastring + ' is not a string.'måste Database Engine följa reglerna för datatypsprioritet för att slutföra den implicita konverteringen innan resultatet av uttrycket kan beräknas. Eftersom int har högre prioritet än varchar försöker Database Engine konvertera strängen till ett heltal och misslyckas eftersom denna sträng inte kan konverteras till ett heltal.

Om vi tillhandahåller en sträng som kan konverteras lyckas satsen, som ses i följande exempel:

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

SELECT @notastring + '1';

I det här fallet kan strängen '1' konverteras till heltalsvärdet 1, så den här SELECT instruktionen returnerar värdet 2. När de angivna datatyperna är heltal blir operatorn + en additionsmatematisk operator, snarare än en strängsammansättning.

Exempel: Azure Synapse Analytics

L. Använda CAST och CONVERT

I det här exemplet hämtas namnet på produkten för de produkter som har en 3 i den första siffran i listpriset och konverterar ListPrice dessa produkter till int. Den använder databasen AdventureWorksDW2025 .

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

I det här exemplet visas samma fråga med i CONVERT stället för CAST. Den använder databasen AdventureWorksDW2025 .

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

M. Använda CAST med aritmetiska operatorer

Det här exemplet beräknar ett värde för en enskild kolumn genom att dividera produktenhetspriset (UnitPrice) med rabattprocenten (UnitPriceDiscountPct). Det här resultatet avrundas sedan till närmaste heltal och konverteras slutligen till en int-datatyp . I det AdventureWorksDW2025 här exemplet används databasen.

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

Här är resultatet.

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. Använda CAST med LIKE-satsen

Detta exempel konverterar penningkolumnenListPrice till en int-typ , och sedan till en char(20)- typ, så att klausulen LIKE kan använda den. I det AdventureWorksDW2025 här exemplet används databasen.

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

O. Använda CAST och CONVERT med datetime-data

I det här exemplet visas aktuellt datum och tid, används CAST för att ändra aktuellt datum och tid till en teckendatatyp och använder CONVERT slutligen visning av datum och tid i ISO 8601-format. I det AdventureWorksDW2025 här exemplet används databasen.

SELECT TOP (1) SYSDATETIME() AS UnconvertedDateTime,
               CAST (SYSDATETIME() AS NVARCHAR (30)) AS UsingCast,
               CONVERT (NVARCHAR (30), SYSDATETIME(), 126) AS UsingConvertTo_ISO8601
FROM dbo.DimCustomer;

Här är resultatet.

UnconvertedDateTime     UsingCast                     UsingConvertTo_ISO8601
---------------------   ---------------------------   ---------------------------
07/20/2010 1:44:31 PM   2010-07-20 13:44:31.5879025   2010-07-20T13:44:31.5879025

Det här exemplet är den grova motsatsen till föregående exempel. I det här exemplet visas ett datum och en tid som teckendata, används CAST för att ändra teckendata till datatypen datetime och använder CONVERT sedan för att ändra teckendata till datatypen datetime . I det AdventureWorksDW2025 här exemplet används databasen.

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;

Här är resultatet.

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

Relaterat innehåll

• FORMAT (Transact-SQL)
• STR (Transact-SQL)
• SELECT (Transact-SQL)
• Systemfunktioner efter kategori för Transact-SQL
• Stöd för sortering och Unicode
• Prioritet för datatyp (Transact-SQL)
• datatypkonvertering (databasmotor)
• Skriv internationella Transact-SQL-instruktioner