Complexités NULL – Partie 4, Contrainte d'unicité standard manquante

La définition de contrainte unique standard est un peu différente de la version T-SQL. La principale différence concerne la gestion de NULL. Voici la définition de contrainte unique de la norme :

"Une contrainte d'unicité sur T est satisfaite si et seulement s'il n'existe pas deux lignes R1 et R2 de T telles que R1 et R2 aient les mêmes valeurs non NULL dans les colonnes uniques."

Ainsi, une table T avec une contrainte unique sur col1 autorisera plusieurs lignes avec un NULL dans col1, mais interdira plusieurs lignes avec la même valeur non NULL dans col1.

Ce qui est un peu plus délicat à expliquer, c'est ce qui se passe selon la norme avec une contrainte d'unicité composite. Disons que vous avez une contrainte unique définie sur (col1, col2). Vous pouvez avoir plusieurs lignes avec (NULL, NULL), mais vous ne pouvez pas avoir plusieurs lignes avec (3, NULL), tout comme vous ne pouvez pas avoir plusieurs lignes avec (1, 100). De même, vous ne pouvez pas avoir plusieurs lignes avec (NULL, 300). Le fait est que vous n'êtes pas autorisé à avoir plusieurs lignes avec les mêmes valeurs non NULL dans les colonnes uniques. Comme pour une clé étrangère, vous pouvez avoir n'importe quel nombre de lignes dans la table de référence avec des valeurs NULL dans toutes les colonnes de référence, indépendamment de ce qui existe dans la table référencée. Ces lignes ne sont liées à aucune ligne de la table référencée (relation facultative). Cependant, si vous avez une valeur non NULL dans l'une des colonnes de référence, il doit exister une ligne dans la table référencée avec les mêmes valeurs non NULL dans les colonnes référencées.

Supposons que vous disposiez d'une base de données sur une plate-forme prenant en charge la contrainte d'unicité standard et que vous deviez migrer cette base de données vers SQL Server. Vous pouvez rencontrer des problèmes avec l'application de contraintes uniques dans SQL Server si les colonnes uniques prennent en charge les valeurs NULL. Les données considérées comme valides dans le système source peuvent être considérées comme non valides dans SQL Server. Dans les sections suivantes, j'explorerai un certain nombre de solutions de contournement possibles dans SQL Server.

Solution 1, en utilisant un index filtré ou une vue indexée

Une solution de contournement courante dans T-SQL pour appliquer la fonctionnalité de contrainte unique standard lorsqu'une seule colonne cible est impliquée consiste à utiliser un index filtré unique qui filtre uniquement les lignes où la colonne cible n'est pas NULL. Le code suivant supprime la contrainte d'unicité existante de T3 et implémente un tel index :

ALTER TABLE dbo.T3 DROP CONSTRAINT UNQ_T3;
 
CREATE UNIQUE NONCLUSTERED INDEX idx_col1_notnull ON dbo.T3(col1) WHERE col1 IS NOT NULL;

Étant donné que l'index ne filtre que les lignes où col1 n'est pas NULL, sa propriété UNIQUE n'est appliquée que sur les valeurs col1 non NULL.

Rappelez-vous que T3 a déjà une ligne avec un NULL dans col1. Pour tester cette solution, utilisez le code suivant pour ajouter une deuxième ligne avec un NULL dans col1 :

INSERT INTO dbo.T3(col1, col2) VALUES(NULL, 400);

Ce code s'exécute avec succès.

Rappelez-vous que T3 a déjà une ligne avec la valeur 1 dans col1. Exécutez le code suivant pour tenter d'ajouter une deuxième ligne avec 1 dans col1 :

INSERT INTO dbo.T3(col1, col2) VALUES(1, 500);

Comme prévu, cette tentative échoue avec l'erreur suivante :

Utilisez le code suivant pour interroger T3 :

SELECT * FROM dbo.T3;

Ce code génère la sortie suivante montrant deux lignes avec un NULL dans col1 :

col1        col2
----------- -----------
1           100
2           -1
NULL        -1
3           300
NULL        400

Cette solution fonctionne bien lorsque vous devez appliquer l'unicité sur une seule colonne et lorsque vous n'avez pas besoin d'appliquer l'intégrité référentielle avec une clé étrangère pointant vers cette colonne.

