Sous-requêtes utilisant COUNT dans SQL et leurs exemples pratiques

La fonction COUNT dans SQL est une fonction de base utilisée pour agréger le nombre d’enregistrements dans une base de données. Cette fonction est très utile pour compter les enregistrements en fonction de conditions spécifiques ou pour agréger par groupe. Dans cet article, nous détaillerons comment exécuter des requêtes de base de données plus avancées en combinant la fonction COUNT et les sous-requêtes. En intégrant des exemples pratiques, nous apprendrons à agréger et analyser les données de manière efficace.

Qu’est-ce que la fonction COUNT ?

La fonction COUNT est une fonction d’agrégation dans SQL qui compte le nombre de colonnes spécifiées ou tous les enregistrements. Par exemple, elle est utilisée pour compter le nombre d’enregistrements dans une table spécifique ou le nombre d’enregistrements qui répondent à certaines conditions.

Utilisation de base

La fonction COUNT peut être utilisée sur une table entière ou une colonne spécifique. La syntaxe de base est la suivante :

SELECT COUNT(*) FROM table_name;

Ou, pour compter une colonne spécifique :

SELECT COUNT(column_name) FROM table_name;

Gestion des valeurs NULL

Lorsqu’un nom de colonne est spécifié, la fonction COUNT exclut les valeurs NULL. En revanche, l’utilisation de COUNT(*) compte tous les enregistrements, y compris ceux avec des valeurs NULL. Voici un exemple :

SELECT COUNT(column_name) FROM table_name;  -- Compte en excluant les NULL
SELECT COUNT(*) FROM table_name;             -- Compte tous les enregistrements, y compris les NULL

La fonction COUNT est un outil essentiel pour l’agrégation et l’analyse de base dans une base de données. Ensuite, passons aux sous-requêtes.

Bases des sous-requêtes

Une sous-requête désigne une requête contenue dans une autre requête SQL. Les sous-requêtes sont souvent utilisées comme conditions dans la requête principale, simplifiant l’expression de manipulations de données complexes.

Syntaxe de base des sous-requêtes

Les sous-requêtes peuvent être utilisées à divers endroits tels que l’instruction SELECT, la clause WHERE, la clause FROM, etc. La syntaxe de base est la suivante :

SELECT column_name
FROM table_name
WHERE column_name IN (SELECT column_name FROM another_table WHERE condition);

Dans cette syntaxe, la sous-requête est utilisée comme condition dans la clause WHERE.

Types de sous-requêtes

Il existe principalement deux types de sous-requêtes :

Sous-requêtes scalaires

Les sous-requêtes scalaires renvoient une seule valeur (valeur scalaire). Elles sont utilisées dans l’instruction SELECT ou comme condition dans la clause WHERE. Exemple :

SELECT column_name,
       (SELECT COUNT(*) FROM another_table WHERE condition) AS alias
FROM table_name;

Sous-requêtes à valeurs multiples

Les sous-requêtes à valeurs multiples renvoient plusieurs valeurs (lignes). Elles sont utilisées avec des conditions telles que IN ou EXISTS. Exemple :

SELECT column_name
FROM table_name
WHERE column_name IN (SELECT column_name FROM another_table WHERE condition);

En utilisant des sous-requêtes, les requêtes complexes peuvent être décrites plus concisément. Ensuite, examinons des exemples spécifiques de sous-requêtes utilisant la fonction COUNT.

Exemples de sous-requêtes utilisant COUNT

En utilisant la fonction COUNT comme sous-requête, vous pouvez agréger des données en fonction de conditions spécifiques. Ici, nous expliquerons comment implémenter des sous-requêtes utilisant COUNT avec des exemples de requêtes SQL réelles.

Exemple 1 : Compter le nombre de produits dans chaque catégorie

Par exemple, si vous avez une table de produits et une table de catégories, la requête pour compter le nombre de produits dans chaque catégorie est la suivante :

SELECT category_name,
       (SELECT COUNT(*)
        FROM products
        WHERE products.category_id = categories.category_id) AS product_count
FROM categories;

