Complessità NULL – Parte 4, Vincolo unico standard mancante

"Un vincolo univoco su T è soddisfatto se e solo se non esistono due righe R1 e R2 di T tali che R1 e R2 abbiano gli stessi valori non NULL nelle colonne univoche."

Quindi, una tabella T con un vincolo univoco su col1 consentirà più righe con NULL in col1, ma non consentirà più righe con lo stesso valore non NULL in col1.

Quello che è un po' più complicato da spiegare è cosa succede secondo lo standard con un vincolo unico composito. Supponiamo di avere un vincolo univoco definito su (col1, col2). Puoi avere più righe con (NULL, NULL), ma non puoi avere più righe con (3, NULL), proprio come non puoi avere più righe con (1, 100). Allo stesso modo, non puoi avere più righe con (NULL, 300). Il punto è che non puoi avere più righe con gli stessi valori non NULL nelle colonne univoche. Come per una chiave esterna, puoi avere un numero qualsiasi di righe nella tabella di riferimento con NULL in tutte le colonne di riferimento, indipendentemente da ciò che esiste nella tabella di riferimento. Tali righe non sono correlate ad alcuna riga nella tabella di riferimento (relazione facoltativa). Tuttavia, se hai un valore non NULL in una qualsiasi delle colonne di riferimento, deve esistere una riga nella tabella di riferimento con gli stessi valori non NULL nelle colonne di riferimento.

Si supponga di disporre di un database in una piattaforma che supporta il vincolo univoco standard e di dover migrare tale database a SQL Server. Potrebbero verificarsi problemi con l'applicazione di vincoli univoci in SQL Server se le colonne univoche supportano i valori NULL. I dati considerati validi nel sistema di origine possono essere considerati non validi in SQL Server. Nelle sezioni seguenti esplorerò una serie di possibili soluzioni alternative in SQL Server.

Soluzione 1, utilizzando l'indice filtrato o la vista indicizzata

Una soluzione alternativa comune in T-SQL per applicare la funzionalità di vincolo univoco standard quando è coinvolta solo una colonna di destinazione consiste nell'usare un indice filtrato univoco che filtra solo le righe in cui la colonna di destinazione non è NULL. Il codice seguente elimina il vincolo univoco esistente da T3 e implementa tale indice:

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

Poiché l'indice filtra solo le righe in cui col1 non è NULL, la relativa proprietà UNIQUE viene applicata solo ai valori col1 non NULL.

Ricordiamo che T3 ha già una riga con un NULL in col1. Per testare questa soluzione, usa il codice seguente per aggiungere una seconda riga con un NULL in col1:

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

Questo codice viene eseguito correttamente.

Ricordiamo che T3 ha già una riga con il valore 1 in col1. Esegui il codice seguente per tentare di aggiungere una seconda riga con 1 in col1:

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

Come previsto, questo tentativo non riesce con il seguente errore:

Utilizzare il codice seguente per interrogare T3:

SELECT * FROM dbo.T3;

Questo codice genera il seguente output che mostra due righe con un NULL in col1:

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

Questa soluzione funziona bene quando devi imporre l'univocità su una sola colonna e quando non è necessario imporre l'integrità referenziale con una chiave esterna che punta a quella colonna.

Il problema con la chiave esterna è che SQL Server richiede una chiave primaria o un vincolo univoco o un indice univoco non filtrato definito nella colonna a cui si fa riferimento. Non funziona quando c'è solo un indice filtrato univoco definito nella colonna di riferimento. Proviamo a creare una tabella con una chiave esterna che faccia riferimento a T3.col1. Innanzitutto, utilizza il codice seguente per creare la tabella 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
);

Quindi prova a eseguire il codice seguente nel tentativo di aggiungere una chiave esterna che punta da T3FK.col1 a T3.col1:

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

Questo tentativo non riesce con il seguente errore:

Msg 1750, livello 16, stato 1
Impossibile creare un vincolo o un indice. Vedi gli errori precedenti.

A questo punto, elimina l'indice filtrato esistente per la pulizia:

DROP INDEX idx_col1_notnull ON dbo.T3;

Non abbandonare la tabella T3FK, poiché la utilizzerai negli esempi successivi.

