Behandeln von NULL-WertenHandling Null Values

Ein NULL-Wert wird in einer relationalen Datenbank verwendet, wenn der Wert in einer Spalte unbekannt ist oder fehlt.A null value in a relational database is used when the value in a column is unknown or missing. Ein NULL-Wert ist weder eine leere Zeichenfolge (für Zeichen- oder datetime-Datentypen) noch der Wert 0 (für numerische Datentypen).A null is neither an empty string (for character or datetime data types) nor a zero value (for numeric data types). Die ANSI-Spezifikation SQL-92 besagt, dass ein NULL-Wert für alle Datentypen gleich sein muss, damit alle NULL-Werte einheitlich behandelt werden.The ANSI SQL-92 specification states that a null must be the same for all data types, so that all nulls are handled consistently. Der Namespace System.Data.SqlTypes bietet Semantik für NULL-Werte, indem die Schnittstelle INullable implementiert wird.The System.Data.SqlTypes namespace provides null semantics by implementing the INullable interface. Jeder der Datentypen in System.Data.SqlTypes hat seine eigene IsNull-Eigenschaft und einen Null-Wert, der einer Instanz dieses Datentyps zugewiesen werden kann.Each of the data types in System.Data.SqlTypes has its own IsNull property and a Null value that can be assigned to an instance of that data type.

Hinweis

Mit .NET Framework Version 2.0 wurde die Unterstützung für nullfähige Werttypen eingeführt, die es Programmierern ermöglichen, einen Werttyp zu erweitern, um alle Werte des zugrunde liegenden Typs darzustellen.The .NET Framework version 2.0 introduced support for nullable value types, which allow programmers to extend a value type to represent all values of the underlying type. Diese CLR-Nullwerttypen stellen eine Nullable Instanz der Struktur dar.These CLR nullable value types represent an instance of the Nullable structure. Diese Fähigkeit ist besonders nützlich, wenn Werttypen geschachtelt oder ungeschachtelt sind, was eine verbesserte Kompatibilität mit Objekttypen ermöglicht.This capability is especially useful when value types are boxed and unboxed, providing enhanced compatibility with object types. CLR-NULLwerttypen sind nicht für die Speicherung von Datenbanknulls vorgesehen, da sich ein null ANSI SQL-NULL-Wert nicht wie ein Verweis (oder Nothing in Visual Basic) verhält.CLR nullable value types are not intended for storage of database nulls because an ANSI SQL null does not behave the same way as a null reference (or Nothing in Visual Basic). Verwenden Sie zum Arbeiten mit ANSI-SQL-NULL-Werten in Datenbanken NULL-Werte des Typs System.Data.SqlTypes anstelle von Nullable.For working with database ANSI SQL null values, use System.Data.SqlTypes nulls rather than Nullable. Weitere Informationen zum Arbeiten mit CLR-Wert nullablen Typen in Visual Basic finden Sie unter Nullable Value Types, und für C-Wertetypen unter Nullable Value Types.For more information on working with CLR value nullable types in Visual Basic see Nullable Value Types, and for C# see Nullable value types.

NULL-Werte und dreiwertige LogikNulls and Three-Valued Logic

Durch das Zulassen von NULL-Werten in Spaltendefinitionen wird in Ihre Anwendung dreiwertige Logik eingeführt.Allowing null values in column definitions introduces three-valued logic into your application. Ein Vergleich kann anhand einer von drei Bedingungen ausgewertet werden:A comparison can evaluate to one of three conditions:

  • TrueTrue

  • FalseFalse

  • UnknownUnknown

Da NULL als unbekannt betrachtet wird, werden zwei miteinander verglichene NULL-Werte nicht als gleich angesehen.Because null is considered to be unknown, two null values compared to each other are not considered to be equal. Wenn in Ausdrücken mit arithmetischen Operatoren einer der Operanden NULL ist, ist das Ergebnis ebenfalls NULL.In expressions using arithmetic operators, if any of the operands is null, the result is null as well.

NULL-Werte und SqlBooleanNulls and SqlBoolean