Le problème avec la clé étrangère est que SQL Server requiert une clé primaire ou une contrainte unique ou un index non filtré unique défini sur la colonne référencée. Cela ne fonctionne pas lorsqu'il n'y a qu'un index filtré unique défini sur la colonne référencée. Essayons de créer une table avec une clé étrangère référençant T3.col1. Tout d'abord, utilisez le code suivant pour créer la table T3 :

DROP TABLE IF EXISTS dbo.T3FK;
GO
 
CREATE TABLE dbo.T3FK
(
  id INT NOT NULL IDENTITY CONSTRAINT PK_T3FK PRIMARY KEY,
  col1 INT NULL, 
  col2 INT NULL, 
  othercol VARCHAR(10) NOT NULL
);

Essayez ensuite d'exécuter le code suivant pour tenter d'ajouter une clé étrangère pointant de T3FK.col1 vers T3.col1 :

ALTER TABLE dbo.T3FK ADD CONSTRAINT FK_T3_T3FK
  FOREIGN KEY(col1) REFERENCES dbo.T3(col1);

Cette tentative échoue avec l'erreur suivante :

Msg 1750, Niveau 16, État 1
Impossible de créer une contrainte ou un index. Voir les erreurs précédentes.

À ce stade, supprimez l'index filtré existant pour le nettoyage :

DROP INDEX idx_col1_notnull ON dbo.T3;

Ne supprimez pas la table T3FK, car vous l'utiliserez dans des exemples ultérieurs.

L'autre problème avec la solution d'index filtré, en supposant que vous n'avez pas besoin d'une clé étrangère, est que cela ne fonctionne pas lorsque vous devez appliquer la fonctionnalité de contrainte unique standard sur plusieurs colonnes, par exemple sur la combinaison (col1, col2) . N'oubliez pas que la contrainte d'unicité standard interdit les combinaisons de valeurs non nulles en double dans les colonnes uniques. Pour implémenter cette logique avec un index filtré, vous devez filtrer uniquement les lignes où l'une des colonnes uniques n'est pas NULL. En d'autres termes, vous devez filtrer uniquement les lignes qui n'ont pas de NULL dans toutes les colonnes uniques. Malheureusement, les index filtrés n'autorisent que des expressions très simples. Ils ne prennent pas en charge OR, NOT ou la manipulation sur les colonnes. Ainsi, aucune des définitions d'index suivantes n'est actuellement prise en charge :

CREATE UNIQUE NONCLUSTERED INDEX idx_customunique ON dbo.T3(col1, col2)
  WHERE col1 IS NOT NULL OR col2 IS NOT NULL;
 
CREATE UNIQUE NONCLUSTERED INDEX idx_customunique ON dbo.T3(col1, col2)
  WHERE NOT (col1 IS NULL AND col2 IS NULL);
 
CREATE UNIQUE NONCLUSTERED INDEX idx_customunique ON dbo.T3(col1, col2)
  WHERE COALESCE(col1, col2) IS NOT NULL;

La solution de contournement dans un tel cas consiste à créer une vue indexée basée sur une requête qui renvoie col1 et col2 à partir de T3 avec l'une des clauses WHERE ci-dessus, avec un index clusterisé unique sur (col1, col2), comme ceci :

CREATE VIEW dbo.T3CustomUnique WITH SCHEMABINDING
AS
  SELECT col1, col2 FROM dbo.T3 WHERE col1 IS NOT NULL OR col2 IS NOT NULL;
GO
 
CREATE UNIQUE CLUSTERED INDEX idx_col1_col2 ON dbo.T3CustomUnique(col1, col2);
GO

Vous serez autorisé à ajouter plusieurs lignes avec (NULL, NULL) dans (col1, col2), mais vous ne serez pas autorisé à ajouter plusieurs occurrences de combinaisons de valeurs non NULL dans (col1, col2), telles que (3 , NULL) ou (NULL, 300) ou (1, 100). Pourtant, cette solution ne prend pas en charge une clé étrangère.

À ce stade, exécutez le code suivant pour le nettoyage :

DROP VIEW IF EXISTS dbo.T3CustomUnique;

Solution 2, utilisant une clé de substitution et une colonne calculée

Les solutions avec l'index filtré et la vue indexée sont bonnes tant que vous n'avez pas besoin de prendre en charge une clé étrangère. Mais que se passe-t-il si vous avez besoin d'appliquer l'intégrité référentielle ? Une option consiste à continuer à utiliser la solution d'index filtré ou de vue indexée pour appliquer l'unicité et à utiliser des déclencheurs pour appliquer l'intégrité référentielle. Cependant, cette option est assez chère.

