Comment créer un alias de type de données défini par l'utilisateur dans SQL Server à l'aide de T-SQL

Outre les nombreux types de données disponibles dans SQL Server, vous avez également la possibilité de créer votre propre type de données. Certains d'entre eux sont appelés "types de données définis par l'utilisateur", tandis que d'autres sont appelés "types de données d'alias".

Un type de données défini par l'utilisateur est implémenté via une classe d'assembly dans le Common Language Runtime (CLR) de Microsoft.NET Framework.

Un type de données d'alias est basé sur un type de système natif SQL Server. En d'autres termes, vous utilisez un type de données existant comme base de votre type de données d'alias.

Cela dit, j'ai vu Microsoft utiliser le terme "alias de type de données défini par l'utilisateur" pour faire référence à un type de données alias. Je l'ai également vu simplement appelé "alias de type de données".

Dans les deux cas, cet article montre comment créer un alias de type de données défini par l'utilisateur à l'aide de Transact-SQL.

Exemple 1 – Créer un type de données d'alias

Pour créer un type de données d'alias, exécutez un CREATE TYPE sur la base de données pour laquelle vous souhaitez créer le type de données alias.

Voici un exemple de code qui crée un alias de type de données défini par l'utilisateur basé sur le SQL Server varchar type de données :

USE Test;

CREATE TYPE clientcode  
FROM varchar(8) NOT NULL;

Résultat :

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

Dans ce cas, je crée un type de données alias appelé clientcode dans une base de données appelée Test .

Mon alias est basé sur varchar(8) , ce qui signifie qu'il peut s'agir d'une chaîne de longueur variable jusqu'à 8 octets. Pour les jeux de caractères codés sur un octet (tels que le latin), cela stockera jusqu'à 8 caractères. Cependant, pour les jeux de caractères d'encodage multi-octets, le nombre de caractères peut être inférieur.

Exemple 2 - Afficher le type de données d'alias

Vous pouvez utiliser sys.types pour vérifier les détails de votre type de données d'alias :

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

Résultat :

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

Nous pouvons voir que le is_user_defined l'indicateur pour ce type de données est 1 , ce qui signifie qu'il s'agit d'un type de données défini par l'utilisateur.

Dans cet exemple, j'ai réduit les résultats au seul code client Type de données. Vous pouvez utiliser sys.types pour renvoyer des informations sur tous les types de données de la base de données. Voir Comment renvoyer une liste de types de données dans SQL Server pour plus d'informations.

Maintenant que le type de données alias a été créé, nous pouvons continuer et l'utiliser.

Exemple 3 - Créer une table qui utilise l'alias

Dans cet exemple, je crée une table qui utilise mon alias de type de données nouvellement créé dans l'une de ses définitions de colonne.

USE Test;

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

Nous pouvons jeter un coup d'œil rapide aux colonnes du tableau :

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

Résultats :

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

Il existe de nombreuses autres colonnes de données, mais je les ai réduites à celles qui sont pertinentes pour cet article.

Exemple 4 - Insérer des données

Il est maintenant temps d'insérer des données dans la colonne qui utilise notre alias de type de données défini par l'utilisateur.

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

Et maintenant sélectionnez la ligne :

SELECT * FROM Client;

Résultat :

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

Nous pouvons donc voir que notre type de données d'alias a accepté les données comme spécifié.

Mais ce ne serait pas un bon test si nous n'essayions pas de le casser.

Essayons d'insérer une valeur qui n'adhère pas à notre alias :

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

Résultat :

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

Dans ce cas, j'ai essayé d'insérer une valeur qui nécessiterait 9 octets pour être stockée, mais l'alias n'accepte que des valeurs jusqu'à 8 octets, il l'a donc rejetée.

Si j'enlève un des caractères, ça marche bien :

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

SELECT * FROM Client;

Résultat :

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