Beim Vergleich zwischen beliebigen System.Data.SqlTypes wird SqlBoolean zurückgegeben.Comparison between any System.Data.SqlTypes will return a SqlBoolean. Die IsNull-Funktion für jeden SqlType gibt SqlBoolean zurück und kann verwendet werden, um auf NULL-Werte zu prüfen.The IsNull function for each SqlType returns a SqlBoolean and can be used to check for null values. Die folgenden Wahrheitstabellen zeigen, wie die Operatoren AND, OR und NOT bei Vorhandensein eines NULL-Werts funktionieren.The following truth tables show how the AND, OR, and NOT operators function in the presence of a null value. (T = TRUE, F = FALSE und U = Unbekannt oder NULL.)(T=true, F=false, and U=unknown, or null.)

WahrheitstabelleTruth Table

Informationen zur ANSI_NULLS-OptionUnderstanding the ANSI_NULLS Option

System.Data.SqlTypes bietet die gleiche Semantik wie bei aktivierter Option ANSI_NULLS in SQL Server.System.Data.SqlTypes provides the same semantics as when the ANSI_NULLS option is set on in SQL Server. Alle arithmetischen Operatoren (+, -, *, /, %), |bitweise Operatoren (, &, ), und die meisten Funktionen IsNullgeben NULL zurück, wenn einer der Operanden oder Argumente null ist, mit Ausnahme der Eigenschaft .All arithmetic operators (+, -, *, /, %), bitwise operators (~, &, |), and most functions return null if any of the operands or arguments is null, except for the property IsNull.

Der ANSI SQL-92-Standard unterstützt columnName = NULL in einer WHERE-Klausel nicht.The ANSI SQL-92 standard does not support columnName = NULL in a WHERE clause. In SQL Server steuert die Option ANSI_NULLS sowohl die standardmäßige NULL-Zulässigkeit in der Datenbank als auch die Auswertung von Vergleichen mit NULL-Werten.In SQL Server, the ANSI_NULLS option controls both default nullability in the database and evaluation of comparisons against null values. Wenn ANSI_NULLS auf ON festgelegt ist (Standardeinstellung), muss in Ausdrücken bei Prüfen auf NULL-Werte der Operator IS NULL verwendet werden.If ANSI_NULLS is turned on (the default), the IS NULL operator must be used in expressions when testing for null values. Der folgende Vergleich gibt z. B. immer UNKNOWN zurück, wenn ANSI_NULLS auf ON festgelegt ist:For example, the following comparison always yields unknown when ANSI_NULLS is on:

colname > NULL  

Der Vergleich mit einer Variablen, die einen NULL-Wert enthält, ergibt ebenfalls „Unbekannt“:Comparison to a variable containing a null value also yields unknown:

colname > @MyVariable  

Verwenden Sie die Prädikate IS NULL oder IS NOT NULL, um zu überprüfen, ob ein NULL-Wert vorliegt.Use the IS NULL or IS NOT NULL predicate to test for a null value. Dadurch nimmt die Komplexität der WHERE-Klausel möglicherweise zu.This can add complexity to the WHERE clause. Beispielsweise lässt die Spalte TerritoryID in der AdventureWorks-Tabelle „Customer“ NULL-Werte zu.For example, the TerritoryID column in the AdventureWorks Customer table allows null values. Soll eine SELECT-Anweisung u. a. das Vorhandensein von NULL-Werten überprüfen, muss ein IS NULL-Prädikat eingefügt werden:If a SELECT statement is to test for null values in addition to others, it must include an IS NULL predicate:

SELECT CustomerID, AccountNumber, TerritoryID  
FROM AdventureWorks.Sales.Customer  
WHERE TerritoryID IN (1, 2, 3)  
   OR TerritoryID IS NULL  

Wenn Sie ANSI_NULLS in SQL Server auf OFF festlegen, können Sie Ausdrücke erstellen, die den Gleichheitsoperator zum Vergleich mit NULL verwenden.If you set ANSI_NULLS off in SQL Server, you can create expressions that use the equality operator to compare to null. Sie können jedoch nicht verhindern, dass verschiedene Verbindungen NULL-Optionen für diese Verbindung festlegen.However, you can't prevent different connections from setting null options for that connection. Die Verwendung von IS NULL zum Testen auf NULL-Werte funktioniert immer, und zwar unabhängig von den ANSI_NULLS-Einstellungen für eine Verbindung.Using IS NULL to test for null values always works, regardless of the ANSI_NULLS settings for a connection.

