Accueil
Centre de Connaissances
Améliorer les requêtes Redshift avec des expressions CASE WHEN

Améliorer les requêtes Redshift avec des expressions CASE WHEN

Introduction

Lorsque vous utilisez l’entrepôt de données Amazon Redshift, vous pouvez avoir besoin d’utiliser une logique conditionnelle pour interroger et transformer vos données. L’expression ‘CASE WHEN’ aide à évaluer les conditions et à renvoyer des résultats différents selon que les conditions sont vraies ou fausses.

Dans cet article, nous allons plonger dans les bases de l’utilisation des expressions ‘CASE WHEN’ dans Redshift SQL. Nous aborderons également l’instruction ELSE au cours de la discussion. Vous apprendrez la syntaxe, verrez des exemples et comprendrez les cas d’utilisation courants. À la fin, vous serez équipé pour exploiter cette logique conditionnelle SQL essentielle dans vos propres requêtes Redshift.

Syntaxe CASE WHEN

La syntaxe générale pour une expression CASE WHEN dans 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 contenant chacune une condition à évaluer
Pour la première condition qui s’avère vraie, le résultat THEN correspondant est renvoyé
Si aucune des conditions n’est vraie, le défaut de ELSE default_result est renvoyé
Le mot-clé END signale la fin de l’expression CASE

Jetons un coup d’œil à un simple exemple pour illustrer. Imaginez une table “utilisateurs” avec des colonnes pour id, nom et âge. Pour catégoriser les utilisateurs comme ‘enfant’, ‘adulte’ ou ‘sénior’ en fonction de l’âge, vous pourriez utiliser :

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

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

Création de données d’exemple

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

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

Cette expression simple 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 catégorisant 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 “Low Value”. La plage des commandes entre 100 $ et 500 $ est “Medium Value”. Les commandes supérieures à 500 $ sont “High Value”. Vous pouvez facilement catégoriser les données d’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 'small'
WHEN total < 250 THEN 'medium'
ELSE 'large'
END AS order_size
FROM orders;

Cela renverrait :

order_id | customer_id | total  | order_size
----------------------------------------------
1        | 101         | 150.00 | medium
2        | 102         | 75.50  | small
3        | 101         | 200.00 | medium
4        | 103         | 120.00 | medium
5        | 102         | 300.00 | large

Aggregate 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 renverrait :

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

Dans chaque COUNT(), le CASE renvoie 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 de la 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 'large'
ELSE 'not large'
END = 'large';

Cela renverrait le client 102, car c’est le seul avec une ‘grande’ commande 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 lorsqu’une valeur est NULL.

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

SELECT order_id, status,
CASE
WHEN shipped_date IS NULL THEN 'Not Shipped'
ELSE CAST(shipped_date AS VARCHAR(10))
END AS shipped
FROM orders;

Cela vérifie si shipped_date IS NULL, et si oui, renvoie ‘Not Shipped’. Sinon, il convertit shipped_date en chaîne pour le renvoyer. Nous devons noter ici que l’utilisation de NVL ou COALESCE peut être un meilleur choix.

Conseils pour l’utilisation de CASE WHEN

Voici quelques conseils à garder à l’esprit lors de l’utilisation d’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 optionnelle et, si elle est omise, NULL sera renvoyé si aucune condition ne correspond
Les expressions CASE peuvent être utilisées presque partout dans une instruction SQL, y compris les clauses 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ées commun

Résumé

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

En comprenant la syntaxe et les cas d’utilisation courants, vous serez en mesure d’écrire du SQL plus puissant et efficace 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émonstration en ligne de notre équipe d’experts.

Visitez le site Web de DataSunrise pour demander une démonstration en ligne de notre équipe d’experts.