Une autre option consiste à utiliser une solution complètement différente pour la partie d'unicité qui prend en charge une clé étrangère. La solution consiste à ajouter deux colonnes à la table référencée (T3 dans notre cas). Une colonne appelée id est une clé de substitution avec une propriété d'identité. Une autre colonne appelée flag est une colonne calculée persistante qui renvoie id lorsque col1 est NULL et 0 lorsqu'il n'est pas NULL. Vous appliquez ensuite une contrainte unique sur la combinaison de col1 et flag. Voici le code pour ajouter les deux colonnes et la contrainte unique :

ALTER TABLE dbo.T3
  ADD id INT NOT NULL IDENTITY,
      flag AS CASE WHEN col1 IS NULL THEN id ELSE 0 END PERSISTED,
      CONSTRAINT UNQ_T3_col1_flag UNIQUE(col1, flag);

Utilisez le code suivant pour interroger T3 :

SELECT * FROM dbo.T3;

Ce code génère la sortie suivante :

col1        col2        id          flag
----------- ----------- ----------- -----------
1           100         1           0
2           -1          2           0
NULL        -1          3           3
3           300         4           0
NULL        400         5           5

En ce qui concerne la table de référence (T3FK dans notre cas), vous ajoutez une colonne calculée appelée flag qui est toujours définie sur 0, et une clé étrangère définie sur (col1, flag) pointant vers les colonnes uniques de T3 (col1, flag), comme ceci :

ALTER TABLE dbo.T3FK
  ADD flag AS 0 PERSISTED,
      CONSTRAINT FK_T3_T3FK
        FOREIGN KEY(col1, flag) REFERENCES dbo.T3(col1, flag);

Testons cette solution.

Essayez d'ajouter les lignes suivantes :

INSERT INTO dbo.T3FK(col1, col2, othercol) VALUES
  (1, 100, 'A'),
  (2, -1, 'B'),
  (3, 300, 'C');

Ces lignes sont ajoutées avec succès, comme il se doit, car toutes ont des lignes référencées correspondantes.

Interroger la table T3FK :

SELECT * FROM dbo.T3FK;

Vous obtenez le résultat suivant :

id          col1        col2        othercol   flag
----------- ----------- ----------- ---------- -----------
1           1           100         A          0
2           2           -1          B          0
3           3           300         C          0

Essayez d'ajouter une ligne qui n'a pas de ligne correspondante dans la table référencée :

INSERT INTO dbo.T3FK(col1, col2, othercol) VALUES
  (4, 400, 'D');

La tentative est rejetée, comme il se doit, avec l'erreur suivante :

Essayez d'ajouter une ligne à T3FK avec un NULL dans col1 :

INSERT INTO dbo.T3FK(col1, col2, othercol) VALUES
  (NULL, NULL, 'E');

Cette ligne est considérée comme n'étant liée à aucune ligne dans T3FK (relation facultative) et, selon la norme, doit être autorisée, qu'un NULL existe ou non dans la table référencée dans col1. T-SQL prend en charge ce scénario et la ligne est ajoutée avec succès.

Interroger la table T3FK :

SELECT * FROM dbo.T3FK;

Ce code génère la sortie suivante :

id          col1        col2        othercol   flag
----------- ----------- ----------- ---------- -----------
1           1           100         A          0
2           2           -1          B          0
3           3           300         C          0
5           NULL        NULL        E          0

La solution fonctionne bien lorsque vous devez appliquer la fonctionnalité d'unicité standard sur une seule colonne. Mais cela pose un problème lorsque vous devez imposer l'unicité sur plusieurs colonnes. Pour illustrer le problème, supprimez d'abord les tables T3 et T3FK :

DROP TABLE IF EXISTS dbo.T3FK, dbo.T3;

Utilisez le code suivant pour recréer T3 avec une contrainte unique composite sur (col1, col2, flag) :

CREATE TABLE dbo.T3
(
  col1 INT NULL,
  col2 INT NULL,
  id INT NOT NULL IDENTITY,
  flag AS CASE WHEN col1 IS NULL AND col2 IS NULL THEN id ELSE 0 END PERSISTED,
  CONSTRAINT UNQ_T3 UNIQUE(col1, col2, flag)
);

Notez que l'indicateur est défini sur id lorsque col1 et col2 sont NULL et 0 sinon.

