Verwenden Sie ISNULL oder COALESCE, um eine bestimmte Bedingung zu überprüfen?

Ich weiß, dass mehrere Parameter übergeben werden können COALESCE, aber wenn Sie nur einen Ausdruck überprüfen möchten, um festzustellen, ob er nicht vorhanden ist, verwenden Sie einen Standard oder ist es besser, ihn ISNULLstattdessen zu verwenden ?

Gibt es einen Leistungsgewinn zwischen den beiden?

Dieses in Microsoft Connect gemeldete Problem zeigt einige Unterschiede zwischen COALESCEund ISNULL:

Ein früher Teil unserer Verarbeitung schreibt COALESCE( expression1, expression2 )als CASE WHEN expression1 IS NOT NULL THEN expression1 ELSE expression2 END. In [diesem Beispiel]:

COALESCE ( ( SELECT Nullable
             FROM Demo
             WHERE SomeCol = 1 ), 1 )

wir erzeugen:

SELECT CASE
          WHEN (SELECT Nullable FROM Demo WHERE SomeCol = 1) IS NOT NULL
          THEN (SELECT Nullable FROM Demo WHERE SomeCol = 1)
          ELSE 1
       END

Spätere Phasen der Abfrageverarbeitung verstehen nicht, dass die beiden Unterabfragen ursprünglich der gleiche Ausdruck waren, daher führen sie die Unterabfrage zweimal aus ...

Eine Abhilfe, obwohl ich es vorschlagen hassen, ist zu ändern , COALESCEum ISNULLda diese, nicht die Unterabfrage duplizieren.

Ich denke nicht, aber COALESCE ist im SQL '92 -Standard und wird von verschiedenen Datenbanken unterstützt. Wenn Sie sich für Portabilität entscheiden, verwenden Sie ISNULL nicht.

In COALESCE können Sie mehrere Ausdrücke haben, wobei Sie wie in ISNULL nur einen Ausdruck überprüfen können

COALESCE ( expression [ ,...n ] ) 

ISNULL ( check_expression , replacement_value )

Erwähnenswert ist, dass die Typbehandlung zwischen den beiden ebenfalls einen Unterschied machen kann (siehe diesen zugehörigen Antwortpunkt (2) ).

Angenommen, eine Abfrage versucht, eine Verknüpfung zum Schreiben eines Nullvergleichs zu verwenden:

select * from SomeTable
 where IsNull(SomeNullableBitField, -1) != IsNull(SomeOtherNullableBitField, -1);

das ist anders als

select * from SomeTable
 where coalesce(SomeNullableBitField, -1) != coalesce(SomeOtherNullableBitField, -1);

Denn im ersten Fall erzwingt IsNull (), dass der Typ ein Bit ist (also wird -1 in true konvertiert), während im zweiten Fall beide zu einem int heraufgestuft werden.

with input as 
(
  select convert(bit, 1) as BitOn,      
         convert(bit, 0) as BitOff,
         convert(bit, null) as BitNull
)
select BitOn, 
       BitOff,
       BitNull,
       IsNull(BitOn, -1) IsNullBitOn,         -- true
       IsNull(BitOff, -1) IsNullBitOff,       -- false
       IsNull(BitNull, -1) IsNullBitNull,     -- true, converts the -1 to bit
       coalesce(BitOn, -1) CoalesceBitOn,     -- 1
       coalesce(BitOff, -1) CoalesceBitOff,   -- 0       
       coalesce(BitNull, -1) CoalesceBitNull  -- -1
  from input;

Es gibt einen ähnlichen Kommentar / Link (@Martin Smith) zu der Frage selbst.

Eine wichtige Sache, die ich nicht explizit angegeben sehe, ist, dass ISNULLder Ausgabetyp dem ersten Ausdruck ähnlich ist, aber COALESCEdamit den Datentyp des Werts mit der höchsten Priorität zurückgibt.

DECLARE @X VARCHAR(3) = NULL
DECLARE @Y VARCHAR(10) = '123456789'
/* The datatype returned is similar to X, or the first expression*/
SELECT ISNULL(@X, @Y) ---> Output is '123'
/* The datatype returned is similar to Y, or to the value of highest precedence*/
SELECT COALESCE(@X, @Y) ---> Output is '123456789'

Die NULLund COALESCEsind nicht immer austauschbar. Es verdient, ihre Unterschiede zu kennen, um zu wissen, wann es besser ist, das eine über das andere zu verwenden:

Die obige Tabelle ist ein Vergleich zwischen ISNULLund COALESCEaus einem Exam Ref 70-761 Querying Data with Transact-SQLBuch von Itzik Ben-Gan.

1. Anzahl der unterstützten Parameter - 2für ISNULLvs >2bei VerwendungCOALESCE
2. ISNULList eine proprietäre T-SQL-Funktion und entspricht dem COALESCEISO / ANSI-SQL-Standard

3. Der Datentyp des Ergebnisses ist wichtig. Überprüfen Sie nach dem Lesen der Notizen in der obigen Tabelle die folgenden Fälle:

   DECLARE @x VARCHAR(3)  = NULL
          ,@y VARCHAR(10) = '1234567890';
   
   SELECT ISNULL(@x, @y) AS [ISNULL], COALESCE(@x, @y) AS [COALESCE];
   

   

   Das ISNULLerhält den Datentyp des ersten Arguments, da es nicht NULLwörtlich ist. Es ist VARCHAR(3)und ist ein Ergebnis, die Daten des zweiten Arguments werden entsprechend zugeschnitten. Mit COALESCEdem Datentyp, wenn höchste Priorität verwendet wird.

   DECLARE @x VARCHAR(8)  = '123x5'
          ,@y INT = 123;
   
   SELECT ISNULL(@x, @y) AS [ISNULL];
   SELECT COALESCE(@x, @y) AS [COALESCE];
   

   

   

   Das ISNULLgibt den Datentyp des ersten Arguments zurück, während in COALESCEwir Fehler erhalten, da das INTden höchsten Vorrang hat und die Konvertierung des ersten Argumentwerts in INTfehlschlägt.

