Gebruik TYPE_NAME() om de naam van een gegevenstype in SQL Server op te halen

In SQL Server kunt u de TYPE_NAME() . gebruiken functie om de naam van een gegevenstype te retourneren, op basis van zijn ID. Dit kan handig zijn bij het opvragen van een systeemweergave zoals sys.columns die de ID van het type retourneert, maar niet de naam.

U kunt TYPE_NAME() . gebruiken voor systeemgegevenstypen en door de gebruiker gedefinieerde gegevenstypen.

Voorbeeld 1 – Basisgebruik

Hier is een eenvoudig voorbeeld om te laten zien hoe het werkt.

SELECT TYPE_NAME(34) AS Result;

Resultaat:

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

Dit resultaat vertelt ons dat het type ID van 34 wordt gebruikt voor de afbeelding typ.

Voorbeeld 2 – Een nuttiger voorbeeld

Hier is een nuttiger voorbeeld.

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

Resultaat:

+---------------+---------------+-------------+
| 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    |
+---------------+---------------+-------------+

Deze query retourneert gebruikerstabellen, samen met hun kolommen en het gegevenstype voor elke kolom.

Zo ziet het eruit als ik TYPE_NAME() verwijder :

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

Resultaat:

+---------------+---------------+----------------+
| 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            |
+---------------+---------------+----------------+

Het is niet zo eenvoudig om de type-ID te lezen.

Voorbeeld 3 – Door de gebruiker gedefinieerde typen

Door de gebruiker gedefinieerde typen zijn inbegrepen. Hier is een voorbeeld dat een door de gebruiker gedefinieerd type alias in de resultaten bevat.

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

Resultaat:

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

Voorbeeld 4 – TYPE_NAME() gebruiken in een WHERE-clausule

U kunt TYPE_NAME() . gebruiken (en elke andere systeemfunctie) in een WHERE clausule (en overal waar een uitdrukking is toegestaan).

Hier pas ik het vorige voorbeeld aan zodat ik TYPE_NAME() . gebruik in de WHERE clausule.

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

Resultaat:

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

Voorbeeld 5 – Ongeldige type-ID of onvoldoende toestemming

Als u een ongeldig type-ID opgeeft of als u niet voldoende rechten heeft om naar het type te verwijzen, is het resultaat NULL.

SELECT TYPE_NAME(258) AS Result;

Resultaat:

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

De type-ID ophalen

Als u de naam van het gegevenstype al weet, maar u wilt de ID ervan, kunt u TYPE_ID() gebruiken om de ID van een gegevenstype te retourneren op basis van de naam.