Utilizzare TYPE_NAME() per ottenere il nome di un tipo di dati in SQL Server

In SQL Server puoi utilizzare TYPE_NAME() funzione per restituire il nome di un tipo di dati, in base al suo ID. Questo può essere utile quando si interroga una vista di sistema come sys.columns che restituisce l'ID del tipo ma non il suo nome.

Puoi usare TYPE_NAME() per i tipi di dati di sistema e i tipi di dati definiti dall'utente.

Esempio 1 – Utilizzo di base

Ecco un esempio di base per dimostrare come funziona.

SELECT TYPE_NAME(34) AS Result;

Risultato:

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

Questo risultato ci dice che l'ID del tipo 34 viene utilizzato per l'immagine digitare.

Esempio 2:un esempio più utile

Ecco un esempio più utile.

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

Risultato:

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

Questa query restituisce le tabelle utente, insieme alle relative colonne e al tipo di dati per ciascuna colonna.

Ecco come appare se rimuovo 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';

Risultato:

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

Non è così facile leggere l'ID del tipo.

Esempio 3 – Tipi definiti dall'utente

Sono inclusi i tipi definiti dall'utente. Ecco un esempio che include un alias di tipo definito dall'utente nei risultati.

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

Risultato:

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

Esempio 4 – Utilizzo di TYPE_NAME() in una clausola WHERE

Puoi usare TYPE_NAME() (e qualsiasi altra funzione di sistema) in un WHERE clausola (e ovunque sia consentita un'espressione).

Qui, modifico l'esempio precedente in modo da utilizzare TYPE_NAME() nel WHERE clausola.

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

Risultato:

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

Esempio 5:ID tipo non valido o autorizzazione insufficiente

Se fornisci un ID di tipo non valido o non disponi di autorizzazioni sufficienti per fare riferimento al tipo, il risultato sarà NULL.

SELECT TYPE_NAME(258) AS Result;

Risultato:

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

Ottieni l'ID del tipo

Se conosci già il nome del tipo di dati, ma desideri il suo ID, puoi utilizzare TYPE_ID() per restituire l'ID di un tipo di dati in base al suo nome.