Das Deaktivieren von ANSI_NULLS wird in einem DataSet nicht unterstützt, das immer dem ANSI-Standard SQL-92 für die Behandlung von NULL-Werten in System.Data.SqlTypes folgt.Setting ANSI_NULLS off is not supported in a DataSet, which always follows the ANSI SQL-92 standard for handling null values in System.Data.SqlTypes.

Zuweisen von NULL-WertenAssigning Null Values

NULL-Werte sind etwas Besonderes, und ihre Speicher- und Zuordnungssemantik unterscheidet sich in verschiedenen Typen- und Speichersystemen.Null values are special, and their storage and assignment semantics differ across different type systems and storage systems. Ein Dataset ist für die Verwendung mit verschiedenen Typ- und Speichersystemen konzipiert.A Dataset is designed to be used with different type and storage systems.

In diesem Abschnitt wird die NULL-Semantik für das Zuweisen von NULL-Werten zu einer DataColumn in einer DataRow in den verschiedenen Typensystemen beschrieben.This section describes the null semantics for assigning null values to a DataColumn in a DataRow across the different type systems.

DBNull.Value
Diese Zuweisung ist gültig für eine DataColumn eines beliebigen Typs.This assignment is valid for a DataColumn of any type. Wenn der Typ INullable implementiert, wird DBNull.Value in den entsprechenden stark typisierten NULL-Wert gezwungen.If the type implements INullable, DBNull.Value is coerced into the appropriate strongly typed Null value.

SqlType.Null
Alle System.Data.SqlTypes-Datentypen implementieren INullable.All System.Data.SqlTypes data types implement INullable. Wenn der stark typisierte NULL-Wert mithilfe impliziter Umwandlungsoperatoren in den Datentyp der Spalte konvertiert werden kann, sollte die Zuweisung durchgeführt werden.If the strongly typed null value can be converted into the column's data type using implicit cast operators, the assignment should go through. Andernfalls wird eine Ausnahme aufgrund ungültiger Umwandlung ausgelöst.Otherwise an invalid cast exception is thrown.

null
Wenn 'null' ein zulässiger Wert für den angegebenen Datentyp DataColumn ist, wird er in den entsprechenden DbNull.Value oder Null gezwungen, der dem INullable-Typ (SqlType.Null) zugeordnet ist.If 'null' is a legal value for the given DataColumn data type, it is coerced into the appropriate DbNull.Value or Null associated with the INullable type (SqlType.Null)

derivedUdt.Null
Bei UDT-Spalten werden NULL-Werte immer basierend auf dem Typ gespeichert, der DataColumn zugeordnet ist.For UDT columns, nulls are always stored based on the type associated with the DataColumn. Betrachten Sie den Fall einer UDT, die einer DataColumn zugeordnet ist, die nicht INullable implementiert, während ihre Unterklasse dies tut.Consider the case of a UDT associated with a DataColumn that does not implement INullable while its sub-class does. Wenn in diesem Fall ein stark typisierter NULL-Wert der abgeleiteten Klasse zugewiesen ist, wird er als nicht typisierter DbNull.Value gespeichert, da die NULL-Speicherung immer im Einklang mit dem Datentyp von DataColumn ist.In this case, if a strongly typed null value associated with the derived class is assigned, it is stored as an untyped DbNull.Value, because null storage is always consistent with the DataColumn's data type.

Hinweis

Die Struktur von Nullable<T> oder Nullable wird in DataSet derzeit nicht unterstützt.The Nullable<T> or Nullable structure is not currently supported in the DataSet.

Zuweisung mehrerer Spalten (Zeilen)Multiple Column (Row) Assignment

