NULL-Komplexitäten – Teil 4, Fehlende eindeutige Standardbeschränkung

„Eine Eindeutigkeitsbedingung für T ist genau dann erfüllt, wenn es keine zwei Zeilen R1 und R2 von T gibt, sodass R1 und R2 dieselben Nicht-NULL-Werte in den eindeutigen Spalten haben.“

Eine Tabelle T mit einer eindeutigen Einschränkung für Spalte1 lässt also mehrere Zeilen mit einem NULL-Wert in Spalte1 zu, verbietet jedoch mehrere Zeilen mit demselben Nicht-NULL-Wert in Spalte1.

Was etwas schwieriger zu erklären ist, ist, was gemäß dem Standard mit einer zusammengesetzten eindeutigen Beschränkung passiert. Angenommen, Sie haben eine eindeutige Einschränkung für (Spalte1, Spalte2) definiert. Sie können mehrere Zeilen mit (NULL, NULL) haben, aber Sie können nicht mehrere Zeilen mit (3, NULL) haben, genau wie Sie nicht mehrere Zeilen mit (1, 100) haben können. Ebenso können Sie mit (NULL, 300) nicht mehrere Zeilen haben. Der Punkt ist, dass Sie nicht mehrere Zeilen mit denselben Nicht-NULL-Werten in den eindeutigen Spalten haben dürfen. Wie bei einem Fremdschlüssel können Sie eine beliebige Anzahl von Zeilen in der referenzierenden Tabelle mit NULLen in allen referenzierenden Spalten haben, unabhängig davon, was in der referenzierten Tabelle vorhanden ist. Solche Zeilen stehen in keiner Beziehung zu Zeilen in der referenzierten Tabelle (optionale Beziehung). Wenn Sie jedoch einen Nicht-NULL-Wert in einer der referenzierenden Spalten haben, muss es eine Zeile in der referenzierten Tabelle mit denselben Nicht-NULL-Werten in den referenzierten Spalten geben.

Angenommen, Sie haben eine Datenbank auf einer Plattform, die die standardmäßige Unique-Einschränkung unterstützt, und Sie müssen diese Datenbank zu SQL Server migrieren. Es können Probleme mit der Erzwingung von Unique-Einschränkungen in SQL Server auftreten, wenn die Unique-Spalten NULL-Werte unterstützen. Daten, die im Quellsystem als gültig galten, können in SQL Server als ungültig angesehen werden. In den folgenden Abschnitten werde ich eine Reihe möglicher Problemumgehungen in SQL Server untersuchen.

Lösung 1, mit gefiltertem Index oder indizierter Ansicht

Eine gängige Problemumgehung in T-SQL zum Erzwingen der standardmäßigen Unique-Constraint-Funktionalität, wenn nur eine Zielspalte betroffen ist, besteht darin, einen eindeutigen gefilterten Index zu verwenden, der nur die Zeilen filtert, in denen die Zielspalte nicht NULL ist. Der folgende Code löscht die vorhandene eindeutige Einschränkung von T3 und implementiert einen solchen 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;

Da der Index nur Zeilen filtert, in denen col1 nicht NULL ist, wird seine UNIQUE-Eigenschaft nur für die col1-Werte erzwungen, die nicht NULL sind.

Denken Sie daran, dass T3 bereits eine Zeile mit NULL in Spalte1 hat. Verwenden Sie zum Testen dieser Lösung den folgenden Code, um eine zweite Zeile mit NULL in Spalte1 hinzuzufügen:

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

Dieser Code wird erfolgreich ausgeführt.

Denken Sie daran, dass T3 bereits eine Zeile mit dem Wert 1 in col1 hat. Führen Sie den folgenden Code aus, um zu versuchen, eine zweite Zeile mit 1 in col1 hinzuzufügen:

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

Wie erwartet schlägt dieser Versuch mit folgendem Fehler fehl:

Verwenden Sie den folgenden Code, um T3 abzufragen:

SELECT * FROM dbo.T3;

