Anteckning
Åtkomst till den här sidan kräver auktorisering. Du kan prova att logga in eller ändra kataloger.
Åtkomst till den här sidan kräver auktorisering. Du kan prova att ändra kataloger.
gäller för:
SQL ServerAzure SQL DatabaseAzure SQL Managed InstanceAzure Synapse AnalyticsAnalytics Platform System (PDW)SQL-analysslutpunkt i Microsoft FabricWarehouse 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 anger hur CONVERT funktionen ska översätta uttryck. För ett formatvärde av NULL returneras NULL.
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 de enda formatmallar som stöds när du konverterar från datum- och tidstyper till datetimeoffset 0 eller 1. Alla andra konverteringsformat returnerar fel 9809.
Anmärkning
SQL Server stöder datumformatet, i arabiskt format, med kuwaitisk algoritm.
| Utan århundrade (yyy) 1 | Med århundradet (yyyyy) | Norm | Indata/utdata 3 |
|---|---|---|---|
| - | 0 eller 1001,2 | Standard för datetime och smalldatetime |
mon dd yyyy hh:miAM (eller PM) |
| 1 | 101 | USA | 1 = mm/dd/yy101 = mm/dd/yyyy |
| 2 | 102 | ANSI (American National Standards Institute) | 2 = yy.mm.dd102 = yyyy.mm.dd |
| 3 | 103 | Brittiska/franska | 3 = dd/mm/yy103 = dd/mm/yyyy |
| 4 | 104 | Tyska | 4 = dd.mm.yy104 = dd.mm.yyyy |
| 5 | 105 | Italienska | 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 eller 24 | 108 | - | hh:mi:ss |
| - | 9 eller 1091,2 | Standard + millisekunder |
mon dd yyyy hh:mi:ss:mmmAM (eller PM) |
| 10 | 110 | USA | 10 = mm-dd-yyy 110 = mm-dd-yyyy |
| 11 | 111 | JAPAN | 11 = åå/mm/dd 111 = yyyy/mm/dd |
| 12 | 112 | ISO | 12 = yymmdd 112 = yyyymmdd |
| - | 13 eller 1131,2 | Standardvärde för Europa + millisekunder |
dd mon yyyy hh:mi:ss:mmm (24-timmars) |
| 14 | 114 | - |
hh:mi:ss:mmm (24-timmars) |
| - | 20 eller 1202 | ODBC kanonisk |
yyyy-mm-dd hh:mi:ss (24-timmars) |
| - | 21 eller 25 eller 1212 | ODBC kanonisk (med millisekunder) standard för tid, datum, datetime2 och datetimeoffset |
yyyy-mm-dd hh:mi:ss.mmm (24-timmars) |
| 22 | - | USA |
mm/dd/yy hh:mi:ss AM (eller PM) |
| - | 23 | ISO8601 | yyyy-mm-dd |
| - | 1264 | ISO8601 |
yyyy-mm-ddThh:mi:ss.mmm (inga blanksteg) 6 |
| - | 1278, 9 | ISO8601 med tidszon Z |
yyyy-MM-ddThh:mm:ss.fffZ (inga blanksteg) 6 |
| - | 1301,2 | Hijri 5 |
dd mon yyyy hh:mi:ss:mmmAM
7 |
| - | 1312 | Hijri 5 | dd/mm/yyyy hh:mi:ss:mmmAM |
1 Dessa formatvärden returnerar icke-terministiska resultat. Innehåller alla () (yyutan århundrade) stilar och en delmängd av (yyyy) (med århundradet) stilar.
2 Standardvärdena (0 eller 100, 9 eller 109, 13 eller 113, 20 eller 120, 23 och 21 eller 25 eller 121) returnerar alltid århundradet (yyyy).
Viktigt!
Som standard tolkar SQL Server tvåsiffriga år baserat på ett brytår 2049. Det innebär att SQL Server tolkar det tvåsiffriga året 49 som 2049 och det tvåsiffriga året 50 som 1950. Många klientprogram, inklusive de som baseras på Automation-objekt, använder ett brytår 2030. SQL Server tillhandahåller det tvåsiffriga konfigurationsalternativet för årsavstängning för att ändra det brytår som används av SQL Server. Detta möjliggör konsekvent behandling av datum. Vi rekommenderar att du anger fyrasiffriga år.
3 Indata när du konverterar till datetime; utdata när du konverterar till teckendata.
4 Utformad för XML-användning. För konvertering från datetime eller smalldatetime till teckendata, se föregående tabell för utdataformatet.
5 Hijri är ett kalendersystem med flera varianter. SQL Server använder kuwaitisk algoritm.
6 För ett millisekundersvärde (mmm) 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.
7 I det här formatet mon 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.
8 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.
9 Använd den valfria tidszonsindikatorn Z för att göra det enklare att mappa XML-datetime-värden som har tidszonsinformation till SQL Server datetime-värden som inte har någon 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.
| Värde | Utgång |
|---|---|
| 0 (standard) | Högst 6 siffror. Använd i vetenskaplig notation, när det är lämpligt. |
| 1 | Alltid 8 siffror. Använd alltid i vetenskaplig notation. |
| 2 | Alltid 16 siffror. Använd alltid i vetenskaplig notation. |
| 3 | Alltid 17 siffror. Använd för förlustfri konvertering. Med det här formatet kommer varje distinkt flyttal eller verkligt värde garanterat att konverteras till en distinkt teckensträng. Gäller för: SQL Server 2016 (13.x) och senare versioner och Azure SQL Database. |
| 126, 128, 129 | Ingår av äldre skäl. Använd inte dessa värden för ny utveckling. |
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.
| Värde | Utgång |
|---|---|
| 0 (standard) | Inga kommatecken var tredje siffra till vänster om decimaltecknet och två siffror till höger om decimaltecknet Exempel: 4235.98. |
| 1 | Kommatecken var tredje siffra till vänster om decimaltecknet och två siffror till höger om decimaltecknet Exempel: 3 510,92. |
| 2 | Inga kommatecken var tredje siffra till vänster om decimaltecknet och fyra siffror till höger om decimaltecknet Exempel: 4235.9819. |
| 126 | Motsvarar format 2 när du konverterar till char(n) eller varchar(n) |
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.
| Värde | Utgång |
|---|---|
| 0 (standard) | Använd standardbeteendet för parsning som tar bort obetydligt tomt utrymme och som inte tillåter en intern DTD-delmängd. Not: När du konverterar till xml-datatypen hanteras SQL Server obetydligt tomt utrymme på ett annat sätt än i XML 1.0. Mer information finns i Skapa instanser av XML-data. |
| 1 | Bevara obetydligt tomt utrymme. Den här formatinställningen anger standardhanteringen xml:space så att den matchar beteendet xml:space="preserve"för . |
| 2 | Aktivera begränsad intern DTD-delmängdsbearbetning. Om den är aktiverad kan servern använda följande information som tillhandahålls i en intern DTD-delmängd för att utföra icke-validerande parsningsåtgärder. – Standardvärden för attribut tillämpas – Interna entitetsreferenser matchas och expanderas – DTD-innehållsmodellen kontrolleras för syntaktisk korrekthet Parsern ignorerar externa DTD-underuppsättningar. Dessutom utvärderas inte XML-deklarationen för att se om det fristående attributet har ett ja - eller nej-värde . I stället parsar den XML-instansen som ett fristående dokument. |
| 3 | Bevara obetydligt tomt utrymme och aktivera begränsad intern DTD-delmängdsbearbetning. |
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. Formatvärden som inte visas i tabellen returnerar ett fel.
| Värde | Utgång |
|---|---|
| 0 (standard) | Översätter ASCII-tecken till binära byte eller binära byte till ASCII-tecken. Varje tecken eller byte konverteras 1:1. För en binär data_type läggs tecknen 0x till vänster om resultatet. |
| 1, 2 | För en binär data_type måste uttrycket vara ett teckenuttryck.
Uttrycket måste ha ett jämnt antal hexadecimala siffror (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F, a, b, c, d, e, f). Om formatet är inställt på 1 måste uttrycket ha 0x som de två första tecknen. Om uttrycket innehåller ett udda antal tecken, eller om något av tecknen är ogiltigt, utlöses ett fel. Om längden på det konverterade uttrycket överskrider längden på data_type trunkeras resultatet. Fast längd data_typeär större än det konverterade resultatet har nollor lagts till till höger om resultatet. Ett data_type av typtecken kräver ett binärt uttryck. Varje binärt tecken konverteras till två hexadecimala tecken. Anta att längden på det konverterade uttrycket överskrider längden på data_type. I så fall trunkeras den. För en teckentyp med fast storlek data_type, om längden på det konverterade resultatet är mindre än längden på data_type, läggs blanksteg till höger om det konverterade uttrycket för att upprätthålla ett jämnt antal hexadecimala siffror. Tecknen 0x läggs inte till till vänster om det konverterade resultatet för format 2. |
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 bild visar alla explicita och implicita datatypkonverteringar som tillåts för datatyper som tillhandahålls av SQL Server-systemet. Dessa inkluderar bigint, sql_variant och xml. Det finns ingen implicit konvertering för tilldelning från sql_variant datatyp, men det finns implicit konvertering till sql_variant.
Tips/Råd
Microsoft Download Center har det här diagrammet tillgängligt för nedladdning som en PNG-fil.
Diagrammet ovan visar alla explicita och implicita konverteringar som tillåts i SQL Server, men den resulterande datatypen för konverteringen beror på vilken åtgärd 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.
Tips/Råd
Ett praktiskt exempel på effekterna av datatypsprioriteten i konverteringar kan visas senare i det här avsnittet.
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.
Eftersom Unicode-data alltid använder ett jämnt antal byte bör du vara försiktig när du konverterar binära eller varbinära till eller från datatyper som stöds av Unicode. Följande konvertering returnerar till exempel inte ett hexadecimalt värde på 41. Det returnerar ett hexadecimalt värde på 4100:
SELECT CAST(CAST(0x41 AS nvarchar) AS varbinary);
Mer information finns i Collation och Unicode Support.
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.
Mer information om konvertering från xml-datatypen finns i 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. Information om dessa regler finns i Definiera serialisering av XML-data. Information om konvertering från andra datatyper till XML-datatypen finns i 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 provar en felaktig konvertering, till exempel om du försöker konvertera ett teckenuttryck som innehåller bokstäver till en int, returnerar SQL Server 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 Sorteringspriorence (Transact-SQL).
Om du vill tilldela utdata en annan sortering använder du COLLATE-satsen för resultatuttrycket för CAST funktionen eller 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 inträffar 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.
| Från datatyp | Till datatyp | Resultat |
|---|---|---|
| int, smallint eller tinyint |
tecken Varchar |
För kort för att visas |
|
nchar nvarchar |
Fel 1 | |
| pengar, smallmoney, numeriska, decimaler, flyttal eller verkliga |
tecken Varchar |
Fel 1 |
|
nchar nvarchar |
Fel 1 |
1 Fel returnerades eftersom resultatlängden är för kort för att visas.
SQL Server garanterar att endast tur och retur-konverteringar, med andra ord konverteringar som konverterar en datatyp från den ursprungliga datatypen 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 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
Varning
Konstruera inte binära värden och konvertera dem sedan till en datatyp för kategorin numerisk datatyp. SQL Server garanterar inte att resultatet av en decimal - eller numerisk datatypkonvertering, till binär, blir detsamma mellan versioner av SQL Server.
I följande exempel visas ett resulterande uttryck som är för litet för att visas.
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
Här är resultatet.
FirstName LastName Title Sick Leave
--------- ------------- ------- --------`
Ken Sanchez NULL *
Terri Duffy NULL *
Roberto Tamburello NULL *
Rob Walters NULL *
Gail Erickson Ms. *
(5 row(s) affected)
När du konverterar datatyper som skiljer sig åt i decimaler returnerar SQL Server ibland ett trunkerat resultatvärde, och vid andra tillfällen returneras ett avrundat värde. Den här tabellen visar beteendet.
| Från | Till | Beteende |
|---|---|---|
| numerisk | numerisk | Rund |
| numerisk | Int | Förkorta |
| numerisk | pengar | Rund |
| pengar | Int | Rund |
| pengar | numerisk | Rund |
| sväva | Int | Förkorta |
| sväva | numerisk | Avrunda 1 |
| sväva | datetime | Rund |
| datetime | Int | Rund |
1 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 under konverteringen 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:
| trunc1 | trunc2 | round1 | round2 |
|---|---|---|---|
| 10 | -10 | 11 | -11 |
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);
SQL Server returnerar ett felmeddelande när icke-numeriskt tecken, nchar, nvarchar eller varchar-data konverteras till decimal-, float-, int-, numeriska. SQL Server returnerar också ett fel när en tom sträng (" ") konverteras till numerisk ellerdecimal.
Vissa datetime-konverteringar är icke-terministiska
De format som sträng-till-datetime-konverteringen är nondeterministisk för är följande:
- Alla format under 100 1
- 106
- 107
- 109
- 113
- 130
1 Med undantag för formatmallarna 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 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 standardformatet för CAST och CONVERT åtgärder i tid och datetime2 datatyper 121, förutom när någon av typerna används i ett beräknat kolumnuttryck. För beräknade kolumner är standardformatet 0. Det här beteendet påverkar beräknade kolumner när de skapas, används i frågor som involverar automatisk parameterisering eller används i villkorsdefinitioner.
Under kompatibilitetsnivå 110 och senare har datatyperna CAST och CONVERT för tid och datetime2 alltid 121 som standardformat. Om en fråga förlitar sig på det gamla beteendet använder du en kompatibilitetsnivå som är mindre än 110 eller anger uttryckligen formatet 0 i den berörda frågan.
| Kompatibilitetsnivåvärde | Standardformat för CAST och CONVERT1 |
Standardformat för beräknad kolumn |
|---|---|---|
| < 110 | 121 | 0 |
| > = 110 | 121 | 121 |
1 Förutom beräknade kolumner
Om du uppgraderar databasen till kompatibilitetsnivå 110 och senare ändras inte användardata som har lagrats på disken. Du måste korrigera dessa data manuellt efter behov. Om du till exempel använde SELECT INTO för att skapa en tabell från en källa som innehåller ett beräknat kolumnuttryck som beskrivs ovan, lagras data (med format 0) i stället för själva den beräknade kolumndefinitionen. Du måste uppdatera dessa data manuellt för att matcha format 121.
Exempel
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 AdventureWorks2022;
GO
SELECT SUBSTRING(Name, 1, 30) AS ProductName,
ListPrice
FROM Production.Product
WHERE CAST(ListPrice AS INT) LIKE '33%';
GO
Använd CONVERT:
USE AdventureWorks2022;
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
(28 rows affected)
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 AdventureWorks2022;
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
(14 row(s) affected)
C. Använda CAST för att sammanfoga
Det här exemplet sammanfogar icke-teckenuttryck med hjälp CASTav . Den använder databasen AdventureWorksDW2022 .
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
Det här exemplet används CAST i SELECT-listan för att konvertera Name kolumnen till en teckenkolumn (10). Den använder databasen AdventureWorksDW2022 .
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 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
Här är resultatet.
FirstName LastName SalesYTD BusinessEntityID
---------------- ------------------- ---------------- -------------
Tsvi Reiter 2811012.7151 279
Syed Abbas 219088.8836 288
Rachel Valdez 2241204.0424 289
(3 row(s) affected)
F. Använda KONVERTERA eller CAST med skrivet XML
De här exemplen visar användning av CONVERT för att konvertera data till skrivet XML med hjälp av 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)
Fler exempel finns i Skapa instanser av XML-data .
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
(1 row(s) affected)
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
(1 row(s) affected)
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
(1 row(s) affected)
Det här exemplet visar att format 1 kan tvinga fram resultattrunkering. Tecknen 0x i resultatuppsättningen tvingar truncationen.
SELECT CONVERT(CHAR(8), 0x4E616d65, 1) AS [Style 1, binary to character];
Här är resultatet.
Style 1, binary to character
------------------------------
0x4E616D
(1 row(s) affected)
Det här exemplet visar att format 2 inte trunkerar resultatet eftersom resultatet inte innehåller tecknen 0x.
SELECT CONVERT(CHAR(8), 0x4E616d65, 2) AS [Style 2, binary to character];
Här är resultatet.
Style 2, binary to character
------------------------------
4E616D65
(1 row(s) affected)
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
(1 row(s) affected)
SELECT CONVERT(BINARY(4), '0x4E616D65', 1) AS [Style 1, character to binary];
Här är resultatet.
Style 1, character to binary
----------------------------
0x4E616D65
(1 row(s) affected)
SELECT CONVERT(BINARY(4), '4E616D65', 2) AS [Style 2, character to binary];
Här är resultatet.
Style 2, character to binary
----------------------------------
0x4E616D65
(1 row(s) affected)
Jag. Konvertera datatyper för datum och tid
Det här exemplet visar konverteringen av datatyperna datum, tid och 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];
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 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. 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.
| Format # | Exempelfråga | Exempelresultat |
|---|---|---|
| 0 | SELECT CONVERT(NVARCHAR, GETDATE(), 0) |
23 aug 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 aug 19 |
| 7 | SELECT CONVERT(NVARCHAR, GETDATE(), 7) |
23 aug, 19 |
| 8 eller 24 eller 108 | SELECT CONVERT(NVARCHAR, GETDATE(), 8) |
13:39:17 |
| 9 eller 109 | SELECT CONVERT(NVARCHAR, GETDATE(), 9) |
23 aug 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 eller 113 | SELECT CONVERT(NVARCHAR, GETDATE(), 13) |
23 aug 2019 13:39:17:090 |
| 14 eller 114 | SELECT CONVERT(NVARCHAR, GETDATE(), 14) |
13:39:17:090 |
| 20 eller 120 | SELECT CONVERT(NVARCHAR, GETDATE(), 20) |
2019-08-23 13:39:17 |
| 21 eller 25 eller 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 aug 2019 |
| 107 | SELECT CONVERT(NVARCHAR, GETDATE(), 107) |
23 aug 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 aug 2019 13:39:17.090 |
| 120 | SELECT CONVERT(NVARCHAR, GETDATE(), 120) |
2019-08-23 13:39:17 |
| 121 | SELECT CONVERT(NVARCHAR, GETDATE(), 121) |
2019-08-23 13:39:17.090 |
| 126 | SELECT CONVERT(NVARCHAR, GETDATE(), 126) |
2019-08-23T13:39:17.090 |
| 127 | SELECT CONVERT(NVARCHAR, GETDATE(), 127) |
2019-08-23T13:39:17.090 |
| 130 | SELECT CONVERT(NVARCHAR, GETDATE(), 130) |
22 ذو الحجة 1440 1:39:17.090P |
| 131 | SELECT CONVERT(NVARCHAR, GETDATE(), 131) |
22/12/1440 13:39:17.090PM |
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 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 INT;
SET @notastring = '1';
SELECT @notastring + ' is not a string.' AS Result
I det här fallet utlöser SELECT-instruktionen 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 kunna utvärdera uttrycket @notastring + ' is not a string.'måste SQL Server 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 SQL Server konvertera strängen till ett heltal och misslyckas eftersom den här strängen inte kan konverteras till ett heltal.
Om vi anger en sträng som kan konverteras lyckas -instruktionen enligt följande exempel:
DECLARE @notastring 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 + matematisk additionsoperator i stället för en strängsammanfogning.
Exempel: Azure Synapse Analytics and Analytics Platform System (PDW)
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 AdventureWorksDW2022 .
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 AdventureWorksDW2022 .
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 AdventureWorksDW2022 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
I det här exemplet konverteras kolumnenListPrice money till en int-typ och sedan till en teckentyp (20), så att LIKE-satsen kan använda den. I det AdventureWorksDW2022 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 AdventureWorksDW2022 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 AdventureWorksDW2022 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
Se även
- FORMAT (Transact-SQL)
- STR (Transact-SQL)
- SELECT (Transact-SQL)
- System Functions (Transact-SQL)
- Sortering och Unicode-stöd