DataTable.Add, DataTable.LoadDataRow oder andere APIs, die ein ItemArray akzeptieren, das einer Zeile zugeordnet wird, ordnen 'null' dem Standardwert von DataColumn zu.DataTable.Add, DataTable.LoadDataRow, or other APIs that accept an ItemArray that gets mapped to a row, map 'null' to the DataColumn's default value. Wenn ein Objekt im Array DbNull.Value oder sein stark typisiertes Pendant enthält, gelten die gleichen Regeln wie oben beschrieben.If an object in the array contains DbNull.Value or its strongly typed counterpart, the same rules as described above are applied.

Außerdem gelten die folgenden Regeln für eine Instanz von NULL-Zuweisungen für DataRow.["columnName"]:In addition, the following rules apply for an instance of DataRow.["columnName"] null assignments:

  1. Für alle Spalten (mit Ausnahme der stark typisierten NULL-Spalten) lautet der default-Standardwert DbNull.Value. In den stark typisierten NULL-Spalten ist es der entsprechende stark typisierte NULL-Wert.The default default value is DbNull.Value for all except the strongly typed null columns where it is the appropriate strongly typed null value.

  2. NULL-Werte werden niemals bei der Serialisierung in XML-Dateien geschrieben (wie in „xsi: nil“).Null values are never written out during serialization to XML files (as in "xsi:nil").

  3. Alle Nicht-NULL-Werte, einschließlich der Standardwerte, werden bei der Serialisierung in XML immer geschrieben.All non-null values, including defaults, are always written out while serializing to XML. Dies steht im Gegensatz zur XSD/XML-Semantik, bei der ein NULL-Wert (xsi:nil) explizit und der Standardwert implizit ist (wenn er in XML nicht vorhanden ist, kann ein validierender Parser ihn aus einem zugehörigen XSD-Schema abrufen).This is unlike XSD/XML semantics where a null value (xsi:nil) is explicit and the default value is implicit (if not present in XML, a validating parser can get it from an associated XSD schema). Das Gegenteil gilt für DataTable: Ein NULL-Wert ist implizit und der Standardwert ist explizit.The opposite is true for a DataTable: a null value is implicit and the default value is explicit.

  4. Allen fehlenden Spaltenwerten für aus der XML-Eingabe gelesene Zeilen wird NULL zugewiesen.All missing column values for rows read from XML input are assigned NULL. Zeilen, die mit NewRow oder ähnlichen Methoden erstellt werden, wird der Standardwert von DataColumn zugewiesen.Rows created using NewRow or similar methods are assigned the DataColumn's default value.

  5. Die IsNull-Methode gibt true sowohl für DbNull.Value als auch für INullable.Null zurück.The IsNull method returns true for both DbNull.Value and INullable.Null.

Zuweisen von NULL-WertenAssigning Null Values

Der Standardwert für jede System.Data.SqlTypes-Instanz ist NULL.The default value for any System.Data.SqlTypes instance is null.

NULL-Werte in System.Data.SqlTypes sind typspezifisch und können nicht durch einen einzelnen Wert, wie z. B. DbNull, dargestellt werden.Nulls in System.Data.SqlTypes are type-specific and cannot be represented by a single value, such as DbNull. Verwenden Sie die IsNull-Eigenschaft, um auf NULL-Werte zu prüfen.Use the IsNull property to check for nulls.

NULL-Werte können einem DataColumn zugewiesen werden, wie im folgenden Codebeispiel gezeigt.Null values can be assigned to a DataColumn as shown in the following code example. Sie können SqlTypes-Variablen direkt NULL-Werte zuweisen, ohne eine Ausnahme auszulösen.You can directly assign null values to SqlTypes variables without triggering an exception.

BeispielExample

Das folgende Codebeispiel erstellt eine DataTable mit zwei Spalten, die als SqlInt32 und SqlString definiert sind.The following code example creates a DataTable with two columns defined as SqlInt32 and SqlString. Der Code fügt eine Zeile mit bekannten Werten und eine Zeile mit NULL-Werten hinzu und iteriert dann durch die DataTable. Dabei werden die Werte den Variablen zugewiesen, und die Ausgabe wird im Konsolenfenster angezeigt.The code adds one row of known values, one row of null values and then iterates through the DataTable, assigning the values to variables and displaying the output in the console window.