Dieser Code generiert die folgende Ausgabe, die zwei Zeilen mit NULL in col1 zeigt:

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

Diese Lösung funktioniert gut, wenn Sie die Eindeutigkeit nur für eine Spalte erzwingen müssen und wenn Sie die referenzielle Integrität nicht mit einem Fremdschlüssel erzwingen müssen, der auf diese Spalte zeigt.

Das Problem mit dem Fremdschlüssel besteht darin, dass SQL Server einen Primärschlüssel oder eine eindeutige Einschränkung oder einen eindeutigen nicht gefilterten Index erfordert, der für die referenzierte Spalte definiert ist. Es funktioniert nicht, wenn nur ein eindeutiger gefilterter Index für die referenzierte Spalte definiert ist. Versuchen wir, eine Tabelle mit einem Fremdschlüssel zu erstellen, der auf T3.col1 verweist. Verwenden Sie zunächst den folgenden Code, um die Tabelle T3 zu erstellen:

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

Versuchen Sie dann, den folgenden Code auszuführen, um zu versuchen, einen Fremdschlüssel hinzuzufügen, der von T3FK.col1 auf T3.col1 zeigt:

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

Dieser Versuch schlägt mit folgendem Fehler fehl:

Msg 1750, Level 16, State 1
Constraint oder Index konnte nicht erstellt werden. Siehe vorherige Fehler.

Löschen Sie an dieser Stelle den vorhandenen gefilterten Index zur Bereinigung:

DROP INDEX idx_col1_notnull ON dbo.T3;

Lassen Sie die Tabelle T3FK nicht fallen, da Sie sie in späteren Beispielen verwenden werden.

Das andere Problem mit der gefilterten Indexlösung, vorausgesetzt, Sie benötigen keinen Fremdschlüssel, besteht darin, dass sie nicht funktioniert, wenn Sie die standardmäßige Unique-Constraint-Funktionalität für mehrere Spalten erzwingen müssen, beispielsweise für die Kombination (Spalte1, Spalte2). . Denken Sie daran, dass die standardmäßige Eindeutigkeitsbeschränkung doppelte Nicht-NULL-Kombinationen von Werten in den eindeutigen Spalten verbietet. Um diese Logik mit einem gefilterten Index zu implementieren, müssen Sie nur Zeilen filtern, in denen eine der eindeutigen Spalten nicht NULL ist. Anders ausgedrückt, Sie müssen nur Zeilen filtern, die nicht in allen eindeutigen Spalten NULL-Werte enthalten. Leider erlauben gefilterte Indizes nur sehr einfache Ausdrücke. Sie unterstützen weder OR, NOT noch Manipulationen an den Spalten. Daher wird derzeit keine der folgenden Indexdefinitionen unterstützt:

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;

Die Problemumgehung in einem solchen Fall besteht darin, eine indizierte Ansicht basierend auf einer Abfrage zu erstellen, die col1 und col2 von T3 mit einer der obigen WHERE-Klauseln zurückgibt, mit einem eindeutigen gruppierten Index auf (col1, col2), wie folgt:

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

Sie dürfen mehrere Zeilen mit (NULL, NULL) in (Spalte1, Spalte2) hinzufügen, aber Sie dürfen nicht mehrere Vorkommen von Nicht-NULL-Kombinationen von Werten in (Spalte1, Spalte2) hinzufügen, z. B. (3 , NULL) oder (NULL, 300) oder (1, 100). Dennoch unterstützt diese Lösung keinen Fremdschlüssel.

Führen Sie an dieser Stelle den folgenden Code zur Bereinigung aus:

DROP VIEW IF EXISTS dbo.T3CustomUnique;

Lösung 2, mit Ersatzschlüssel und berechneter Spalte

Die Lösungen mit dem gefilterten Index und der indizierten Ansicht sind gut, solange Sie keinen Fremdschlüssel unterstützen müssen. Aber was ist, wenn Sie die referenzielle Integrität erzwingen müssen? Eine Option besteht darin, weiterhin den gefilterten Index oder die indizierte Ansichtslösung zu verwenden, um die Eindeutigkeit zu erzwingen, und Trigger zu verwenden, um die referenzielle Integrität zu erzwingen. Diese Option ist jedoch recht teuer.

