Redshift CASE WHEN : Conditionnels SQL

Introduction

Lors de l’utilisation de l’entrepôt de données Amazon Redshift, vous devrez peut-être utiliser une logique conditionnelle pour interroger et transformer vos données. L’expression ‘CASE WHEN’ aide à évaluer les conditions et à retourner différents résultats selon si les conditions sont vraies ou fausses.

Dans cet article, nous aborderons les bases de l’utilisation des expressions ‘CASE WHEN’ en Redshift SQL. Nous couvrirons également l’instruction ELSE lors de la discussion. Vous apprendrez la syntaxe, verrez des exemples et comprendrez des cas d’utilisation courants. À la fin, vous serez en mesure de tirer parti de cette logique conditionnelle essentielle SQL dans vos propres requêtes Redshift.

Syntaxe CASE WHEN

La syntaxe générale d’une expression CASE WHEN en Redshift est :

CASE
WHEN condition1 THEN result1
WHEN condition2 THEN result2
...
ELSE default_result
END

Voici comment cela fonctionne :

• Le mot-clé CASE signale le début de l’expression conditionnelle
• Vous spécifiez une ou plusieurs clauses WHEN qui contiennent chacune une condition à évaluer
• Pour la première condition qui s’avère vraie, le résultat THEN correspondant est retourné
• Si aucune des conditions n’est vraie, le resultat par défaut ELSE est retourné
• Le mot-clé END signale la fin de l’expression CASE

Examinons un exemple simple pour illustrer. Imaginez une table “users” avec des colonnes pour id, name et age. Pour classer les utilisateurs comme ‘enfant’, ‘adulte’ ou ‘senior’ en fonction de l’âge, vous pourriez utiliser :

SELECT id, name,
CASE
WHEN age < 18 THEN 'enfant'
WHEN age < 65 THEN 'adulte'
ELSE 'senior'
END AS age_category
FROM users;

Cela évaluerait chaque ligne, vérifierait l’âge de l’utilisateur et retournerait la catégorie d’âge correspondante.

Créer des Données d’Exemple

Pour démontrer des exemples plus complexes de CASE WHEN, créons d’abord quelques données d’exemple avec lesquelles travailler. Exécutez la requête SQL suivante dans Redshift pour créer une table “orders” :

CREATE TABLE orders (
order_id INT,
customer_id INT,
order_date DATE,
total DECIMAL(10,2),
status VARCHAR(20)
);
INSERT INTO ordre
VALUES
(1, 101, '2023-01-15', 150.00, 'terminé'),
(2, 102, '2023-02-10', 75.50, 'en attente'),
(3, 101, '2023-03-01', 200.00, 'terminé'),
(4, 103, '2023-03-05', 120.00, 'annulé'),
(5, 102, '2023-04-12', 300.00, 'terminé');

Cette simple expression case crée une table de commandes avec quelques enregistrements d’exemple sur lesquels nous pouvons maintenant exécuter des expressions CASE.

Utiliser CASE pour Dériver de Nouvelles Colonnes

Les instructions CASE peuvent être utilisées pour créer de nouvelles colonnes dans un ensemble de données en classant les données existantes. Lors de l’organisation des commandes par montant total, une instruction CASE peut définir les règles pour chaque groupe.

Les commandes de moins de 100 $ sont de “faible valeur”. La gamme des commandes entre 100 $ et 500 $ sont de “valeur moyenne”. Les commandes dépassant 500 $ sont de “haute valeur”. Vous pouvez facilement organiser les données dans un ensemble de données en utilisant une instruction CASE, ce qui aide à l’analyse et à la compréhension.

SELECT order_id, customer_id, total,
CASE
WHEN total < 100 THEN 'petit'
WHEN total < 250 THEN 'moyen'
ELSE 'grand'
END AS order_size
FROM orders;

Cela retournerait :

