NULL-complexiteit - Deel 4, Standaard unieke beperking ontbreekt

"Er wordt voldaan aan een unieke beperking op T als en alleen als er geen twee rijen R1 en R2 van T bestaan, zodat R1 en R2 dezelfde niet-NULL-waarden hebben in de unieke kolommen."

Een tabel T met een unieke beperking op col1 staat dus meerdere rijen toe met een NULL in col1, maar staat meerdere rijen met dezelfde niet-NULL-waarde in col1 niet toe.

Wat een beetje lastiger uit te leggen is, is wat er gebeurt volgens de standaard met een samengestelde unieke beperking. Stel dat u een unieke beperking hebt gedefinieerd voor (col1, col2). U kunt meerdere rijen hebben met (NULL, NULL), maar u kunt niet meerdere rijen hebben met (3, NULL), net zoals u niet meerdere rijen kunt hebben met (1, 100). Evenzo kunt u niet meerdere rijen hebben met (NULL, 300). Het punt is dat je niet meerdere rijen met dezelfde niet-NULL-waarden in de unieke kolommen mag hebben. Wat betreft een externe sleutel, u kunt een willekeurig aantal rijen in de verwijzingstabel hebben met NULL's in alle verwijzingskolommen, ongeacht wat er in de tabel waarnaar wordt verwezen, bestaat. Dergelijke rijen zijn niet gerelateerd aan rijen in de tabel waarnaar wordt verwezen (optionele relatie). Als u echter een niet-NULL-waarde in een van de verwijzende kolommen heeft, moet er een rij in de tabel waarnaar wordt verwezen met dezelfde niet-NULL-waarden in de kolommen waarnaar wordt verwezen.

Stel dat u een database hebt op een platform dat de standaard unieke beperking ondersteunt en dat u die database naar SQL Server moet migreren. U kunt problemen ondervinden met het afdwingen van unieke beperkingen in SQL Server als de unieke kolommen NULL's ondersteunen. Gegevens die in het bronsysteem als geldig werden beschouwd, kunnen in SQL Server als ongeldig worden beschouwd. In de volgende paragrafen zal ik een aantal mogelijke oplossingen in SQL Server onderzoeken.

Oplossing 1, met gefilterde index of geïndexeerde weergave

Een veelvoorkomende oplossing in T-SQL voor het afdwingen van de standaard unieke beperkingsfunctionaliteit wanneer er slechts één doelkolom is, is het gebruik van een unieke gefilterde index die alleen de rijen filtert waar de doelkolom niet NULL is. De volgende code verwijdert de bestaande unieke beperking van T3 en implementeert een dergelijke 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;

Aangezien de index alleen rijen filtert waarin col1 niet NULL is, wordt de eigenschap UNIQUE alleen afgedwongen op de niet-NULL col1-waarden.

Bedenk dat T3 al een rij heeft met een NULL in col1. Om deze oplossing te testen, gebruikt u de volgende code om een ​​tweede rij toe te voegen met een NULL in col1:

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

Deze code is succesvol uitgevoerd.

Bedenk dat T3 al een rij heeft met de waarde 1 in col1. Voer de volgende code uit om te proberen een tweede rij toe te voegen met 1 in col1:

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

Zoals verwacht mislukt deze poging met de volgende fout:

Gebruik de volgende code om T3 op te vragen:

SELECT * FROM dbo.T3;

Deze code genereert de volgende uitvoer met twee rijen met een NULL in col1:

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

Deze oplossing werkt goed wanneer u uniciteit op slechts één kolom moet afdwingen en wanneer u geen referentiële integriteit hoeft af te dwingen met een externe sleutel die naar die kolom verwijst.

Het probleem met de externe sleutel is dat SQL Server een primaire sleutel of een unieke beperking of een unieke niet-gefilterde index vereist die is gedefinieerd in de kolom waarnaar wordt verwezen. Het werkt niet als er alleen een unieke gefilterde index is gedefinieerd in de kolom waarnaar wordt verwezen. Laten we proberen een tabel te maken met een externe sleutel die verwijst naar T3.col1. Gebruik eerst de volgende code om de tabel T3 te maken:

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

Probeer vervolgens de volgende code uit te voeren in een poging een externe sleutel toe te voegen die wijst van T3FK.col1 naar T3.col1:

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

Deze poging mislukt met de volgende fout:

Msg 1750, niveau 16, staat 1
Kan geen beperking of index maken. Zie eerdere fouten.

Laat op dit punt de bestaande gefilterde index vallen voor opschoning:

DROP INDEX idx_col1_notnull ON dbo.T3;

Laat de tabel T3FK niet vallen, aangezien u deze in latere voorbeelden zult gebruiken.