Dans cette requête, pour chaque catégorie, la sous-requête compte le nombre de produits appartenant à cette catégorie.

Exemple 2 : Récupérer le nombre de ventes pour le magasin ayant les ventes les plus élevées

Ensuite, nous montrerons un exemple de comptage du nombre de ventes pour chaque magasin et de récupération du magasin ayant les ventes les plus élevées :

Ensuite, nous montrerons un exemple de comptage du nombre de ventes pour chaque magasin et de récupération du magasin ayant les ventes les plus élevées :

SELECT store_id, sales_count
FROM (SELECT store_id,
             COUNT(*) AS sales_count
      FROM sales
      GROUP BY store_id) AS store_sales
ORDER BY sales_count DESC
LIMIT 1;

Dans cette requête, la sous-requête compte d’abord le nombre de ventes pour chaque magasin. La requête principale trie ensuite les résultats par nombre de ventes dans l’ordre décroissant et récupère le magasin en tête.

Exemple 3 : Compter le nombre d’utilisateurs qui répondent à des conditions spécifiques

Enfin, nous montrerons un exemple de comptage du nombre d’utilisateurs répondant à des conditions spécifiques (par exemple, les utilisateurs ayant passé des commandes dans une certaine période) :

SELECT COUNT(*)
FROM (SELECT user_id
      FROM orders
      WHERE order_date BETWEEN '2023-01-01' AND '2023-12-31'
      GROUP BY user_id) AS yearly_orders;

Dans cette requête, la sous-requête regroupe les utilisateurs ayant passé des commandes dans une période spécifique, et la requête principale compte ce nombre.

Comme vous pouvez le voir à partir de ces exemples, l’utilisation des sous-requêtes avec COUNT permet d’agréger des données complexes de manière efficace. Ensuite, passons à des exemples pratiques de comptage du nombre de commandes par utilisateur.

Exemple pratique : Compter le nombre de commandes par utilisateur

À titre d’exemple pratique pour les entreprises, nous allons introduire comment compter le nombre de commandes par utilisateur. Dans cet exemple, nous utiliserons les tables users et orders pour compter le nombre de commandes passées par chaque utilisateur.

Structure des tables

Tout d’abord, la structure des tables users et orders est la suivante :

-- table users
CREATE TABLE users (
    user_id INT PRIMARY KEY,
    user_name VARCHAR(255)
);

-- table orders
CREATE TABLE orders (
    order_id INT PRIMARY KEY,
    user_id INT,
    order_date DATE,
    FOREIGN KEY (user_id) REFERENCES users(user_id)
);

Requête pour compter le nombre de commandes par utilisateur

La requête pour compter le nombre de commandes par utilisateur est la suivante :

SELECT user_name,
       (SELECT COUNT(*)
        FROM orders
        WHERE orders.user_id = users.user_id) AS order_count
FROM users;

Cette requête effectue les opérations suivantes :

1. Récupérer les noms d’utilisateur de la table users.
2. Utiliser une sous-requête pour compter le nombre de commandes de la table orders pour l’utilisateur correspondant.
3. Afficher le résultat sous la forme order_count.

Exemple de résultats d’exécution

Par exemple, supposons les données suivantes dans la table users et les données de commandes dans la table orders :

-- Données dans la table users
INSERT INTO users (user_id, user_name) VALUES
(1, 'Alice'),
(2, 'Bob'),
(3, 'Charlie');

-- Données dans la table orders
INSERT INTO orders (order_id, user_id, order_date) VALUES
(1, 1, '2023-01-01'),
(2, 1, '2023-02-15'),
(3, 2, '2023-03-10'),
(4, 3, '2023-04-20'),
(5, 3, '2023-05-25'),
(6, 3, '2023-06-30');

Exécuter la requête ci-dessus donne les résultats suivants :

user_name   | order_count
------------|-------------
Alice       | 2
Bob         | 1
Charlie     | 3

D’après ce résultat, nous pouvons voir qu’Alice a passé 2 commandes, Bob a passé 1 commande et Charlie a passé 3 commandes.

