Megosztás:

Null értékek kezelése

Egy relációs adatbázisban null értéket használ a rendszer, ha az oszlop értéke ismeretlen vagy hiányzik. A null érték nem üres sztring (karakter- vagy datetime-adattípusok esetén), sem nulla érték (numerikus adattípusok esetén). Az ANSI SQL-92 specifikációja azt állítja, hogy a null értéknek minden adattípus esetében azonosnak kell lennie, hogy a null értékek kezelése egységes legyen. A System.Data.SqlTypes névtér null szemantikát biztosít az INullable interfész implementálásával. Az adattípusok System.Data.SqlTypes mindegyikének saját IsNull tulajdonsága van, és egy Null érték, amely hozzárendelhető az adott adattípus egy példányához.

Megjegyzés:

A .NET-keretrendszer 2.0-s verziója támogatja a null értékű értéktípusokat, így a programozók kiterjeszthetnek egy értéktípust az alapul szolgáló típus összes értékének megjelenítésére. Ezek a CLR null értéket felvevő értéktípusok a Nullable struktúra egy példányát képviselik. Ez a lehetőség különösen akkor hasznos, amikor az értéktípusok dobozoltak és kicsomagoltak, ezáltal fokozott kompatibilitást biztosítanak az objektumtípusokkal. A CLR null értékű értéktípusai nem az adatbázis null értékeinek tárolására szolgálnak, mert az ANSI SQL null nem ugyanúgy viselkedik, mint egy null hivatkozás (vagy Nothing a Visual Basic esetében). Az ANSI SQL null értékek használatához használjon System.Data.SqlTypes null értékeket ahelyett Nullable null értékeket. A CLR érték null értékű típusok Visual Basicben való használatával kapcsolatos további információkért lásd: Null értékű típusok, C# esetén pedig a Null értékű típusok.

Null értékek és Three-Valued logika

Ha engedélyezi a null értékeket az oszlopdefiníciókban, az háromértékű logikát vezet be az alkalmazásba. Az összehasonlítás három feltétel egyikét értékelheti ki:

  • Igaz

  • Téves

  • Ismeretlen

Mivel a null érték ismeretlennek minősül, a két null érték egymáshoz képest nem tekinthető egyenlőnek. Az aritmetikai operátorokat használó kifejezésekben, ha az operandusok bármelyike null, akkor az eredmény is null.

Null értékek és SqlBoolean

Bármelyik System.Data.SqlTypes összehasonlítása visszaad egy SqlBoolean. Az IsNull függvény minden SqlType esetén egy SqlBoolean értéket ad vissza, és használható a null értékek ellenőrzésére. Az alábbi igazságtáblák azt mutatják be, hogy az AND, OR és NOT operátorok hogyan működnek null érték jelenlétében. (T=igaz, F=hamis, és U=ismeretlen, vagy üres.)

Igazságtábla

A ANSI_NULLS lehetőség ismertetése

System.Data.SqlTypes ugyanazt a szemantikát biztosítja, mint amikor a ANSI_NULLS beállítás be van kapcsolva az SQL Serverben. Minden aritmetikai operátor (+, -, *, /, %), bitenkénti operátor (~, &, |) és a legtöbb függvény null értéket ad vissza, ha az operandusok vagy argumentumok bármelyike null értékű, kivéve a tulajdonságot IsNull.

Az ANSI SQL-92 szabvány nem támogatja, hogy a columnName = NULL szerepeljen a WHERE záradékban. Az SQL Serverben a ANSI_NULLS beállítás az adatbázis alapértelmezett nullképességét és a null értékekkel való összehasonlítások kiértékelését szabályozza. Ha a ANSI_NULLS be van kapcsolva (az alapértelmezett), akkor az IS NULL operátort kell használni a kifejezésekben a null értékek tesztelése során. A következő összehasonlítás például mindig ismeretlen eredményt ad, ha ANSI_NULLS be van kapcsolva:

colname > NULL

A null értéket tartalmazó változóval való összehasonlítás szintén ismeretlen eredményt ad:

colname > @MyVariable

Null érték teszteléséhez használja az IS NULL vagy a NOT NULL predikátumot. Ez összetettebbé teheti a WHERE záradékot. Az AdventureWorks Customer tábla TerritoryID oszlopa például null értékeket engedélyez. Ha a SELECT utasítás a másokon kívül a null értékeket is teszteli, akkor az IS NULL predikátumot is tartalmaznia kell:

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

Ha az ANSI_NULLS ki van kapcsolva az SQL Serverben, akkor olyan kifejezéseket hozhat létre, amelyek az egyenlőségi operátort használják a null értékkel való összehasonlításhoz. Azonban nem akadályozhatja meg, hogy a különböző kapcsolatok null értékű beállításokat állítsanak be az adott kapcsolathoz. A null értékek teszteléséhez az IS NULL használata mindig működik, függetlenül a kapcsolat ANSI_NULLS beállításaitól.

Az ANSI_NULLS kikapcsolása nem támogatott a DataSet-ban, amely mindig az ANSI SQL-92 szabványt követi a null értékek System.Data.SqlTypes kezelésénél.

Null értékek hozzárendelése

A null értékek különlegesek, a tárolási és hozzárendelési szemantikák pedig különböző típusú rendszerekben és tárolórendszerekben különböznek. Az A Dataset különböző típusú és tárolórendszerekhez használható.

Ez a szakasz a nulla szemantika alkalmazását ismerteti a null értékek DataColumn és DataRow típusú rendszerekben történő hozzárendelése során.

