Cómo crear un alias de tipo de datos definido por el usuario en SQL Server usando T-SQL

Además de los muchos tipos de datos disponibles en SQL Server, también tiene la opción de crear su propio tipo de datos. Algunos de estos se denominan "tipos de datos definidos por el usuario", mientras que otros se denominan "tipos de datos de alias".

Un tipo de datos definido por el usuario se implementa a través de una clase de ensamblado en Microsoft.NET Framework common language runtime (CLR).

Un tipo de datos de alias se basa en un tipo de sistema nativo de SQL Server. En otras palabras, utiliza un tipo de datos existente como base para su tipo de datos de alias.

Habiendo dicho eso, he visto a Microsoft usar el término "alias de tipo de datos definido por el usuario" cuando se refiere a un tipo de datos de alias. También lo he visto referido simplemente como un "alias de tipo de datos".

De cualquier manera, este artículo muestra cómo crear un alias de tipo de datos definido por el usuario mediante Transact-SQL.

Ejemplo 1:crear un tipo de datos de alias

Para crear un tipo de datos de alias, ejecute CREATE TYPE declaración contra la base de datos que desea crear el tipo de datos de alias.

Aquí hay un ejemplo de código que crea un alias de tipo de datos definido por el usuario basado en SQL Server varchar tipo de datos:

USE Test;

CREATE TYPE clientcode  
FROM varchar(8) NOT NULL;

Resultado:

Commands completed successfully.
Total execution time: 00:00:00.028

En este caso, creo un tipo de datos de alias llamado clientcode en una base de datos llamada Test .

Mi alias se basa en varchar(8) , lo que significa que puede ser una cadena de longitud variable de hasta 8 bytes de longitud. Para conjuntos de caracteres de codificación de un solo byte (como el latín), esto almacenará hasta 8 caracteres. Sin embargo, para conjuntos de caracteres de codificación multibyte, la cantidad de caracteres puede ser menor.

Ejemplo 2:ver el tipo de datos de alias

Puede usar sys.types para verificar los detalles de su tipo de datos de alias:

SELECT * FROM sys.types
WHERE name = 'clientcode';

Resultado:

name              | clientcode
system_type_id    | 167
user_type_id      | 257
schema_id         | 1
principal_id      | NULL
max_length        | 8
precision         | 0
scale             | 0
collation_name    | SQL_Latin1_General_CP1_CI_AS
is_nullable       | 0
is_user_defined   | 1
is_assembly_type  | 0
default_object_id | 0
rule_object_id    | 0
is_table_type     | 0

Podemos ver que is_user_defined el indicador para este tipo de datos es 1 , lo que significa que es un tipo de datos definido por el usuario.

En este ejemplo, reduje los resultados a solo el clientcode tipo de datos. Puede usar sys.types para devolver información sobre todos los tipos de datos en la base de datos. Consulte Cómo devolver una lista de tipos de datos en SQL Server para obtener más información.

Ahora que se ha creado el tipo de datos de alias, podemos continuar y usarlo.

Ejemplo 3:crear una tabla que use el alias

En este ejemplo, creo una tabla que usa mi alias de tipo de datos recién creado en una de sus definiciones de columna.

USE Test;

CREATE TABLE Client
(
    ClientCode clientcode PRIMARY KEY,
    FirstName varchar(50),
    LastName varchar(50)
);

Podemos echar un vistazo rápido a las columnas de la tabla:

SELECT 
  c.name,  
  c.system_type_id,
  c.user_type_id,
  c.max_length,
  c.is_nullable
FROM sys.columns c
INNER JOIN sys.tables t
ON t.object_id = c.object_id
WHERE t.name = 'Client';

Resultados:

+------------+------------------+----------------+--------------+---------------+
| name       | system_type_id   | user_type_id   | max_length   | is_nullable   |
|------------+------------------+----------------+--------------+---------------|
| ClientCode | 167              | 257            | 8            | 0             |
| FirstName  | 167              | 167            | 50           | 1             |
| LastName   | 167              | 167            | 50           | 1             |
+------------+------------------+----------------+--------------+---------------+

Hay muchas más columnas de datos, pero las he reducido a solo algunas que son relevantes para este artículo.

Ejemplo 4:Insertar datos

Ahora es el momento de insertar datos en la columna que usa nuestro alias de tipo de datos definido por el usuario.

INSERT INTO Client
VALUES ('aaa00001', 'Satoshi', 'Nakamoto');

Y ahora seleccione la fila:

SELECT * FROM Client;

Resultado:

+--------------+-------------+------------+
| ClientCode   | FirstName   | LastName   |
|--------------+-------------+------------|
| aaa00001     | Satoshi     | Nakamoto   |
+--------------+-------------+------------+

Entonces podemos ver que nuestro tipo de datos de alias ha aceptado los datos como se especifica.

Pero no sería una prueba adecuada a menos que intentáramos romperla.

Intentemos insertar un valor que no se adhiera a nuestro alias:

INSERT INTO Client
VALUES ('aaaa00002', 'Mikko', 'Linnamäki');

Resultado:

Msg 8152, Level 16, State 30, Line 1
String or binary data would be truncated.

En este caso, traté de insertar un valor que requeriría 9 bytes para almacenar, pero el alias solo acepta valores de hasta 8 bytes, por lo que lo rechazó.

Si elimino uno de los caracteres, funciona bien:

INSERT INTO Client
VALUES ('aaa00002', 'Mikko', 'Linnamäki');

SELECT * FROM Client;

Resultado:

+--------------+-------------+------------+
| ClientCode   | FirstName   | LastName   |
|--------------+-------------+------------|
| aaa00001     | Satoshi     | Nakamoto   |
| aaa00002     | Mikko       | Linnamäki  |
+--------------+-------------+------------+