L'altro problema con la soluzione dell'indice filtrato, supponendo che non sia necessaria una chiave esterna, è che non funziona quando è necessario applicare la funzionalità di vincolo univoco standard su più colonne, ad esempio sulla combinazione (col1, col2) . Ricorda che il vincolo univoco standard non consente combinazioni di valori non NULL duplicate nelle colonne univoche. Per implementare questa logica con un indice filtrato, è necessario filtrare solo le righe in cui una qualsiasi delle colonne univoche non è NULL. Formulato in modo diverso, devi filtrare solo le righe che non hanno NULL in tutte le colonne univoche. Sfortunatamente, gli indici filtrati consentono solo espressioni molto semplici. Non supportano OR, NOT o manipolazione sulle colonne. Quindi nessuna delle seguenti definizioni di indice è attualmente supportata:

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 soluzione alternativa in questo caso è creare una vista indicizzata basata su una query che restituisce col1 e col2 da T3 con una delle clausole WHERE sopra, con un indice cluster univoco su (col1, col2), in questo modo:

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

Ti sarà consentito aggiungere più righe con (NULL, NULL) in (col1, col2), ma non ti sarà consentito aggiungere più occorrenze di combinazioni di valori non NULL in (col1, col2), ad esempio (3 , NULL) o (NULL, 300) o (1, 100). Tuttavia, questa soluzione non supporta una chiave esterna.

A questo punto, esegui il codice seguente per la pulizia:

DROP VIEW IF EXISTS dbo.T3CustomUnique;

Soluzione 2, utilizzando la chiave surrogata e la colonna calcolata

Le soluzioni con l'indice filtrato e la vista indicizzata sono buone purché non sia necessario supportare una chiave esterna. Ma cosa succede se è necessario rafforzare l'integrità referenziale? Un'opzione consiste nel continuare a utilizzare l'indice filtrato o la soluzione di visualizzazione indicizzata per imporre l'unicità e utilizzare i trigger per imporre l'integrità referenziale. Tuttavia, questa opzione è piuttosto costosa.

Un'altra opzione consiste nell'utilizzare una soluzione completamente diversa per la parte di unicità che supporta una chiave esterna. La soluzione prevede l'aggiunta di due colonne alla tabella di riferimento (T3 nel nostro caso). Una colonna denominata id è una chiave surrogata con una proprietà identity. Un'altra colonna denominata flag è una colonna calcolata persistente che restituisce id quando col1 è NULL e 0 quando non è NULL. Quindi imporre un vincolo univoco sulla combinazione di col1 e flag. Ecco il codice per aggiungere le due colonne e il vincolo univoco:

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

Utilizzare il codice seguente per interrogare T3:

SELECT * FROM dbo.T3;

Questo codice genera il seguente output:

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

Per quanto riguarda la tabella di riferimento (T3FK nel nostro caso), aggiungi una colonna calcolata chiamata flag che è sempre impostata su 0 e una chiave esterna definita su (col1, flag) che punta alle colonne univoche di T3 (col1, flag), in questo modo :

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

Proviamo questa soluzione.

Prova ad aggiungere le seguenti righe:

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

Queste righe vengono aggiunte correttamente, come dovrebbero, poiché tutte hanno righe di riferimento corrispondenti.

Interroga la tabella T3FK:

SELECT * FROM dbo.T3FK;

Ottieni il seguente output:

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

Prova ad aggiungere una riga che non ha una riga corrispondente nella tabella di riferimento:

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

Il tentativo viene rifiutato, come dovrebbe essere, con il seguente errore:

Prova ad aggiungere una riga a T3FK con un NULL in col1:

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

Questa riga è considerata non correlata a nessuna riga in T3FK (relazione facoltativa) e, secondo lo standard, dovrebbe essere consentita indipendentemente dal fatto che nella tabella di riferimento in col1 sia presente un NULL. T-SQL supporta questo scenario e la riga viene aggiunta correttamente.

Interroga la tabella T3FK:

SELECT * FROM dbo.T3FK;

Questo codice genera il seguente output:

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 soluzione funziona bene quando è necessario applicare la funzionalità di unicità standard su una singola colonna. Ma ha un problema quando è necessario imporre l'unicità su più colonne. Per dimostrare il problema, prima elimina le tabelle T3 e T3FK:

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

Usa il codice seguente per ricreare T3 con un vincolo univoco composito su (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)
);

Nota che il flag è impostato su id quando sia col1 che col2 sono NULL e 0 altrimenti.

Il vincolo unico stesso funziona bene.

Esegui il codice seguente per aggiungere alcune righe a T3, incluse più occorrenze di (NULL, NULL) in (col1, col2):

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

Queste righe vengono aggiunte correttamente come dovrebbero.

Prova ad aggiungere due occorrenze di (1, NULL) in (col1, col2):

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

Questo tentativo fallisce come dovrebbe con il seguente errore:

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