Use TYPE_NAME() para obtener el nombre de un tipo de datos en SQL Server

En SQL Server, puede usar TYPE_NAME() función para devolver el nombre de un tipo de datos, en función de su ID. Esto puede ser útil cuando se consulta una vista del sistema como sys.columns que devuelve el ID del tipo pero no su nombre.

Puedes usar TYPE_NAME() para tipos de datos del sistema y tipos de datos definidos por el usuario.

Ejemplo 1:uso básico

Aquí hay un ejemplo básico para demostrar cómo funciona.

SELECT TYPE_NAME(34) AS Result;

Resultado:

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

Este resultado nos dice que se usa el ID de tipo 34 para la imagen tipo.

Ejemplo 2:un ejemplo más útil

Aquí hay un ejemplo más útil.

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

Resultado:

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

Esta consulta devuelve tablas de usuario, junto con sus columnas y el tipo de datos de cada columna.

Esto es lo que parece si elimino 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';

Resultado:

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

No es tan fácil leer el ID de tipo.

Ejemplo 3:tipos definidos por el usuario

Se incluyen tipos definidos por el usuario. Este es un ejemplo que incluye un alias de tipo definido por el usuario en los resultados.

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

Resultado:

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

Ejemplo 4:uso de TYPE_NAME() en una cláusula WHERE

Puedes usar TYPE_NAME() (y cualquier otra función del sistema) en un WHERE cláusula (y en cualquier lugar donde se permita una expresión).

Aquí, modifico el ejemplo anterior para usar TYPE_NAME() en el WHERE cláusula.

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

Resultado:

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

Ejemplo 5:ID de tipo no válido o permiso insuficiente

Si proporciona un ID de tipo no válido o no tiene suficientes permisos para hacer referencia al tipo, el resultado será NULL.

SELECT TYPE_NAME(258) AS Result;

Resultado:

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

Obtenga la identificación del tipo

Si ya conoce el nombre del tipo de datos, pero quiere su ID, puede usar TYPE_ID() para devolver el ID de un tipo de datos basado en su nombre.