Décrit l'utilisation d'opérateurs arithmétiques et la construction de colonnes calculées. Les fonctions récapitulatives (agrégées) COUNT, SUM, AVG, MAX, MIN sont prises en compte. Un exemple d'utilisation de la clause GROUP BY pour le regroupement dans les requêtes de sélection de données est donné. Décrit l'utilisation de la clause HAVING.

Création de champs calculés

En général, pour créer champ calculé (dérivé) une expression doit être spécifiée dans la liste SELECT langage SQL... Ces expressions utilisent l'arithmétique d'addition, de soustraction, de multiplication et de division et les fonctions SQL intégrées. Vous pouvez spécifier le nom de n'importe quelle colonne (champ) d'une table ou d'une requête, mais n'utilisez que le nom de colonne de cette table ou requête qui est répertorié dans la clause FROM de l'instruction correspondante. Lors de la création d'expressions complexes, des parenthèses peuvent être nécessaires.

Les normes SQL vous permettent de spécifier explicitement les noms de colonnes de la table de résultats à l'aide de la clause AS.

SELECT Product.Name, Product.Price, Deal.Quantity, Product.Price * Deal.Quantity AS Cost FROM Product INNER JOIN Deal ON Product.Product Code = Deal.Product Code Exemple 6.1. Calcul du coût total de chaque transaction.

Exemple 6.2. Obtenez une liste d'entreprises avec les noms et les initiales des clients.

SELECT Entreprise, Nom + "" + Gauche (Prénom, 1) + "." + Gauche (Deuxième prénom, 1) + "." AS Nom complet FROM Client Exemple 6.2. Obtention d'une liste d'entreprises avec l'indication du nom et des initiales des clients.

La requête utilise la fonction intégrée Left, qui vous permet de couper un caractère à partir de la gauche dans une variable de texte dans ce cas.

Exemple 6.3. Obtenez une liste de produits avec l'année et le mois de vente.

SELECT Item.Name, Year (Deal.Date) AS Year, Month (Deal.Date) AS Month FROM Item INNER JOIN Deal ON Item.Product Code = Deal.Product Code Exemple 6.3. Recevoir une liste de produits indiquant l'année et le mois de vente.

La requête utilise les fonctions intégrées Year et Month pour extraire l'année et le mois d'une date.

Utilisation des fonctions récapitulatives

En utilisant fonctions de résumé (agrégat) dans le cadre d'une requête SQL, vous pouvez obtenir un certain nombre de statistiques récapitulatives sur l'ensemble des valeurs sélectionnées de l'ensemble de sortie.

Les principaux suivants sont à la disposition de l'utilisateur. fonctions récapitulatives:

• Count (Expression) - détermine le nombre d'enregistrements dans l'ensemble de sortie de la requête SQL ;
• Min / Max (Expression) - détermine le plus petit et le plus grand de l'ensemble de valeurs dans un certain champ de la demande ;
• Avg (Expression) - Cette fonction vous permet de calculer la moyenne d'un ensemble de valeurs stockées dans un champ spécifique d'enregistrements sélectionnés par requête. C'est la moyenne arithmétique, c'est-à-dire la somme des valeurs divisée par leur nombre.
• Somme (expression) - calcule la somme de l'ensemble de valeurs contenues dans un champ spécifique des enregistrements sélectionnés par la requête.

Les noms de colonnes sont le plus souvent utilisés comme expressions. L'expression peut également être calculée à l'aide des valeurs de plusieurs tables.

Toutes ces fonctions opèrent sur des valeurs dans une seule colonne d'un tableau ou avec une expression arithmétique et renvoient une seule valeur. Les fonctions COUNT, MIN et MAX s'appliquent aux champs numériques et non numériques, tandis que les fonctions SUM et AVG ne peuvent être utilisées que dans le cas des champs numériques, à l'exception de COUNT (*). Lors du calcul des résultats de toutes les fonctions, toutes les valeurs vides sont d'abord exclues, après quoi l'opération requise est appliquée uniquement aux valeurs de colonne spécifiques restantes. La variante COUNT (*) est un cas particulier d'utilisation de la fonction COUNT, son objectif est de compter toutes les lignes de la table résultante, qu'elle contienne des valeurs vides, en double ou toute autre valeur.

