Datatypepræference i SQL Server

Nedenfor er en liste, der indeholder SQL Server-datatyperne i rækkefølge.

brugerdefinerede datatyper (højest)
sql_variant
xml
datetimeoffset
datetime2
datetime
smalldatetime
date
time
float
real
decimal
money
smallmoney
bigint
int
smallint
tinyint
bit
ntext
text
image
timestamp
uniqueidentifier
nvarchar (inklusive nvarchar(max) )
nchar
varchar (inklusive varchar(max) )
char
varbinary (inklusive varbinary(max) )
binary (laveste)

Når du bruger en operator til at kombinere operander af forskellige datatyper, konverteres datatypen med den lavere prioritet først til datatypen med den højere prioritet.

Hvis konverteringen ikke er en understøttet implicit konvertering, returneres en fejl.

Hvis begge operander er af samme type, udføres (eller er ikke nødvendig) nogen konvertering, og resultatet af operationen bruger operandernes datatype.

Eksempel

Her er et eksempel på en implicit konvertering, der lykkes:

SELECT 1 * 1.00;

Resultat:

1.00

Her blev venstre operand konverteret til datatypen for højre operand.

Her er en mere eksplicit måde at gøre det på:

DECLARE 
    @n1 INT, 
    @n2 DECIMAL(5, 2);
SET @n1 = 1;
SET @n2 = 1;
SELECT @n1 * @n2;

Resultat:

1.00

I dette tilfælde erklærede jeg eksplicit den venstre operand som en INT og den højre operand som DECIMAL(5, 2) .

Vi kan undersøge resultaterne yderligere med sys.dm_exec_describe_first_result_set system dynamisk styringsfunktion.

Denne funktion gør det muligt for os at kontrollere datatypen for hver kolonne, der returneres i en forespørgsel:

SELECT 
    system_type_name,
    max_length,
    [precision],
    scale
FROM sys.dm_exec_describe_first_result_set(
    'DECLARE @n1 INT, @n2 DECIMAL(5, 2);
SET @n1 = 1;
SET @n2 = 1;
SELECT @n1, @n2, @n1 * @n2;', 
    null, 
    0);

Resultat:

+--------------------+--------------+-------------+---------+
| system_type_name   | max_length   | precision   | scale   |
|--------------------+--------------+-------------+---------|
| int                | 4            | 10          | 0       |
| decimal(5,2)       | 5            | 5           | 2       |
| decimal(16,2)      | 9            | 16          | 2       |
+--------------------+--------------+-------------+---------+

Her kan vi se, at hver række repræsenterer hver kolonne, der returneres af forespørgslen. Derfor var den første kolonne en INT , den anden kolonne var DECIMAL(5,2) , og den tredje kolonne a DECIMAL(16,2) .

Så SQL Server returnerede faktisk en DECIMAL(16,2) , selvom den oprindelige decimalværdi var en DECIMAL(5,2) .

Eksempel på en konverteringsfejl

Som nævnt, hvis konverteringen ikke er en understøttet implicit konvertering, returneres en fejl:

SELECT 'Age: ' + 10;

Resultat:

Msg 245, Level 16, State 1, Line 1
Conversion failed when converting the varchar value 'Age: ' to data type int.

I dette tilfælde forsøgte jeg at sammenkæde en streng (VARCHAR ) og et tal (INT ). Ses som INT har en højere prioritet end VARCHAR , forsøgte SQL Server implicit at konvertere strengen til en INT .

Dette mislykkedes, fordi denne streng ikke kan konverteres til et heltal.

For at overvinde dette kan vi først konvertere INT til VARCHAR :

SELECT 'Age: ' + CAST(10 AS VARCHAR(2));

Resultat:

Age: 10

Nu har begge operander den samme datatype, og så udfører SQL Server operationen med succes uden at skulle udføre implicitte konverteringer.

En anden måde at udføre denne særlige handling på er med CONCAT() funktion:

SELECT CONCAT('Age: ', 10);

Resultat:

Age: 10

CONCAT() funktion er en strengfunktion og konverterer derfor implicit alle argumenter til strengtyper før sammenkædning. Derfor var det ikke nødvendigt for os at udføre en eksplicit konvertering.

Men hvis strengoperanden implicit kan konverteres til et tal, vil det ikke forårsage en fejl, når du bruger + operatør:

SELECT '10' + 10;

Resultat:

Men i dette tilfælde er + operator bliver til en matematisk additionsoperator i stedet for en strengsammenkædningsoperator.