La contrainte unique elle-même fonctionne bien.

Exécutez le code suivant pour ajouter quelques lignes à T3, y compris plusieurs occurrences de (NULL, NULL) dans (col1, col2) :

INSERT INTO dbo.T3(col1, col2) VALUES(1, 100),(1, 200),(NULL, NULL),(NULL, NULL);

Ces lignes sont ajoutées avec succès comme il se doit.

Essayez d'ajouter deux occurrences de (1, NULL) dans (col1, col2) :

INSERT INTO dbo.T3(col1, col2) VALUES(1, NULL),(1, NULL);

Cette tentative échoue comme il se doit avec l'erreur suivante :

INSERT INTO dbo.T3(col1, col2) VALUES(NULL, 100),(NULL, 100);

INSERT INTO dbo.T3(col1, col2) VALUES(3, NULL),(NULL, 300);

SELECT * FROM dbo.T3;

col1        col2        id          flag
----------- ----------- ----------- -----------
1           100         1           0
1           200         2           0
NULL        NULL        3           3
NULL        NULL        4           4
3           NULL        9           0
NULL        300         10          0

CREATE TABLE dbo.T3FK
(
  id INT NOT NULL IDENTITY CONSTRAINT PK_T3FK PRIMARY KEY,
  col1 INT NULL, 
  col2 INT NULL, 
  othercol VARCHAR(10) NOT NULL,
  flag AS 0 PERSISTED,
  CONSTRAINT FK_T3_T3FK
    FOREIGN KEY(col1, col2, flag) REFERENCES dbo.T3(col1, col2, flag)
);

INSERT INTO dbo.T3FK(col1, col2, othercol) VALUES(5, NULL, 'A');

DROP TABLE IF EXISTS dbo.T3FK, dbo.T3;

CREATE TABLE dbo.T3
(
  col1 INT NULL,
  col2 INT NULL,
  id INT NOT NULL IDENTITY,
  unqpath AS CASE WHEN col1 IS NULL AND col2 IS NULL THEN CAST(id AS VARCHAR(10)) 
                  ELSE CONCAT(CAST(col1 AS VARCHAR(11)), '.', CAST(col2 AS VARCHAR(11)))
             END PERSISTED,
  CONSTRAINT UNQ_T3 UNIQUE(unqpath)
);

INSERT INTO dbo.T3(col1, col2) VALUES(1, 100),(1, 200),(NULL, NULL),(NULL, NULL);

INSERT INTO dbo.T3(col1, col2) VALUES(1, NULL),(1, NULL);

INSERT INTO dbo.T3(col1, col2) VALUES(NULL, 100),(NULL, 100);

INSERT INTO dbo.T3(col1, col2) VALUES(3, NULL),(NULL, 300);

SELECT * FROM dbo.T3;

col1        col2        id          unqpath
----------- ----------- ----------- -----------------------
1           100         1           1.100
1           200         2           1.200
NULL        NULL        3           3
NULL        NULL        4           4
3           NULL        9           3.
NULL        300         10          .300

CREATE TABLE dbo.T3FK
(
  id INT NOT NULL IDENTITY CONSTRAINT PK_T3FK PRIMARY KEY,
  col1 INT NULL, 
  col2 INT NULL, 
  othercol VARCHAR(10) NOT NULL,
  unqpath AS CASE WHEN col1 IS NULL AND col2 IS NULL THEN NULL
                  ELSE CONCAT(CAST(col1 AS VARCHAR(11)), '.', CAST(col2 AS VARCHAR(11)))
             END PERSISTED,
  CONSTRAINT FK_T3_T3FK
    FOREIGN KEY(unqpath) REFERENCES dbo.T3(unqpath)
);

INSERT INTO dbo.T3FK(col1, col2, othercol) VALUES(5, NULL, 'A');

INSERT INTO dbo.T3FK(col1, col2, othercol) VALUES
  (1   , 100 , 'A'),
  (1   , 200 , 'B'),
  (3   , NULL, 'C'),
  (NULL, 300 , 'D'),
  (NULL, NULL, 'E'),
  (NULL, NULL, 'F');

SELECT * FROM dbo.T3FK;

id          col1        col2        othercol   unqpath
----------- ----------- ----------- ---------- -----------------------
2           1           100         A          1.100
3           1           200         B          1.200
4           3           NULL        C          3.
5           NULL        300         D          .300
6           NULL        NULL        E          NULL
7           NULL        NULL        F          NULL