Si vous devez éliminer les valeurs en double avant d'utiliser la fonction générique, vous devez faire précéder le nom de la colonne dans la définition de la fonction avec mot-clé DISTINCT. Cela n'a pas de sens pour les fonctions MIN et MAX, cependant, son utilisation peut affecter les résultats de l'exécution. Fonctions SOMME et AVG, vous devez donc déterminer à l'avance s'il doit être présent dans chaque cas. De plus, le mot clé DISTINCT peut être spécifié au plus une fois dans n'importe quelle requête.

Il est très important de noter que fonctions récapitulatives ne peut être utilisé que dans la liste clauses SELECT et dans le cadre de la clause HAVING. Dans tous les autres cas, c'est inacceptable. Si la liste de la clause SELECT contient fonctions récapitulatives, et que le texte de la requête ne contient pas la clause GROUP BY, qui garantit la combinaison des données en groupes, alors aucun des éléments de la liste de la clause SELECT ne peut inclure de références à des champs, sauf dans le cas où les champs agissent comme arguments fonctions récapitulatives.

Exemple 6.4. Déterminez le premier nom alphabétique du produit.

SELECT Min (Nom de l'article) AS Min_Name FROM Article Exemple 6.4. Détermination du premier nom alphabétique du produit.

Exemple 6.5. Déterminez le nombre de transactions.

SELECT Nombre (*) AS Nombre_ de transactions FROM Transaction Exemple 6.5. Déterminez le nombre de transactions.

Exemple 6.6. Déterminez le montant total des marchandises vendues.

SELECT Sum (Deal.Quantity) AS Item_Quantity FROM Deal Exemple 6.6. Détermination du montant total des marchandises vendues.

Exemple 6.7. Déterminer le prix moyen des marchandises vendues.

SELECT Avg (Item.Price) AS Avg_Price FROM Item INNER JOIN Deal ON Item.Product Code = Deal.Product Code; Exemple 6.7. Détermination du prix moyen des marchandises vendues.

SELECT Sum (Item.Price * Deal.Quantity) AS Cost FROM Item INNER JOIN Deal ON Item.Product Code = Deal.Product Code Exemple 6.8. Calcul du coût total des marchandises vendues.

Clause GROUP BY

Les requêtes nécessitent souvent des sous-totaux, ce qui est généralement indiqué par l'apparition de la phrase "pour chaque..." dans la requête. La clause GROUP BY est utilisée à cette fin dans l'instruction SELECT. Une requête qui contient un GROUP BY est appelée requête de regroupement car elle regroupe les données résultant d'une opération SELECT, puis crée une seule ligne récapitulative pour chaque groupe individuel. Le standard SQL requiert que la clause SELECT et la clause GROUP BY soient étroitement liées. Avec une clause GROUP BY dans une instruction SELECT, chaque élément de liste dans la clause SELECT doit avoir une valeur unique pour l'ensemble du groupe. De plus, la clause SELECT ne peut inclure que les types d'éléments suivants : noms de champs, fonctions récapitulatives, des constantes et des expressions qui incluent des combinaisons des éléments ci-dessus.

Tous les noms de champs répertoriés dans la clause SELECT doivent apparaître dans la clause GROUP BY, sauf si le nom de colonne est utilisé dans fonction finale... L'inverse n'est pas vrai — la clause GROUP BY peut contenir des noms de colonnes qui ne sont pas répertoriés dans la clause SELECT.

Si une clause WHERE est utilisée avec GROUP BY, elle est traitée en premier et seules les lignes qui satisfont à la condition de recherche sont regroupées.

La norme SQL spécifie que lors du regroupement, toutes les valeurs manquantes sont traitées comme égales. Si deux lignes de tableau dans la même colonne de regroupement contiennent des valeurs NULL et identiques dans toutes les autres colonnes regroupées non vides, elles sont placées dans le même groupe.

Exemple 6.9. Calculez le volume moyen des achats effectués par chaque client.

SELECT Client.Nom, Avg (Deal.Quantity) AS Average_amount FROM Client INNER JOIN Deal ON Client.Client Code = Deal.Client Code GROUP BY Client.Surname Exemple 6.9. Calcul du volume moyen des achats effectués par chaque client.

La phrase "par chaque client" est reflétée dans la requête SQL sous forme de phrase GROUP BY Client..

Exemple 6.10. Déterminez à quel prix chaque article a été vendu.

SELECT Item.Name, Sum (Item.Price * Deal.Quantity) AS Cost FROM Item INNER JOIN Deal ON Item.Product Code = Deal.Product Code GROUP BY Item.Name Exemple 6.10. Détermination du prix de vente du produit de chaque article.

SELECT Client.Firm, Count (Deal.Trade Code) AS Nombre_ de transactions FROM Client INNER JOIN Deal ON Client.Client Code = Deal.Client Code GROUP BY Client.Firm Exemple 6.11. Compter le nombre de transactions effectuées par chaque entreprise.

SELECT Client.Firm, Sum (Deal.Quantity) AS Total_Quantity, Sum (Product.Price * Deal.Quantity) AS Cost FROM Product INNER JOIN (Client INNER JOIN Deal ON Client.Client Code = Deal.Client Code) ON Product.Product Code = Deal .Product Code GROUP BY Client.Firm Exemple 6.12. Calcul du montant total des biens achetés pour chaque entreprise et de sa valeur.

Exemple 6.13. Déterminez le coût total de chaque produit pour chaque mois.

SELECT Item.Name, Month (Deal.Date) AS Month, Sum (Item.Price * Deal.Quantity) AS Cost FROM Item INNER JOIN Deal ON Item.Product Code = Deal.Product Code GROUP BY Item.Name, Month (Deal .Date ) Exemple 6.13. Détermination du coût total de chaque produit pour chaque mois.

Exemple 6.14. Déterminez le coût total de chaque produit de la première année pour chaque mois.

SELECT Item.Name, Month (Deal.Date) AS Month, Sum (Item.Price * Deal.Quantity) AS Cost FROM Item INNER JOIN Deal ON Item.Product Code = Deal.Product Code WHERE Item.Variety = "First" GROUP PAR Article .Nom, Mois (Deal.Date) Exemple 6.14. Détermination du coût total de chaque produit du premier grade pour chaque mois.

Clause AVOIR

HAVING reflète tous les blocs de données précédemment regroupés par GROUP BY qui satisfont aux conditions spécifiées dans HAVING. ce opportunité supplémentaire"filtrer" l'ensemble de sortie.

Les conditions dans HAVING sont différentes des conditions dans WHERE :

• HAVING exclut les groupes de valeurs agrégés de l'ensemble de données de résultats ;
• WHERE exclut du calcul des valeurs agrégées en regroupant les enregistrements qui ne remplissent pas la condition ;
• les fonctions d'agrégat ne peuvent pas être spécifiées dans la clause de recherche WHERE.

Exemple 6.15. Identifiez les entreprises avec plus de trois transactions au total.

SELECT Client.Firm, Count (Deal.Number) AS Number_ of_ trades FROM Client INNER JOIN Deal ON Client.Client Code = Deal.Client Code GROUP BY Client.Firm HAVING Count (Deal.Number)> 3 Exemple 6.15. Identification des entreprises avec plus de trois transactions au total.

Exemple 6.16. Affichez une liste de produits vendus pour plus de 10 000 RUB.

SELECT Product.Name, Sum (Product.Price * Deal.Quantity) AS Cost FROM Product INNER JOIN Deal ON Product.Product Code = Deal.Product Code GROUP BY Product.Name HAVING Sum (Product.Price * Deal.Quantity)> 10000 Exemple 6.16. Affichage d'une liste de produits vendus pour plus de 10 000 roubles.

Exemple 6.17. Afficher une liste de produits vendus à plus de 10 000 sans préciser le montant.

SELECT Item.Name FROM Item INNER JOIN Deal ON Item.Product Code = Deal.Product Code GROUP BY Item.Name HAVING Sum (Item.Price * Deal.Quantity)> 10000 Exemple 6.17. Affichage d'une liste de produits vendus à plus de 10 000 sans préciser le montant.

À partir de la version 4.0, le SGBD MySQL a une capacité plutôt pratique de compter le nombre de tous les enregistrements appropriés pour une requête, lorsque le nombre d'enregistrements est limité par LIMIT. Lorsque vous travaillez avec une recherche de base de données, ainsi que lorsque vous effectuez des sélections à partir de tables avec gros montant enregistrements, une telle fonctionnalité est simplement nécessaire.

Syntaxe. Dans la requête SELECT, l'option SQL_CALC_FOUND_ROWS doit être spécifiée avant la liste des colonnes. Voici le début de la syntaxe de la clause SELECT.

SÉLECTIONNER




select_expr, ... ...

Ainsi, en faisant requête SELECT SQL_CALC_FOUND_ROWS Le SGBD comptera le nombre total de lignes correspondant à la condition de requête et stockera ce nombre en mémoire. Naturellement, la requête SELECT SQL_CALC_FOUND_ROWS n'a de sens que lorsque la contrainte (LIMIT) est utilisée. Immédiatement après avoir exécuté une requête select pour obtenir le nombre d'enregistrements, vous devez exécuter une autre requête SELECT : SELECT FOUND_ROWS () ;. En conséquence, MySQL renverra une ligne avec un champ, qui stockera le nombre de lignes.

Un exemple des demandes elles-mêmes :

> SELECT SQL_CALC_FOUND_ROWS * FROM tbl_name WHERE nombre> 100 LIMIT 10;
> SELECT FOUND_ROWS ();

La première requête renverra (imprimera) 10 lignes de la table tbl_name pour laquelle la condition numéro> 100 est vraie. Le deuxième appel à la commande SELECT renverra le nombre de lignes que la première commande SELECT aurait renvoyé si elle avait été écrite sans clause LIMIT. Bien que MySQL doive recalculer toutes les lignes du jeu de résultats lors de l'utilisation de SELECT SQL_CALC_FOUND_ROWS, cette méthode est toujours plus rapide que sans LIMIT, car elle n'a pas besoin d'envoyer le résultat au client.

Exemples de requêtes PHP :

$ result = mysql_query ("SELECT SQL_CALC_FOUND_ROWS * FROM table1 LIMIT 0, 10", $ link);
while ($ ligne = mysql_fetch_assoc ($ résultat))
{
var_dump (ligne $);
}

$ result = mysql_query ("SELECT FOUND_ROWS ()", $ link);
$ num_rows = mysql_result ($ result, 0);
echo "$ num_rows Rows \ n" ;

À la suite de l'exécution du code, à condition que le lien $ pointe vers une connexion ouverte au SGBD, PHP affichera 10 lignes de table1, puis une valeur entière pour le nombre de lignes correspondant à la requête (hors LIMIT).

Dans les requêtes avec UNION, SQL_CALC_FOUND_ROWS peut se comporter de deux manières du fait que LIMIT peut apparaître à plusieurs endroits. Le comptage de lignes peut être effectué pour des requêtes SELECT individuelles ou pour la requête entière après la concaténation.

L'objectif de SQL_CALC_FOUND_ROWS pour UNION est qu'il doit renvoyer le nombre de lignes qui seront renvoyées sans LIMITE globale. Les conditions d'utilisation de SQL_CALC_FOUND_ROWS avec UNION sont les suivantes :

• Le mot clé SQL_CALC_FOUND_ROWS doit apparaître dans la première instruction SELECT.
• FOUND_ROWS () ne sera précis que si UNION ALL est utilisé. Si UNION est spécifié sans ALL, la déduplication se produit et FOUND_ROWS () n'est qu'approximative.
• Si LIMIT n'est pas présent dans UNION, SQL_CALC_FOUND_ROWS est ignoré et le nombre de lignes de la table temporaire créée pour exécuter UNION est renvoyé.

Pour déterminer le nombre d'enregistrements dans table MySQL, vous devez utiliser fonction spéciale COMPTER ().

La fonction COUNT() renvoie le nombre d'enregistrements dans une table qui correspondent à un critère donné.

La fonction COUNT (expr) ne compte toujours que les lignes où expr est évaluée à NOT NULL.

Une exception à cette règle est l'utilisation de la fonction COUNT () avec un astérisque comme argument - COUNT (*). Dans ce cas, toutes les lignes sont prises en compte, qu'elles soient NULL ou NON NULL.

Par exemple, la fonction COUNT (*) renvoie le nombre total d'enregistrements dans une table :

SELECT COUNT (*) FROM nom_table

Comment compter le nombre d'entrées et afficher

Un exemple de code PHP + MySQL pour compter et afficher le nombre total de lignes :

$ res = mysql_query ("SELECT COUNT (*) FROM table_name") $ row = mysql_fetch_row ($ res); $ total = $ ligne ; // total des enregistrements echo $ total; ?>

Cet exemple illustre l'utilisation la plus simple de la fonction COUNT(). Mais avec cette fonction, vous pouvez également effectuer d'autres tâches.

En indiquant colonne spécifique table en paramètre, la fonction COUNT (nom_colonne) renvoie le nombre d'enregistrements dans cette colonne qui ne contiennent pas NULL. Les entrées NULL sont ignorées.

SELECTIONNER COUNT (nom_colonne) FROM nom_table

Vous ne pouvez pas utiliser la fonction mysql_num_rows(), car pour connaître le nombre total d'enregistrements, vous devez exécuter la requête SELECT * FROM db, c'est-à-dire obtenir tous les enregistrements, ce qui n'est pas souhaitable, il est donc préférable de utiliser la fonction de comptage.

$ result = mysql_query ("SELECT COUNT (*) as rec FROM db");

Utilisation de la fonction COUNT() par exemple

Voici un autre exemple d'utilisation de la fonction COUNT(). Supposons que vous ayez une table ice_cream avec un catalogue de crèmes glacées qui contient des ID de catégorie et des noms de crème glacée.

Leçon SQL 8. Regroupement d'enregistrements et fonction COUNT ()

Rappelons-nous quels messages et dans quels sujets nous avons. Pour ce faire, vous pouvez utiliser la requête habituelle :

Mais que se passe-t-il si nous avons juste besoin de savoir combien de messages il y a sur le forum. Pour ce faire, vous pouvez utiliser la fonction intégrée COMPTER ()... Cette fonction compte le nombre de lignes. De plus, si * sert d'argument à cette fonction, alors toutes les lignes du tableau sont comptées. Et si un nom de colonne est spécifié comme argument, seules les lignes qui ont une valeur dans la colonne spécifiée sont comptées.

Dans notre exemple, les deux arguments donneront le même résultat, puisque toutes les colonnes de la table ne sont PAS NULL. Écrivons une requête en utilisant la colonne id_topic comme argument :

SELECTIONNER COUNT (id_topic) DE messages;

Il y a donc 4 messages dans nos fils de discussion. Mais que se passe-t-il si nous voulons savoir combien de messages contient chaque sujet. Pour ce faire, nous devons regrouper nos messages par sujet et calculer le nombre de messages pour chaque groupe. Pour le regroupement en SQL, utilisez l'opérateur PAR GROUPE... Notre requête ressemblera maintenant à ceci :

SÉLECTIONNEZ id_topic, COUNT (id_topic) FROM messages GROUP BY id_topic ;

Opérateur PAR GROUPE indique au SGBD de regrouper les données par la colonne id_topic (c'est-à-dire que chaque sujet est un groupe distinct) et pour chaque groupe de compter le nombre de lignes :

Eh bien, dans le sujet avec id = 1 nous avons 3 messages, et avec id = 4 - un. Soit dit en passant, s'il n'y avait pas de valeurs dans le champ id_topic, ces lignes seraient combinées dans un groupe séparé avec une valeur NULL.

Supposons que nous ne soyons intéressés que par des groupes contenant plus de deux messages. Dans une requête normale, nous spécifierions une condition en utilisant l'opérateur OÙ, mais cet opérateur ne peut fonctionner qu'avec des chaînes, et pour les groupes les mêmes fonctions sont exécutées par l'opérateur AYANT:

SÉLECTIONNEZ id_topic, COUNT (id_topic) FROM messages GROUP BY id_topic AYANT COUNT (id_topic)> 2 ;

En conséquence, nous avons :

Dans la leçon 4, nous avons considéré quelles conditions peuvent être posées par l'opérateur OÙ, les mêmes conditions peuvent être fixées par l'opérateur AYANT, vous avez juste besoin de vous en souvenir OÙ filtre les lignes, et AYANT- les groupes.

Alors aujourd'hui, nous avons appris à créer des groupes et à compter le nombre de lignes dans un tableau et dans les groupes. En règle générale, avec l'opérateur PAR GROUPE vous pouvez utiliser d'autres fonctions intégrées, mais nous les étudierons plus tard.

Nous allons apprendre à résumer. Non, ce ne sont pas encore les résultats de l'étude de SQL, mais les résultats des valeurs des colonnes des tables de la base de données. Agrégat Fonctions SQL agir sur les valeurs des colonnes afin d'obtenir une seule valeur résultante. Les fonctions d'agrégation SQL les plus couramment utilisées sont SUM, MIN, MAX, AVG et COUNT. Il faut distinguer deux cas d'utilisation de fonctions d'agrégat. Premièrement, les fonctions d'agrégat sont utilisées seules et renvoient une seule valeur résultante. Deuxièmement, les fonctions d'agrégation sont utilisées avec la clause SQL GROUP BY, c'est-à-dire avec un regroupement par champs (colonnes) pour obtenir les valeurs de résultat dans chaque groupe. Considérons d'abord les cas d'utilisation de fonctions d'agrégat sans regroupement.

Fonction SOMME SQL

La fonction SQL SUM renvoie la somme des valeurs d'une colonne dans une table de base de données. Il ne peut être appliqué qu'aux colonnes dont les valeurs sont des nombres. requêtes SQL pour obtenir le montant obtenu, commencez comme ceci :

SÉLECTIONNER LA SOMME (COLUMN_NAME) ...

Cette expression est suivie de FROM (TABLE_NAME), puis une condition peut être spécifiée à l'aide de la clause WHERE. De plus, DISTINCT peut être spécifié devant le nom de la colonne, ce qui signifie que seules les valeurs uniques seront comptées. Par défaut, toutes les valeurs sont prises en compte (pour cela, vous pouvez spécifier spécifiquement non pas DISTINCT, mais ALL, mais le mot ALL est facultatif).

Exemple 1. Il existe une base de données de l'entreprise avec des données sur ses divisions et ses employés. La table Personnel, en plus de tout, a une colonne avec des données sur les salaires des employés. La sélection dans le tableau est la suivante (pour agrandir l'image, cliquez dessus avec le bouton gauche de la souris) :

Pour obtenir la somme de tous les salaires, nous utilisons la requête suivante :

SELECTIONNER LA SOMME (Salaire) DU Personnel

Cette requête renverra 287664.63.

Et maintenant . Dans les exercices, nous commençons déjà à compliquer les tâches, en les rapprochant de celles rencontrées en pratique.

Fonction SQL MIN

La fonction SQL MIN fonctionne également sur les colonnes dont les valeurs sont des nombres et renvoie le minimum de toutes les valeurs de la colonne. Cette fonction a la même syntaxe que la fonction SOMME.

Exemple 3. La base de données et la table sont les mêmes que dans l'exemple 1.

Vous voulez savoir le minimum les salaires employés du département numéro 42. Pour ce faire, écrivez la demande suivante :

La demande renverra la valeur 10505,90.

Et encore exercice pour décision indépendante ... Dans cet exercice et dans d'autres, vous aurez besoin non seulement de la table Staff, mais également de la table Org, qui contient des données sur les divisions de l'entreprise :

Exemple 4. La table Org est ajoutée à la table Staff, qui contient des données sur les divisions de l'entreprise. Affichez le nombre minimum d'années qu'un seul employé a travaillé dans un service situé à Boston.

Fonction SQL MAX

La fonction SQL MAX fonctionne de manière similaire et a une syntaxe similaire, qui est utilisée lorsque vous devez déterminer la valeur maximale parmi toutes les valeurs d'une colonne.

Exemple 5.

Il est nécessaire de connaître le salaire maximum des employés du département numéro 42. Pour ce faire, écrivez la demande suivante:

La requête renverra la valeur 18352,80

Le temps est venu exercices d'auto-solution.

Exemple 6. Nous travaillons à nouveau avec deux tables - Staff et Org. Imprimez le nom du département et les commissions maximales gagnées par un employé dans un département appartenant à la Division de l'Est. Utilisation JOIN (rejoindre des tables) .

Fonction SQL AVG

La syntaxe ci-dessus pour les fonctions décrites précédemment est également vraie pour la fonction SQL AVG. Cette fonction renvoie la moyenne de toutes les valeurs d'une colonne.

Exemple 7. La base de données et la table sont les mêmes que dans les exemples précédents.

Supposons que vous souhaitiez connaître l'expérience de travail moyenne des employés du département numéro 42. Pour ce faire, écrivez la requête suivante :

Le résultat sera une valeur de 6,33

Exemple 8. Nous travaillons avec une seule table - Personnel. Retirer le salaire moyen des salariés ayant une expérience de 4 à 6 ans.

Fonction SQL COUNT

La fonction SQL COUNT renvoie le nombre d'enregistrements dans une table de base de données. Si vous spécifiez SELECT COUNT (COLUMN_NAME) ... dans la requête, le résultat sera le nombre d'enregistrements à l'exclusion des enregistrements dans lesquels la valeur de la colonne est NULL (non définie). Si vous utilisez un astérisque comme argument et lancez une requête SELECT COUNT (*) ..., le résultat sera le nombre de tous les enregistrements (lignes) de la table.

Exemple 9. La base de données et la table sont les mêmes que dans les exemples précédents.

Il est nécessaire de connaître le nombre de tous les employés qui reçoivent des commissions. Le nombre d'employés dont les valeurs de la colonne Comm ne sont pas NULL renverra la requête suivante :

SELECT COUNT (Comm) FROM Personnel

Le résultat est 11.

Exemple 10. La base de données et la table sont les mêmes que dans les exemples précédents.

Si vous avez besoin de connaître le nombre total d'enregistrements dans une table, nous utilisons une requête avec un astérisque comme argument de la fonction COUNT :

SELECTIONNER LE COMPTE (*) FROM Personnel

Le résultat est 17.

Ensuite exercice d'auto-assistance vous devrez utiliser une sous-requête.

Exemple 11. Nous travaillons avec une seule table - Personnel. Afficher le nombre d'employés dans le service de planification (Plaines).

Fonctions d'agrégation avec SQL GROUP BY (regroupement)

Examinons maintenant l'utilisation des fonctions d'agrégation en conjonction avec la clause SQL GROUP BY. La clause SQL GROUP BY permet de regrouper les valeurs du résultat par les colonnes de la table de base de données. Le site a une leçon dédiée à cet opérateur séparément .

Exemple 12. Il existe une base de données de portail publicitaire. Il contient le tableau Annonces, qui contient des données sur les annonces soumises pour la semaine. La colonne Catégorie contient des données sur les grandes catégories d'annonces (par exemple, Immobilier), tandis que la colonne Pièces contient des données sur les plus petites parties incluses dans la catégorie (par exemple, les parties Appartements et Villas font partie de la catégorie Immobilier). La colonne Unités contient des données sur le nombre d'annonces soumises et la colonne Argent contient le montant d'argent reçu pour l'envoi d'annonces.

Catégorie	Partie	Unités	De l'argent
Transport	Véhicules à moteur	110	17600
Immobilier	Appartements	89	18690
Immobilier	Chalets	57	11970
Transport	motocyclettes	131	20960
Matériaux de construction	Planches	68	7140
Ingénierie électrique	postes de télévision	127	8255
Ingénierie électrique	Réfrigérateurs	137	8905
Matériaux de construction	Regips	112	11760
Loisirs	Livres	96	6240
Immobilier	Maisons	47	9870
Loisirs	Musique	117	7605
Loisirs	Jeux	41	2665

À l'aide de instruction SQL GROUP BY, trouvez le montant d'argent gagné en soumettant des annonces dans chaque catégorie. Nous écrivons la requête suivante :

SÉLECTIONNEZ LA CATÉGORIE, SOMME (Argent) AS Argent À PARTIR DES Annonces GROUPE PAR Catégorie

Exemple 13. La base de données et la table sont les mêmes que dans l'exemple précédent.

Utilisez l'instruction SQL GROUP BY pour savoir quelle partie de chaque catégorie comportait le plus d'annonces. Nous écrivons la requête suivante :

SELECTIONNER Catégorie, Partie, MAX (Unités) COMME Maximum FROM Annonces GROUP BY Catégorie

Le résultat sera le tableau suivant :

Les valeurs totales et individuelles dans un tableau peuvent être obtenues combinaison des résultats de la requête à l'aide de l'opérateur UNION .

Bases de données relationnelles données et langage SQL