Come creare un alias del tipo di dati definito dall'utente in SQL Server utilizzando T-SQL

Oltre ai numerosi tipi di dati disponibili in SQL Server, hai anche la possibilità di creare il tuo tipo di dati. Alcuni di questi sono indicati come "tipi di dati definiti dall'utente", mentre altri sono indicati come "tipi di dati alias".

Un tipo di dati definito dall'utente viene implementato tramite una classe di un assembly nel Common Language Runtime (CLR) di Microsoft.NET Framework.

Un tipo di dati alias è basato su un tipo di sistema nativo di SQL Server. In altre parole, utilizzi un tipo di dati esistente come base del tuo tipo di dati alias.

Detto questo, ho visto Microsoft usare il termine "alias del tipo di dati definito dall'utente" quando si fa riferimento a un tipo di dati alias. L'ho anche visto indicato semplicemente come un "alias del tipo di dati".

In ogni caso, questo articolo illustra come creare un alias del tipo di dati definito dall'utente usando Transact-SQL.

Esempio 1:creazione di un tipo di dati alias

Per creare un tipo di dati alias, esegui un CREATE TYPE istruzione sul database in cui si desidera creare il tipo di dati alias.

Ecco un esempio di codice che crea un alias del tipo di dati definito dall'utente basato su SQL Server varchar tipo di dati:

USE Test;

CREATE TYPE clientcode  
FROM varchar(8) NOT NULL;

Risultato:

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

In questo caso, creo un tipo di dati alias chiamato codice cliente in un database chiamato Test .

Il mio alias è basato su varchar(8) , il che significa che può essere una stringa di lunghezza variabile fino a 8 byte. Per i set di caratteri di codifica a byte singolo (come il latino), questo memorizzerà fino a 8 caratteri. Tuttavia, per i set di caratteri di codifica multibyte, il numero di caratteri potrebbe essere inferiore.

Esempio 2:visualizzazione del tipo di dati alias

Puoi usare sys.types per controllare i dettagli del tuo tipo di dati alias:

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

Risultato:

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

Possiamo vedere che è_user_defined il flag per questo tipo di dati è 1 , il che significa che è un tipo di dati definito dall'utente.

In questo esempio ho ristretto i risultati al solo clientcode tipo di dati. Puoi usare sys.types per restituire informazioni su tutti i tipi di dati nel database. Per ulteriori informazioni, vedere Come restituire un elenco di tipi di dati in SQL Server.

Ora che il tipo di dati alias è stato creato, possiamo procedere e utilizzarlo.

Esempio 3:creare una tabella che utilizza l'alias

In questo esempio creo una tabella che utilizza l'alias del tipo di dati appena creato in una delle sue definizioni di colonna.

USE Test;

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

Possiamo dare una rapida occhiata alle colonne della tabella:

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

Risultati:

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

Ci sono molte più colonne di dati, ma l'ho ristretto solo ad alcune che sono rilevanti per questo articolo.

Esempio 4 – Inserisci dati

Ora è il momento di inserire i dati nella colonna che utilizza il nostro alias del tipo di dati definito dall'utente.

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

E ora seleziona la riga:

SELECT * FROM Client;

Risultato:

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

Quindi possiamo vedere che il nostro tipo di dati alias ha accettato i dati come specificato.

Ma non sarebbe un test adeguato a meno che non provassimo a romperlo.

Proviamo a inserire un valore che non aderisce al nostro alias:

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

Risultato:

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

In questo caso ho provato a inserire un valore che richiederebbe 9 byte per essere archiviato, ma l'alias accetta solo valori fino a 8 byte, quindi lo ha rifiutato.

Se rimuovo uno dei caratteri, funziona bene:

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

SELECT * FROM Client;

Risultato:

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