DBNull.Value
Ez a feladat bármilyen típusú DataColumn esetén érvényes. Ha a típus implementálja INullable, DBNull.Value a megfelelő, erősen típusos Null értékre van kényszerítve.

SqlType.Null
Minden System.Data.SqlTypes adattípus implementálja a INullable. Ha az erősen beírt null érték implicit öntött operátorok használatával konvertálható az oszlop adattípusává, a hozzárendelésnek végig kell mennie. Ellenkező esetben érvénytelen leadott kivételt ad ki a rendszer.

null
Ha a "null" egy megengedett érték az adott DataColumn adattípushoz, akkor azt a megfelelő DbNull.Value típusba kényszerítik, vagy a Null a INullable típushoz (SqlType.Null) társítják.

derivedUdt.Null
Az UDT-oszlopok esetében a null értékek tárolása mindig a függvényhez DataColumntársított típus alapján történik. Fontolja meg egy UDT DataColumn esetét, amely nem implementálja INullable, míg az alosztálya igen. Ebben az esetben, ha egy, a származtatott osztályhoz társított, erősen típusozott null érték van hozzárendelve, a rendszer típus nélküliként DbNull.Value tárolja, mivel a null tárterület mindig összhangban van a DataColumn adattípusával.

Megjegyzés:

A Nullable<T> vagy Nullable struktúra jelenleg nem támogatott a DataSet.

Bármely System.Data.SqlTypes példány alapértelmezett értéke null.

A System.Data.SqlTypes null értékek típusspecifikusak, és nem jelölhetők egy adott érték, például a DbNull által. IsNull A tulajdonság használatával ellenőrizze a null értékeket.

A null értékek az DataColumn alábbi kód példában látható módon rendelhetők hozzá. Null értékeket közvetlenül hozzárendelhet a változókhoz SqlTypes kivétel aktiválása nélkül.

példa

Az alábbi példakód létrehoz egy DataTable-t két oszloppal, amelyeket SqlInt32 és SqlString határoz meg. A kód egy ismert értéksort, egy null értékű sort ad hozzá, majd a DataTableváltozókhoz rendeli az értékeket, és megjeleníti a kimenetet a konzolablakban.

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

    // 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

Ez a példa a következő eredményeket jeleníti meg:

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

Több oszlop (sor) hozzárendelése

DataTable.Add, DataTable.LoadDataRow, vagy más API-k, amelyek egy ItemArray-t fogadnak, ami egy sorra kerül leképezésre, a 'null' értéket a DataColumn alapértelmezett értékére képezi le. Ha a tömb egy objektuma tartalmazza DbNull.Value-t vagy ennek erősen típusos megfelelőjét, ugyanazok a szabályok vonatkoznak rá, mint korábban.

Emellett a DataRow.["columnName"] null hozzárendelések esetében a következő szabályok érvényesek:

  1. Az alapértelmezett érték az DbNull.Value összesre igaz, kivéve az erősen beírt null oszlopokat, ahol az a megfelelő, erősen beírt null érték.

  2. A null értékek soha nem íródnak ki az XML-fájlokba való szerializálás során (mint az "xsi:nil").

  3. Minden nem null értékű érték, beleértve az alapértelmezett értékeket is, mindig ki van írva az XML-be való szerializálás során. Ez ellentétben áll az XSD/XML szemantikával, ahol a null érték (xsi:nil) explicit, és az alapértelmezett érték implicit (ha nem jelenik meg AZ XML-ben, az érvényesítő elemzők lekérhetik azt egy társított XSD-sémából). Az ellenkezője igaz egy DataTable esetében: a null érték implicit, az alapértelmezett érték pedig explicit.

  4. Az XML-bemenetből beolvasott sorok összes hiányzó oszlopértéke NULL értékű. A NewRow vagy hasonló módszerekkel létrehozott sorok a DataColumn alapértelmezett értékét kapják.

  5. A IsNull metódus true-t ad vissza mind a DbNull.Value és INullable.Null esetében.

Null értékek összehasonlítása az SqlTypes és a CLR-típusokkal

A null értékek összehasonlításakor fontos tisztában lenni azzal, hogy a metódus hogyan értékeli ki a Equals null értékeket System.Data.SqlTypes a CLR-típusokhoz képest. Az összes metódus adatbázis-szemantikát System.Data.SqlTypesEquals használ a null értékek kiértékeléséhez: ha bármelyik vagy mindkét érték null, akkor az összehasonlítás null értéket eredményez. Másrészt, ha a CLR Equals metódust kettőre System.Data.SqlTypes használjuk, akkor igaz lesz, ha mindkettő null értékű. Ez egy példánymetódus, például a CLR String.Equals metódus és a statikus/megosztott metódus SqlString.Equalshasználata közötti különbséget tükrözi.

Az alábbi példa a SqlString.Equals metódus és a String.Equals metódus közötti eredménybeli különbséget mutatja be, amikor mindegyiknek egy null értékekből álló párt, majd egy üres sztringpárt adunk át.

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

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

        // Compare nulls using instance method String.Equals.
        Console.WriteLine();
        Console.WriteLine("String.Equals instance method:");
        Console.WriteLine($"  Two nulls={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={SqlStringEquals(a, b)}");

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

    static string SqlStringEquals(SqlString string1, SqlString string2)
    {
        // SqlString.Equals uses database semantics for evaluating nulls.
        var returnValue = SqlString.Equals(string1, string2).ToString();
        return returnValue;
    }

    static string StringEquals(SqlString string1, SqlString string2)
    {
        // String.Equals uses CLR type semantics for evaluating nulls.
        var 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

A kód a következő kimenetet hozza létre:

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

Lásd még

  • Last updated on