SQL NULLIF() explicado

La mayoría de los principales RDBMS admiten NULLIF() operador, que devuelve NULL si sus dos argumentos son equivalentes. Si los argumentos no son equivalentes, NULLIF() devuelve el primer argumento.

NULLIF() es una característica estándar de SQL (está incluida en la especificación ISO/IEC 9075).

Sintaxis

La sintaxis es así:

NULLIF (V1, V2)

Esto es equivalente al siguiente CASE expresión:

CASE WHEN V1=V2 THEN NULL ELSE V1 END

Ejemplo

Aquí hay un ejemplo para demostrarlo:

SELECT NULLIF( 12, 12 );

Resultado:

NULL

En este caso, ambos argumentos son idénticos y el resultado es NULL .

Dependiendo de su RDBMS, la salida real para valores NULL puede ser diferente. Por ejemplo, cuando se usa psql (para PostgreSQL), la cadena vacía se genera de forma predeterminada cada vez que se devuelve un valor NULL (aunque esto se puede cambiar). Es lo mismo con SQLite (y esto también se puede cambiar).

Cuando los argumentos no son equivalentes

Esto es lo que sucede cuando los argumentos no son equivalentes:

SELECT NULLIF( 12, 13 );

Resultado:

12

Los argumentos son diferentes, por lo que se devuelve el primer argumento.

Cuerdas

Aquí hay un ejemplo que compara cadenas:

SELECT 
    NULLIF( 'Gym', 'Gym' ) AS "Same",
    NULLIF( 'Gym', 'Bag' ) AS "Different";

Resultado:

+------+-----------+
| Same | Different |
+------+-----------+
| NULL | Gym       |
+------+-----------+

Fechas

Aquí hay un ejemplo que compara fechas:

SELECT 
    NULLIF( DATE '2045-11-25', DATE '2045-11-25' ) AS "Same",
    NULLIF( DATE '2045-11-25', DATE '1990-08-15' ) AS "Different";

Resultado:

+------+------------+
| Same | Different  |
+------+------------+
| NULL | 2045-11-25 |
+------+------------+

Expresiones

NULLIF() evalúa el valor actual de las expresiones. Por lo tanto, si pasamos una expresión como esta:

SELECT NULLIF( 24, 2 * 12 );

Obtenemos esto:

NULL

2 multiplicado por 12 es 24, por lo que los dos argumentos son equivalentes.

Esto es lo que sucede si cambiamos el segundo argumento:

SELECT NULLIF( 24, 3 * 12 );

Resultado:

24

Se devuelve el primer argumento.

Un ejemplo de base de datos

Supongamos que ejecutamos la siguiente consulta:

SELECT 
    Name,
    LocalName
FROM country 
WHERE Region = 'South America'
ORDER BY Name;

Resultado:

+------------------+-------------------+
| Name             | LocalName         |
+------------------+-------------------+
| Argentina        | Argentina         |
| Bolivia          | Bolivia           |
| Brazil           | Brasil            |
| Chile            | Chile             |
| Colombia         | Colombia          |
| Ecuador          | Ecuador           |
| Falkland Islands | Falkland Islands  |
| French Guiana    | Guyane française  |
| Guyana           | Guyana            |
| Paraguay         | Paraguay          |
| Peru             | Perú/Piruw        |
| Suriname         | Suriname          |
| Uruguay          | Uruguay           |
| Venezuela        | Venezuela         |
+------------------+-------------------+

Aquí tenemos los nombres de los países en la columna de la izquierda y el nombre local del país respectivo en la derecha.

Agreguemos NULLIF() a una tercera columna de nuestra consulta:

SELECT
    Name,
    LocalName,
    NULLIF(LocalName, Name) AS "Local Name if Different"
FROM country 
WHERE Region = 'South America'
ORDER BY Name;

Resultado:

+------------------+-------------------+-------------------------+
| Name             | LocalName         | Local Name if Different |
+------------------+-------------------+-------------------------+
| Argentina        | Argentina         | NULL                    |
| Bolivia          | Bolivia           | NULL                    |
| Brazil           | Brasil            | Brasil                  |
| Chile            | Chile             | NULL                    |
| Colombia         | Colombia          | NULL                    |
| Ecuador          | Ecuador           | NULL                    |
| Falkland Islands | Falkland Islands  | NULL                    |
| French Guiana    | Guyane française  | Guyane française        |
| Guyana           | Guyana            | NULL                    |
| Paraguay         | Paraguay          | NULL                    |
| Peru             | Perú/Piruw        | Perú/Piruw              |
| Suriname         | Suriname          | NULL                    |
| Uruguay          | Uruguay           | NULL                    |
| Venezuela        | Venezuela         | NULL                    |
+------------------+-------------------+-------------------------+

Podemos ver que la tercera columna devuelve el nombre local solo si es diferente al valor en Name columna. Si es lo mismo, entonces NULL es devuelto.

También podemos usar NULLIF() para filtrar los resultados de nuestra consulta:

SELECT 
    Name,
    LocalName
FROM country 
WHERE Region = 'South America'
AND NULLIF(LocalName, Name) IS NOT NULL
ORDER BY Name;

Resultado:

+---------------+-------------------+
| Name          | LocalName         |
+---------------+-------------------+
| Brazil        | Brasil            |
| French Guiana | Guyane française  |
| Peru          | Perú/Piruw        |
+---------------+-------------------+

En este caso, devolvimos solo aquellas filas donde el nombre local es diferente al Name columna.

NULLIF() vs CASE

Como se mencionó, el siguiente código:

NULLIF (V1, V2)

es equivalente al siguiente CASE expresión:

CASE WHEN V1=V2 THEN NULL ELSE V1 END

Entonces es posible usar un CASE expresión en lugar de NULLIF() si así lo desea. El NULLIF() La función es básicamente un atajo sintáctico para CASE expresión.

Entonces, por ejemplo, podríamos reemplazar el ejemplo anterior con el siguiente:

SELECT 
    Name,
    LocalName
FROM country 
WHERE Region = 'South America'
AND (CASE WHEN LocalName = Name THEN NULL ELSE LocalName END) IS NOT NULL
ORDER BY Name;

Resultado:

+---------------+-------------------+
| Name          | LocalName         |
+---------------+-------------------+
| Brazil        | Brasil            |
| French Guiana | Guyane française  |
| Peru          | Perú/Piruw        |
+---------------+-------------------+

Sin embargo, el NULLIF() la función es mucho más concisa.

Recuento de parámetros incorrecto

Pasar el número incorrecto de argumentos da como resultado un error:

SELECT NULLIF( 'One' );

Resultado en MySQL:

ERROR 1582 (42000): Incorrect parameter count in the call to native function 'NULLIF'