static private void WorkWithSqlNulls()
{
    DataTable table = new DataTable();

    // Specify the SqlType for each column.
    DataColumn idColumn =
        table.Columns.Add("ID", typeof(SqlInt32));
    DataColumn descColumn =
        table.Columns.Add("Description", typeof(SqlString));

    // Add some data.
    DataRow nRow = table.NewRow();
    nRow["ID"] = 123;
    nRow["Description"] = "Side Mirror";
    table.Rows.Add(nRow);

    // Add null values.
    nRow = table.NewRow();
    nRow["ID"] = SqlInt32.Null;
    nRow["Description"] = SqlString.Null;
    table.Rows.Add(nRow);

    // Initialize variables to use when
    // extracting the data.
    SqlBoolean isColumnNull = false;
    SqlInt32 idValue = SqlInt32.Zero;
    SqlString descriptionValue = SqlString.Null;

    // Iterate through the DataTable and display the values.
    foreach (DataRow row in table.Rows)
    {
        // Assign values to variables. Note that you 
        // do not have to test for null values.
        idValue = (SqlInt32)row["ID"];
        descriptionValue = (SqlString)row["Description"];

        // Test for null value in ID column.
        isColumnNull = idValue.IsNull;

        // Display variable values in console window.
        Console.Write("isColumnNull={0}, ID={1}, Description={2}",
            isColumnNull, idValue, descriptionValue);
        Console.WriteLine();
    }
Private Sub WorkWithSqlNulls()
    Dim table As New DataTable()

    ' Specify the SqlType for each column.
    Dim idColumn As DataColumn = _
      table.Columns.Add("ID", GetType(SqlInt32))
    Dim descColumn As DataColumn = _
      table.Columns.Add("Description", GetType(SqlString))

    ' Add some data.
    Dim row As DataRow = table.NewRow()
    row("ID") = 123
    row("Description") = "Side Mirror"
    table.Rows.Add(row)

    ' Add null values.
    row = table.NewRow()
    row("ID") = SqlInt32.Null
    row("Description") = SqlString.Null
    table.Rows.Add(row)

    ' Initialize variables to use when
    ' extracting the data.
    Dim isColumnNull As SqlBoolean = False
    Dim idValue As SqlInt32 = SqlInt32.Zero
    Dim descriptionValue As SqlString = SqlString.Null

    ' Iterate through the DataTable and display the values.
    For Each row In table.Rows
        ' Assign values to variables. Note that you 
        ' do not have to test for null values.
        idValue = CType(row("ID"), SqlInt32)
        descriptionValue = CType(row("Description"), SqlString)

        ' Test for null value with ID column
        isColumnNull = idValue.IsNull

        ' Display variable values in console window.
        Console.Write("isColumnNull={0}, ID={1}, Description={2}", _
          isColumnNull, idValue, descriptionValue)
        Console.WriteLine()
    Next row
End Sub

In diesem Beispiel werden die folgenden Ergebnisse gezeigt:This example displays the following results:

isColumnNull=False, ID=123, Description=Side Mirror  
isColumnNull=True, ID=Null, Description=Null  

Vergleichen von NULL-Werten mit "SqlTypes" und CLR-TypenComparing Null Values with SqlTypes and CLR Types

Beim Vergleich von NULL-Werten ist es wichtig, den Unterschied zwischen der Art und Weise zu verstehen, wie die Equals-Methode NULL-Werte in System.Data.SqlTypes auswertet, im Vergleich dazu, wie sie mit CLR-Typen arbeitet.When comparing null values, it is important to understand the difference between the way the Equals method evaluates null values in System.Data.SqlTypes as compared with the way it works with CLR types. Alle System.Data.SqlTypesEquals-Methoden verwenden Datenbanksemantik zur Auswertung von NULL-Werten. Wenn einer oder beide Werte NULL sind, ergibt der Vergleich NULL.All of the System.Data.SqlTypesEquals methods use database semantics for evaluating null values: if either or both of the values is null, the comparison yields null. Andererseits ergibt das Anwenden der CLR-Methode Equals auf zwei System.Data.SqlTypes TRUE, wenn beide NULL sind.On the other hand, using the CLR Equals method on two System.Data.SqlTypes will yield true if both are null. Dies spiegelt den Unterschied zwischen der Verwendung einer Instanzmethode wie der CLR-Methode String.Equals und der Verwendung der statischen/gemeinsamen Methode SqlString.Equals wider.This reflects the difference between using an instance method such as the CLR String.Equals method, and using the static/shared method, SqlString.Equals.

Das folgende Beispiel veranschaulicht den Unterschied in den Ergebnissen zwischen der SqlString.Equals-Methode und der String.Equals-Methode, wenn jeweils ein Paar NULL-Werte und dann ein Paar leere Zeichenfolgen übergeben werden.The following example demonstrates the difference in results between the SqlString.Equals method and the String.Equals method when each is passed a pair of null values and then a pair of empty strings.

    private static void CompareNulls()
    {
        // Create two new null strings.
        SqlString a = new SqlString();
        SqlString b = new SqlString();

        // Compare nulls using static/shared SqlString.Equals.
        Console.WriteLine("SqlString.Equals shared/static method:");
        Console.WriteLine("  Two nulls={0}", SqlStringEquals(a, b));

        // Compare nulls using instance method String.Equals.
        Console.WriteLine();
        Console.WriteLine("String.Equals instance method:");
        Console.WriteLine("  Two nulls={0}", StringEquals(a, b));

        // Make them empty strings.
        a = "";
        b = "";

        // When comparing two empty strings (""), both the shared/static and
        // the instance Equals methods evaluate to true.
        Console.WriteLine();
        Console.WriteLine("SqlString.Equals shared/static method:");
        Console.WriteLine("  Two empty strings={0}", SqlStringEquals(a, b));

        Console.WriteLine();
        Console.WriteLine("String.Equals instance method:");
        Console.WriteLine("  Two empty strings={0}", StringEquals(a, b));
    }
    
    private static string SqlStringEquals(SqlString string1, SqlString string2)
    {
        // SqlString.Equals uses database semantics for evaluating nulls.
        string returnValue = SqlString.Equals(string1, string2).ToString();
        return returnValue;
    }

    private static string StringEquals(SqlString string1, SqlString string2)
    {
        // String.Equals uses CLR type semantics for evaluating nulls.
        string returnValue = string1.Equals(string2).ToString();
        return returnValue;
    }
}
Private Sub CompareNulls()
    ' Create two new null strings.
    Dim a As New SqlString
    Dim b As New SqlString

    ' Compare nulls using static/shared SqlString.Equals.
    Console.WriteLine("SqlString.Equals shared/static method:")
    Console.WriteLine("  Two nulls={0}", SqlStringEquals(a, b))

    ' Compare nulls using instance method String.Equals.
    Console.WriteLine()
    Console.WriteLine("String.Equals instance method:")
    Console.WriteLine("  Two nulls={0}", StringEquals(a, b))

    ' Make them empty strings.
    a = ""
    b = ""

    ' When comparing two empty strings (""), both the shared/static and
    ' the instance Equals methods evaluate to true.
    Console.WriteLine()
    Console.WriteLine("SqlString.Equals shared/static method:")
    Console.WriteLine("  Two empty strings={0}", SqlStringEquals(a, b))

    Console.WriteLine()
    Console.WriteLine("String.Equals instance method:")
    Console.WriteLine("  Two empty strings={0}", StringEquals(a, b))
End Sub

Private Function SqlStringEquals(ByVal string1 As SqlString, _
    ByVal string2 As SqlString) As String

    ' SqlString.Equals uses database semantics for evaluating nulls.
    Dim returnValue As String = SqlString.Equals(string1, string2).ToString()
    Return returnValue
End Function

Private Function StringEquals(ByVal string1 As SqlString, _
    ByVal string2 As SqlString) As String

    ' String.Equals uses CLR type semantics for evaluating nulls.
    Dim returnValue As String = string1.Equals(string2).ToString()
    Return returnValue
End Function

Der Code erzeugt folgende Ausgabe:The code produces the following output:

SqlString.Equals shared/static method:  
  Two nulls=Null  
  
String.Equals instance method:  
  Two nulls=True  
  
SqlString.Equals shared/static method:  
  Two empty strings=True  
  
String.Equals instance method:  
  Two empty strings=True

Siehe auchSee also