La fonction NULLIF() — syntaxe et exemples d'utilisation

Allez, on va parler d'une autre fonction pour bosser avec ce fameux NULL — NULLIF(). Elle va grave t'aider dans les situations où tu veux remplacer certaines valeurs par NULL pour mieux gérer tes données. Accroche-toi, ça va être un petit voyage sympa !

La fonction NULLIF(), c'est un super outil dans PostgreSQL qui te permet de comparer deux valeurs et de renvoyer NULL si elles sont identiques, ou de renvoyer la première valeur si elles sont différentes. C'est un peu comme si elle disait : "Si ces deux valeurs sont pareilles, on les oublie !"

Voilà la syntaxe toute simple de la fonction :

NULLIF(value1, value2)

Si value1 et value2 sont égaux, le résultat sera NULL. S'ils sont différents, le résultat sera value1.

Exemple :

SELECT NULLIF(10, 10); -- Résultat : NULL
SELECT NULLIF(10, 20); -- Résultat : 10
SELECT NULLIF('hello', 'hello'); -- Résultat : NULL
SELECT NULLIF('hello', 'world'); -- Résultat : 'hello'

Facile, non ? Maintenant, voyons comment utiliser cette fonction dans des cas concrets.

Exemple 1 : Éviter la division par zéro

La division par zéro, c'est le cauchemar de tout dev. En SQL, si tu tentes de diviser par zéro, tu te prends une erreur. C'est là que NULLIF() débarque pour te sauver.

Imagine : on a une table sales avec deux colonnes : revenue (revenus) et expenses (dépenses). On veut calculer la rentabilité (revenue / expenses), mais parfois les dépenses sont à zéro. Si tu fais la requête sans vérifier, tu vas te prendre une erreur de division par zéro.

Table sales :

Requête qui plante :

SELECT revenue / expenses AS profitability
FROM sales;
-- Erreur : division par zéro !

La solution avec NULLIF() :

SELECT revenue / NULLIF(expenses, 0) AS profitability
FROM sales;

Résultat :

Maintenant, si expenses vaut 0, NULLIF(expenses, 0) renvoie NULL, et la division par NULL ne fait pas planter la requête, ça renvoie juste NULL.

Exemple 2 : Remplacer les valeurs identiques par NULL

Imagine que t'as une table avec des infos sur les étudiants, avec les colonnes first_name et preferred_name. Parfois les étudiants préfèrent leur vrai prénom, parfois ils en choisissent un autre. Si les deux prénoms sont identiques, ça sert à rien d'afficher preferred_name.

Table students :

Requête avec NULLIF() :

SELECT first_name,
       NULLIF(preferred_name, first_name) AS display_name
FROM students;

Résultat :

Quand preferred_name et first_name sont égaux, le résultat c'est NULL.

Exemple 3 : Filtrer les données

Parfois tu veux juste les lignes où les valeurs de deux colonnes sont différentes. Par exemple, t'as une table de commandes avec original_price et discounted_price. On veut trouver les commandes où une remise a été appliquée.

Table orders :

Requête avec NULLIF() :

SELECT order_id, original_price, discounted_price
FROM orders
WHERE NULLIF(original_price, discounted_price) IS NOT NULL;

Résultat :

Seules les commandes avec une remise apparaissent dans le résultat.

Cas pratiques d'utilisation de NULLIF()

Cas 1 : Choisir une valeur optionnelle

Quand tu bosses avec des données, parfois tu veux prendre la valeur d'une colonne, sauf si elle vaut un certain truc. Par exemple, t'as une liste d'employés avec leur salaire : base_salary et bonus. Si le bonus vaut 0, on veut le remplacer par 999.

Table employees :

Requête avec NULLIF() :

SELECT employee_id,
       base_salary + COALESCE(NULLIF(bonus, 0), 999) AS total_salary
FROM employees;

Résultat :

Si bonus vaut 0, il sera remplacé par 999.

Cas 2 : Compter les lignes

On peut utiliser NULLIF() pour simplifier des conditions de filtrage un peu reloues. Par exemple, t'as une table users et tu veux, en une seule requête, savoir combien il y a d'utilisateurs au total et combien sont enregistrés (pas en statut guest).

SELECT
  COUNT(*) AS total_users,
  COUNT(NULLIF(status, 'guest')) AS registered_users
FROM users;

Voilà, avec juste une fonction NULLIF() tu peux régler plein de trucs : éviter les erreurs, rendre ton code plus lisible, etc. Maintenant que tu sais comment ça marche, t'es déjà un peu plus proche du niveau boss pour manipuler les données dans PostgreSQL.