Använd TYPE_NAME() för att hämta namnet på en datatyp i SQL Server

I SQL Server kan du använda TYPE_NAME() funktion för att returnera namnet på en datatyp, baserat på dess ID. Detta kan vara användbart när du frågar efter en systemvy som sys.columns som returnerar typens ID men inte dess namn.

Du kan använda TYPE_NAME() för systemdatatyper och användardefinierade datatyper.

Exempel 1 – Grundläggande användning

Här är ett grundläggande exempel för att visa hur det fungerar.

SELECT TYPE_NAME(34) AS Result;

Resultat:

+----------+
| Result   |
|----------|
| image    |
+----------+

Detta resultat talar om för oss att typ-ID 34 används för bilden typ.

Exempel 2 – Ett mer användbart exempel

Här är ett mer användbart exempel.

USE Music;
SELECT 
  o.name AS [Object Name], 
  c.name AS [Column Name],  
  TYPE_NAME(c.user_type_id) AS [Type Name]  
FROM sys.objects AS o   
JOIN sys.columns AS c  ON o.object_id = c.object_id
WHERE o.type_desc = 'USER_TABLE';

Resultat:

+---------------+---------------+-------------+
| Object Name   | Column Name   | Type Name   |
|---------------+---------------+-------------|
| Artists       | ArtistId      | int         |
| Artists       | ArtistName    | nvarchar    |
| Artists       | ActiveFrom    | date        |
| Artists       | CountryId     | int         |
| Genres        | GenreId       | int         |
| Genres        | Genre         | nvarchar    |
| Albums        | AlbumId       | int         |
| Albums        | AlbumName     | nvarchar    |
| Albums        | ReleaseDate   | date        |
| Albums        | ArtistId      | int         |
| Albums        | GenreId       | int         |
| Country       | CountryId     | int         |
| Country       | CountryName   | nvarchar    |
+---------------+---------------+-------------+

Den här frågan returnerar användartabeller, tillsammans med deras kolumner och datatypen för varje kolumn.

Så här ser det ut om jag tar bort TYPE_NAME() :

USE Music;
SELECT 
  o.name AS [Object Name], 
  c.name AS [Column Name],  
  c.user_type_id 
FROM sys.objects AS o   
JOIN sys.columns AS c  ON o.object_id = c.object_id
WHERE o.type_desc = 'USER_TABLE';

Resultat:

+---------------+---------------+----------------+
| Object Name   | Column Name   | user_type_id   |
|---------------+---------------+----------------|
| Artists       | ArtistId      | 56             |
| Artists       | ArtistName    | 231            |
| Artists       | ActiveFrom    | 40             |
| Artists       | CountryId     | 56             |
| Genres        | GenreId       | 56             |
| Genres        | Genre         | 231            |
| Albums        | AlbumId       | 56             |
| Albums        | AlbumName     | 231            |
| Albums        | ReleaseDate   | 40             |
| Albums        | ArtistId      | 56             |
| Albums        | GenreId       | 56             |
| Country       | CountryId     | 56             |
| Country       | CountryName   | 231            |
+---------------+---------------+----------------+

Det är inte lika lätt att läsa typ-ID.

Exempel 3 – Användardefinierade typer

Användardefinierade typer ingår. Här är ett exempel som inkluderar ett användardefinierat typalias i resultaten.

USE Test;
SELECT 
  o.name AS [Object Name], 
  c.name AS [Column Name],  
  TYPE_NAME(c.user_type_id) AS [Type Name],
  CASE 
    WHEN t.is_user_defined = 1 THEN 'Yes'
    ELSE 'No' 
  END AS [User Defined?]
FROM sys.objects AS o   
JOIN sys.columns AS c  ON o.object_id = c.object_id
JOIN sys.types t ON c.user_type_id = t.user_type_id
WHERE o.type_desc = 'USER_TABLE'
AND o.name = 'Client';

Resultat:

+---------------+---------------+-------------+-----------------+
| Object Name   | Column Name   | Type Name   | User Defined?   |
|---------------+---------------+-------------+-----------------|
| Client        | ClientCode    | clientcode  | Yes             |
| Client        | FirstName     | varchar     | No              |
| Client        | LastName      | varchar     | No              |
+---------------+---------------+-------------+-----------------+

Exempel 4 – Använda TYPE_NAME() i en WHERE-sats

Du kan använda TYPE_NAME() (och alla andra systemfunktioner) i en WHERE klausul (och var som helst ett uttryck är tillåtet).

Här ändrar jag det föregående exemplet så att jag använder TYPE_NAME() i WHERE klausul.

USE Test;
SELECT 
  o.name AS [Object Name], 
  c.name AS [Column Name],  
  TYPE_NAME(c.user_type_id) AS [Type Name],
  CASE 
    WHEN t.is_user_defined = 1 THEN 'Yes'
    ELSE 'No' 
  END AS [User Defined?]
FROM sys.objects AS o   
JOIN sys.columns AS c  ON o.object_id = c.object_id
JOIN sys.types t ON c.user_type_id = t.user_type_id
WHERE TYPE_NAME(c.user_type_id) = 'clientcode';

Resultat:

+---------------+---------------+-------------+-----------------+
| Object Name   | Column Name   | Type Name   | User Defined?   |
|---------------+---------------+-------------+-----------------|
| Client        | ClientCode    | clientcode  | Yes             |
+---------------+---------------+-------------+-----------------+

Exempel 5 – Ogiltigt typ-ID eller otillräcklig behörighet

Om du anger ett ogiltigt typ-ID eller om du inte har tillräcklig behörighet för att referera till typen, blir resultatet NULL.

SELECT TYPE_NAME(258) AS Result;

Resultat:

+----------+
| Result   |
|----------|
| NULL     |
+----------+

Hämta typ-ID

Om du redan känner till datatypens namn, men du vill ha dess ID, kan du använda TYPE_ID() för att returnera ID:t för en datatyp baserat på dess namn.