Eine andere Möglichkeit besteht darin, eine völlig andere Lösung für den Eindeutigkeitsteil zu verwenden, die einen Fremdschlüssel unterstützt. Die Lösung besteht darin, der referenzierten Tabelle (in unserem Fall T3) zwei Spalten hinzuzufügen. Eine Spalte namens id ist ein Ersatzschlüssel mit einer Identitätseigenschaft. Eine andere Spalte namens flag ist eine dauerhaft berechnete Spalte, die id zurückgibt, wenn col1 NULL ist, und 0, wenn sie nicht NULL ist. Anschließend erzwingen Sie eine Unique-Einschränkung für die Kombination von col1 und flag. Hier ist der Code zum Hinzufügen der beiden Spalten und der eindeutigen Einschränkung:

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

Verwenden Sie den folgenden Code, um T3 abzufragen:

SELECT * FROM dbo.T3;

Dieser Code generiert die folgende Ausgabe:

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

Für die Referenztabelle (in unserem Fall T3FK) fügen Sie eine berechnete Spalte namens flag hinzu, die immer auf 0 gesetzt ist, und einen Fremdschlüssel, der auf (col1, flag) definiert ist und auf die eindeutigen Spalten von T3 (col1, flag) zeigt :

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

Lassen Sie uns diese Lösung testen.

Versuchen Sie, die folgenden Zeilen hinzuzufügen:

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

Diese Zeilen wurden ordnungsgemäß hinzugefügt, da alle über entsprechende referenzierte Zeilen verfügen.

Fragen Sie die Tabelle T3FK:

SELECT * FROM dbo.T3FK;

Sie erhalten die folgende Ausgabe:

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

Versuchen Sie, eine Zeile hinzuzufügen, die keine entsprechende Zeile in der referenzierten Tabelle hat:

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

Der Versuch wird, wie es sein sollte, mit folgendem Fehler abgelehnt:

Versuchen Sie, T3FK eine Zeile mit einer NULL in Spalte1 hinzuzufügen:

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

Diese Zeile gilt als mit keiner Zeile in T3FK verwandt (optionale Beziehung) und sollte laut Standard unabhängig davon erlaubt sein, ob in der referenzierten Tabelle in col1 eine NULL existiert. T-SQL unterstützt dieses Szenario und die Zeile wurde erfolgreich hinzugefügt.

Fragen Sie die Tabelle T3FK:

SELECT * FROM dbo.T3FK;

Dieser Code generiert die folgende Ausgabe:

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

Die Lösung funktioniert gut, wenn Sie die standardmäßige Eindeutigkeitsfunktion für eine einzelne Spalte erzwingen müssen. Es gibt jedoch ein Problem, wenn Sie die Eindeutigkeit für mehrere Spalten erzwingen müssen. Um das Problem zu demonstrieren, löschen Sie zunächst die Tabellen T3 und T3FK:

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

Verwenden Sie den folgenden Code, um T3 mit einer zusammengesetzten eindeutigen Einschränkung für (col1, col2, flag) neu zu erstellen:

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

Beachten Sie, dass das Flag auf id gesetzt ist, wenn sowohl col1 als auch col2 NULL sind und andernfalls 0.

Die eindeutige Einschränkung selbst funktioniert gut.

Führen Sie den folgenden Code aus, um einige Zeilen zu T3 hinzuzufügen, einschließlich mehrerer Vorkommen von (NULL, NULL) in (col1, col2):

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

Diese Zeilen wurden ordnungsgemäß hinzugefügt.

Versuchen Sie, zwei Vorkommen von (1, NULL) in (Spalte1, Spalte2) hinzuzufügen:

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

Dieser Versuch schlägt mit dem folgenden Fehler fehl, wie er sollte:

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