4. Die Nullbarkeit des Ergebnisses kann ebenfalls wichtig sein. Zum Beispiel:

   DECLARE @x VARCHAR(3) = NULL
          ,@y VARCHAR(3) = NULL;
   
   DROP TABLE IF EXISTS [dbo].[DataSource01];
   
   SELECT ISNULL(10, 20) AS [C1]
         ,ISNULL(@x, 'text') AS [C2]
         ,ISNULL(@x, @y) AS [C3]
   INTO [dbo].[DataSource01];
   
   DROP TABLE IF EXISTS [dbo].[DataSource02];
   
   SELECT COALESCE(10, 20) AS [C1]
         ,COALESCE(@x, 'text') AS [C2]
         ,COALESCE(@x, @y) AS [C3]
   INTO [dbo].[DataSource02];
   

   Lassen Sie uns die NullableEigenschaft jeder Spalte überprüfen :

   

   

   Mit haben COALESCEwir eine NOT NULLEigenschaft der Spalte auf gesetzt Yes, nur wenn alle Eingaben nicht nullfähig sind.

5. Gemäß dem SQL-Standard wird der COALESCEAusdruck übersetzt in:

   CASE WHEN (<subquery>) IS NOT NULL THEN (<subquery>) ELSE 0 END
   

   Wenn das Ergebnis der Ausführung der Unterabfrage in der WHEN-Klausel nicht NULL ist, führt SQL Server sie in der THEN-Klausel ein zweites Mal aus. Mit anderen Worten, in einem solchen Fall wird es zweimal ausgeführt. Nur wenn das Ergebnis der Ausführung in der WHEN-Klausel NULL ist, führt SQL Server die Unterabfrage nicht erneut aus, sondern gibt den ELSE-Ausdruck zurück. Bei Verwendung von Unterabfragen hat die ISNULL-Funktion einen Leistungsvorteil.

Wenn es nur eine Nullbedingung gibt, ISNULLhat dies weniger Overhead. Der Unterschied ist jedoch wahrscheinlich vernachlässigbar.

Diese Erklärung gibt deutlich über Koaleszenz gegen Isnull

Die COALESCE-Funktion in SQL gibt den ersten Nicht-NULL-Ausdruck unter ihren Argumenten zurück. Die Syntax für COALESCE lautet wie folgt:

 COALESCE ("expression 1", "expressions 2", ...)

Dies entspricht der folgenden CASE-Anweisung:

SELECT CASE ("column_name")
  WHEN "expression 1 is not NULL" THEN "expression 1"
  WHEN "expression 2 is not NULL" THEN "expression 2"
  ...
  [ELSE "NULL"]
  END
FROM "table_name";

In SQL Server wird die Funktion ISNULL () verwendet, um den NULL-Wert durch einen anderen Wert zu ersetzen.

select CountryName = ISNULL("columnname", 'INDIA') from Countries

Coalesce gibt den ersten Nicht-Null-Ausdruck zurück, wobei asnull () verwendet wird, um den Nullwert durch unseren gewünschten Wert zu ersetzen.

COALESCE ist Teil der ANSI-Standards und in fast allen Datenbanken verfügbar.

Bei der Entscheidung zwischen ISNULL und COALESCE müssen die folgenden Parameter berücksichtigt werden:

1. COALESCE bestimmt den Typ der Ausgabe basierend auf der Priorität des Datentyps, wobei wie bei ISNULL der Datentyp nicht durch die Priorität des Datentyps beeinflusst wird.

2. Betrachten Sie die folgenden SQL-Anweisungen

   DECLARE @c5 VARCHAR(5);
   SELECT 'COALESCE', COALESCE(@c5, 'longer name')
   UNION ALL
   SELECT 'ISNULL',   ISNULL(@c5,   'longer name');
   

Ergebnisse:

COALESCE longer name
ISNULL   longe

Dies liegt daran, dass ISNULL den Datentyp des ersten Arguments verwendet, während COALESCE alle Elemente überprüft und die beste Anpassung auswählt (in diesem Fall VARCHAR (11)).

Weitere Informationen zur Entscheidung zwischen COALESCE und ISNULL finden Sie unter: https://www.mssqltips.com/sqlservertip/2689/deciding-between-coalesce-and-isnull-in-sql-server/

In COALESCE kann man mehrere Ausdrücke verwenden. Es wird ein Wert zurückgegeben, der keine Null ist und zuerst auftritt ... zum Beispiel

DECLARE @Value1 INT, @Value2 INT, @Value3 INT, @Value4 INT
SELECT @Value2 = 2, @Value4 = 4
SELECT COALESCE(@Value1, @Value2, @Value3, @Value4)
SELECT COALESCE(@Value1, @Value4, @Value3, @Value2)

Und in ISNULL gibt der Ausdruck null den zweiten angegebenen Parameter zurück, und Sie können natürlich nur nach einem Ausdruck suchen ...

Wenn Sie also mehrere Ausdrücke überprüfen und zuerst nicht null unter ihnen auswählen möchten, verwenden Sie coalesce, andernfalls wählen Sie ISNULL