Het andere probleem met de gefilterde indexoplossing, ervan uitgaande dat u geen externe sleutel nodig hebt, is dat het niet werkt wanneer u de standaard unieke beperkingsfunctionaliteit op meerdere kolommen moet afdwingen, bijvoorbeeld op de combinatie (col1, col2) . Houd er rekening mee dat de standaard unieke beperking dubbele niet-NULL-combinaties van waarden in de unieke kolommen niet toestaat. Als u deze logica wilt implementeren met een gefilterde index, hoeft u alleen rijen te filteren waarin een van de unieke kolommen niet NULL is. Anders gezegd, u hoeft alleen rijen te filteren die geen NULL's hebben in alle unieke kolommen. Helaas laten gefilterde indexen alleen zeer eenvoudige uitdrukkingen toe. Ze ondersteunen geen OR, NOT of manipulatie op de kolommen. Dus geen van de volgende indexdefinities wordt momenteel ondersteund:

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;

De tijdelijke oplossing in een dergelijk geval is om een ​​geïndexeerde weergave te maken op basis van een query die col1 en col2 van T3 retourneert met een van de WHERE-clausules hierboven, met een unieke geclusterde index op (col1, col2), zoals zo:

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

U mag meerdere rijen toevoegen met (NULL, NULL) in (col1, col2), maar u mag niet meerdere keren voorkomen van niet-NULL-combinaties van waarden in (col1, col2), zoals (3 , NULL) of (NULL, 300) of (1, 100). Toch ondersteunt deze oplossing geen externe sleutel.

Voer nu de volgende code uit om op te schonen:

DROP VIEW IF EXISTS dbo.T3CustomUnique;

Oplossing 2, met surrogaatsleutel en berekende kolom

De oplossingen met de gefilterde index en de geïndexeerde weergave zijn goed zolang u geen externe sleutel hoeft te ondersteunen. Maar wat als u referentiële integriteit wel moet afdwingen? Een optie is om de gefilterde index of geïndexeerde weergave-oplossing te blijven gebruiken om uniciteit af te dwingen, en triggers te gebruiken om referentiële integriteit af te dwingen. Deze optie is echter vrij duur.

Een andere optie is om een ​​geheel andere oplossing te gebruiken voor het uniciteitsgedeelte dat wel een externe sleutel ondersteunt. De oplossing omvat het toevoegen van twee kolommen aan de tabel waarnaar wordt verwezen (T3 in ons geval). Eén kolom met de naam id is een surrogaatsleutel met een identiteitseigenschap. Een andere kolom met de naam vlag is een persistente berekende kolom die id retourneert wanneer col1 NULL is en 0 wanneer het niet NULL is. Vervolgens dwingt u een unieke beperking af op de combinatie van col1 en vlag. Hier is de code om de twee kolommen en de unieke beperking toe te voegen:

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

Gebruik de volgende code om T3 op te vragen:

SELECT * FROM dbo.T3;

Deze code genereert de volgende uitvoer:

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

Wat betreft de referentietabel (T3FK in ons geval), voeg je een berekende kolom toe met de naam vlag die altijd is ingesteld op 0, en een externe sleutel gedefinieerd op (col1, vlag) die verwijst naar de unieke kolommen van T3 (col1, vlag), zoals zo :

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

Laten we deze oplossing testen.

Probeer de volgende rijen toe te voegen:

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

Deze rijen zijn toegevoegd, zoals het hoort, aangezien ze allemaal corresponderende rijen hebben waarnaar wordt verwezen.

Vraag de tabel T3FK:

SELECT * FROM dbo.T3FK;

U krijgt de volgende uitvoer:

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

Probeer een rij toe te voegen die geen overeenkomstige rij heeft in de tabel waarnaar wordt verwezen:

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

De poging wordt afgewezen, zoals het hoort, met de volgende fout:

Probeer een rij toe te voegen aan T3FK met een NULL in col1:

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

Deze rij wordt beschouwd als niet gerelateerd aan een rij in T3FK (optionele relatie) en zou volgens de standaard moeten worden toegestaan, ongeacht of er een NULL bestaat in de tabel waarnaar wordt verwezen in col1. T-SQL ondersteunt dit scenario en de rij is succesvol toegevoegd.

Vraag de tabel T3FK:

SELECT * FROM dbo.T3FK;

Deze code genereert de volgende uitvoer:

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

De oplossing werkt goed wanneer u de standaard uniciteitsfunctionaliteit op een enkele kolom moet afdwingen. Maar het heeft een probleem wanneer u uniciteit op meerdere kolommen moet afdwingen. Om het probleem te demonstreren, laat u eerst de tabellen T3 en T3FK vallen:

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

Gebruik de volgende code om T3 opnieuw te maken met een samengestelde unieke beperking op (col1, col2, vlag):

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

Merk op dat de vlag is ingesteld op id wanneer zowel col1 als col2 NULL zijn en anders 0.

De unieke beperking zelf werkt goed.

Voer de volgende code uit om een ​​paar rijen aan T3 toe te voegen, inclusief meerdere keren dat (NULL, NULL) in (col1, col2) voorkomt:

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

Deze rijen zijn toegevoegd zoals het hoort.

Probeer twee exemplaren van (1, NULL) toe te voegen in (col1, col2):

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

Deze poging mislukt zoals het hoort met de volgende fout:

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