order_id | customer_id | total  | order_size
----------------------------------------------
1        | 101         | 150.00 | moyen
2        | 102         | 75.50  | petit
3        | 101         | 200.00 | moyen
4        | 103         | 120.00 | moyen
5        | 102         | 300.00 | grand

Aggréger avec CASE

Les expressions CASE sont également très utiles dans les fonctions d’agrégation comme SUM() et COUNT(). Par exemple, pour compter le nombre de petites, moyennes et grandes commandes :

SELECT
COUNT(CASE WHEN total < 100 THEN 1 END) AS small_orders,
COUNT(CASE WHEN total >= 100 AND total < 250 THEN 1 END) AS medium_orders,
COUNT(CASE WHEN total >= 250 THEN 1 END) AS large_orders
FROM orders;

Cela retournerait :

small_orders | medium_orders | large_orders
--------------------------------------------
1            | 3             | 1

Dans chaque COUNT(), le CASE retourne 1 lorsque la condition est remplie, que le COUNT() additionne ensuite.

CASE dans les Clauses WHERE et HAVING

Vous pouvez également utiliser des expressions CASE dans les clauses WHERE et HAVING pour filtrer les résultats en fonction d’une logique conditionnelle. Par exemple, pour trouver tous les clients qui ont passé une ‘grande’ commande :

SELECT DISTINCT customer_id
FROM orders
WHERE
CASE
WHEN total >= 250 THEN 'grande'
ELSE 'pas grande'
END = 'grande';

Cela retournerait le client 102, car il est le seul à avoir passé une commande ‘grande’ de plus de 250 $.

Gérer les Valeurs NULL

Les expressions CASE sont également utiles pour gérer les valeurs NULL. Vous pouvez utiliser CASE pour remplacer les NULL par une valeur par défaut, ou pour appliquer une logique différente lorsque une valeur est NULL.

Par exemple, considérons si notre table “orders” avait une colonne “shipped_date” qui pourrait être NULL si la commande n’a pas encore été expédiée. Pour retourner ‘Pas Expédié’ pour ces commandes :

SELECT order_id, status,
CASE
WHEN shipped_date IS NULL THEN 'Pas Expédié'
ELSE CAST(shipped_date AS VARCHAR(10))
END AS shipped
FROM orders;

Cela vérifie si shipped_date EST NULL, et dans ce cas, retourne ‘Pas Expédié’. Sinon, cela convertit shipped_date en chaîne pour retourner. Nous devrions noter ici que l’utilisation de NVL ou COALESCE pourrait être un meilleur choix.

Conseils pour Utiliser CASE WHEN

Voici quelques conseils à garder à l’esprit lorsque vous utilisez des expressions CASE WHEN dans Redshift :

• Les expressions CASE peuvent être imbriquées les unes dans les autres pour une logique plus complexe
• La clause ELSE est facultative, et si omise, NULL sera retourné si aucune condition n’est remplie
• Les expressions CASE peuvent être utilisées presque partout dans une instruction SQL, y compris SELECT, WHERE, HAVING, GROUP BY et ORDER BY
• Faites attention aux types de données – les résultats d’une expression CASE doivent tous être convertibles en un type de donnée commun

Résumé

L’expression CASE WHEN est un outil polyvalent pour appliquer une logique conditionnelle dans les requêtes Redshift SQL. Vous pouvez l’utiliser pour dériver de nouvelles colonnes, agréger des données, filtrer des résultats, gérer des NULL, et bien plus encore.

En comprenant la syntaxe et les cas d’utilisation courants, vous serez en mesure d’écrire des SQL plus puissants et efficaces pour analyser vos données dans Redshift.

DataSunrise propose des outils conviviaux et flexibles pour la sécurité des bases de données, l’audit et la conformité qui s’intègrent parfaitement avec Amazon Redshift. Visitez le site web de DataSunrise pour demander une démo en ligne auprès de notre équipe d’experts.

Visitez le site web de DataSunrise pour demander une démo en ligne auprès de notre équipe d’experts.