Como criar um alias de tipo de dados definido pelo usuário no SQL Server usando T-SQL

Além dos vários tipos de dados disponíveis no SQL Server, você também tem a opção de criar seu próprio tipo de dados. Alguns deles são chamados de “tipos de dados definidos pelo usuário”, enquanto outros são chamados de “tipos de dados de alias”.

Um tipo de dados definido pelo usuário é implementado por meio de uma classe de um assembly no CLR (Common Language Runtime) do Microsoft.NET Framework.

Um tipo de dados de alias é baseado em um tipo de sistema nativo do SQL Server. Em outras palavras, você usa um tipo de dados existente como base de seu tipo de dados de alias.

Dito isso, vi a Microsoft usar o termo “alias de tipo de dados definido pelo usuário” ao se referir a um tipo de dados de alias. Eu também o vi referido simplesmente como um “alias de tipo de dados”.

De qualquer forma, este artigo demonstra como criar um alias de tipo de dados definido pelo usuário usando o Transact-SQL.

Exemplo 1 – Criar um tipo de dados de alias

Para criar um tipo de dados de alias, execute um CREATE TYPE instrução em relação ao banco de dados que você deseja criar o tipo de dados de alias.

Aqui está um exemplo de código que cria um alias de tipo de dados definido pelo usuário com base no SQL Server varchar tipo de dados:

USE Test;

CREATE TYPE clientcode  
FROM varchar(8) NOT NULL;

Resultado:

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

Nesse caso, crio um tipo de dados de alias chamado clientcode em um banco de dados chamado Test .

Meu alias é baseado em varchar(8) , o que significa que pode ser uma string de comprimento variável de até 8 bytes de comprimento. Para conjuntos de caracteres de codificação de byte único (como latim), isso armazenará até 8 caracteres. No entanto, para conjuntos de caracteres de codificação de vários bytes, o número de caracteres pode ser menor.

Exemplo 2 – Visualizar o tipo de dados de alias

Você pode usar sys.types para verificar os detalhes do tipo de dados do seu 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 o is_user_defined sinalizador para este tipo de dados é 1 , o que significa que é um tipo de dados definido pelo usuário.

Neste exemplo, reduzi os resultados apenas ao clientcode tipo de dados. Você pode usar sys.types para retornar informações sobre todos os tipos de dados no banco de dados. Consulte Como retornar uma lista de tipos de dados no SQL Server para obter mais informações.

Agora que o tipo de dados de alias foi criado, podemos prosseguir e usá-lo.

Exemplo 3 – Criar uma tabela que usa o alias

Neste exemplo, crio uma tabela que usa meu alias de tipo de dados recém-criado em uma de suas definições de coluna.

USE Test;

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

Podemos dar uma olhada rápida nas colunas na tabela:

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

Existem muitas outras colunas de dados, mas reduzi apenas algumas que são relevantes para este artigo.

Exemplo 4 – Inserir dados

Agora é hora de inserir dados na coluna que usa nosso alias de tipo de dados definido pelo usuário.

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

E agora selecione a linha:

SELECT * FROM Client;

Resultado:

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

Assim, podemos ver que nosso tipo de dados de alias aceitou os dados conforme especificado.

Mas não seria um teste adequado, a menos que tentássemos quebrá-lo.

Vamos tentar inserir um valor que não adere ao nosso 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.

Nesse caso tentei inserir um valor que exigiria 9 bytes para ser armazenado, mas o alias só aceita valores de até 8 bytes, então o rejeitou.

Se eu remover um dos caracteres, funciona bem:

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

SELECT * FROM Client;

Resultado:

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