En utilisant des sous-requêtes avec COUNT de cette manière, vous pouvez facilement agréger des décomptes détaillés de commandes par utilisateur. Ensuite, passons aux méthodes d’agrégation des données en fonction de conditions spécifiques.

Exemple pratique : Agrégation basée sur des conditions spécifiques

Ensuite, nous introduirons une méthode pour agréger des données en fonction de conditions spécifiques. Ici, nous montrerons un exemple d’agrégation du nombre de commandes passées dans une période spécifique.

Requête pour compter le nombre de commandes dans une période

La requête pour compter le nombre de commandes passées dans une période spécifique est la suivante :

SELECT user_name,
       (SELECT COUNT(*)
        FROM orders
        WHERE orders.user_id = users.user_id
        AND order_date BETWEEN '2023-01-01' AND '2023-12-31') AS order_count
FROM users;

Cette requête effectue les opérations suivantes :

1. Récupérer les noms d’utilisateur de la table users.
2. Utiliser une sous-requête pour compter le nombre de commandes de la table orders pour l’utilisateur correspondant, limité à la période spécifiée.
3. Afficher le résultat sous la forme order_count.

Exemple de résultats d’exécution

Par exemple, supposons les données suivantes dans la table users et la table orders :

-- Données dans la table users
INSERT INTO users (user_id, user_name) VALUES
(1, 'Alice'),
(2, 'Bob'),
(3, 'Charlie');

-- Données dans la table orders
INSERT INTO orders (order_id, user_id, order_date) VALUES
(1, 1, '2023-01-01'),
(2, 1, '2023-02-15'),
(3, 2, '2023-03-10'),
(4, 3, '2023-04-20'),
(5, 3, '2023-05-25'),
(6, 3, '2023-06-30'),
(7, 1, '2022-12-31');  -- Commande hors de la période

Exécuter la requête ci-dessus donne les résultats suivants :

user_name   | order_count
------------|-------------
Alice       | 2
Bob         | 1
Charlie     | 3

D’après ce résultat, nous pouvons voir qu’Alice a passé 2 commandes en 2023, Bob a passé 1 commande et Charlie a passé 3 commandes.

Autres exemples d’utilisation de l’agrégation conditionnelle

Par exemple, si vous souhaitez compter le nombre de commandes pour un produit spécifique, vous pouvez ajouter des conditions supplémentaires :

SELECT product_name,
       (SELECT COUNT(*)
        FROM orders
        WHERE orders.product_id = products.product_id
        AND order_date BETWEEN '2023-01-01' AND '2023-12-31') AS order_count
FROM products;

Dans cette requête, pour chaque produit de la table products, le nombre de commandes passées dans une période spécifique est compté.

En utilisant des sous-requêtes avec COUNT de cette manière, une agrégation flexible des données en fonction de conditions spécifiques est possible. Cela permet d’acquérir efficacement des informations utiles pour la prise de décision commerciale et l’analyse des données. Passons maintenant au résumé de cet article.

Résumé

Les sous-requêtes utilisant la fonction COUNT sont un outil puissant dans SQL. Leur utilisation permet d’exécuter efficacement des agrégations et des analyses de données complexes. En particulier, vous pouvez facilement écrire des requêtes utiles dans le cadre professionnel, telles que le comptage du nombre de commandes par utilisateur ou l’agrégation basée sur des conditions spécifiques.

En comprenant et en utilisant correctement les sous-requêtes, vous pouvez maximiser les informations contenues dans la base de données. Cela permet une analyse de données précise et détaillée pour soutenir la prise de décision commerciale.

À l’avenir, essayez de relever le défi des requêtes plus complexes et combinez-les avec d’autres fonctions d’agrégation pour un traitement des données plus avancé. En perfectionnant vos compétences en SQL, vous pouvez grandement améliorer l’efficacité de la gestion et de l’analyse des bases de données.

Ceci conclut l’explication et les exemples pratiques des sous-requêtes utilisant COUNT dans SQL. Nous espérons que cet article vous aidera dans vos opérations de base de données.