Vorrang der Datentypen in SQL Server

Nachfolgend finden Sie eine Liste mit den SQL Server-Datentypen in der Reihenfolge ihrer Priorität.

1. benutzerdefinierte Datentypen (höchste)
2. sql_variant
3. xml
4. datetimeoffset
5. datetime2
6. datetime
7. smalldatetime
8. date
9. time
10. float
11. real
12. decimal
13. money
14. smallmoney
15. bigint
16. int
17. smallint
18. tinyint
19. bit
20. ntext
21. text
22. image
23. timestamp
24. uniqueidentifier
25. nvarchar (einschließlich nvarchar(max) )
26. nchar
27. varchar (einschließlich varchar(max) )
28. char
29. varbinary (einschließlich varbinary(max) )
30. binary (niedrigste)

Wenn Sie Operanden verschiedener Datentypen mit einem Operator kombinieren, wird der Datentyp mit der niedrigeren Priorität zuerst in den Datentyp mit der höheren Priorität konvertiert.

Wenn die Konvertierung keine unterstützte implizite Konvertierung ist, wird ein Fehler zurückgegeben.

Wenn beide Operanden vom gleichen Typ sind, wird keine Konvertierung durchgeführt (oder benötigt) und das Ergebnis der Operation verwendet den Datentyp der Operanden.

Beispiel

Hier ist ein Beispiel für eine erfolgreiche implizite Konvertierung:

SELECT 1 * 1.00;

Ergebnis:

1.00

Dabei wurde der linke Operand in den Datentyp des rechten Operanden konvertiert.

Hier ist eine explizitere Methode:

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

Ergebnis:

1.00

In diesem Fall habe ich den linken Operanden explizit als INT deklariert und der rechte Operand als DECIMAL(5, 2) .

Wir können die Ergebnisse mit dem sys.dm_exec_describe_first_result_set weiter untersuchen systemdynamische Verwaltungsfunktion.

Diese Funktion ermöglicht es uns, den Datentyp jeder Spalte zu überprüfen, die in einer Abfrage zurückgegeben wird:

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);

Ergebnis:

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

Hier können wir sehen, dass jede Zeile jede von der Abfrage zurückgegebene Spalte darstellt. Daher war die erste Spalte ein INT , die zweite Spalte war DECIMAL(5,2) , und die dritte Spalte ein DECIMAL(16,2) .

Also gab SQL Server tatsächlich ein DECIMAL(16,2) zurück , obwohl der ursprüngliche Dezimalwert ein DECIMAL(5,2) war .

Beispiel für einen Konvertierungsfehler

Wie bereits erwähnt, wird ein Fehler zurückgegeben, wenn die Konvertierung keine unterstützte implizite Konvertierung ist:

SELECT 'Age: ' + 10;

Ergebnis:

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

In diesem Fall habe ich versucht, eine Zeichenfolge zu verketten (VARCHAR ) und eine Zahl (INT ). Als INT zu sehen hat eine höhere Priorität als VARCHAR , hat SQL Server versucht, die Zeichenfolge implizit in einen INT zu konvertieren .

Dies ist fehlgeschlagen, da diese Zeichenfolge nicht in eine Ganzzahl konvertiert werden kann.

Um dies zu umgehen, können wir zuerst den INT umwandeln zu VARCHAR :

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

Ergebnis:

Age: 10

Jetzt haben beide Operanden denselben Datentyp, und SQL Server führt die Operation erfolgreich aus, ohne dass implizite Konvertierungen durchgeführt werden müssen.

Eine andere Möglichkeit, diese spezielle Operation durchzuführen, ist mit CONCAT() Funktion:

SELECT CONCAT('Age: ', 10);

Ergebnis:

Age: 10

Der CONCAT() function ist eine String-Funktion und wandelt daher alle Argumente vor der Verkettung implizit in String-Typen um. Daher mussten wir keine explizite Konvertierung durchführen.

Wenn der String-Operand jedoch implizit in eine Zahl konvertiert werden kann, verursacht dies bei Verwendung von + keinen Fehler Betreiber:

SELECT '10' + 10;

Ergebnis:

20

Aber in diesem Fall das + -Operator wird zu einem mathematischen Additionsoperator und nicht zu einem String-Verkettungsoperator.