Les champs calculés sont un outil important dans la gestion des données pour manipuler et présenter les données plus efficacement. Cet outil permet aux utilisateurs d’effectuer des calculs directement dans les requêtes SQL, en obtenant les résultats souhaités sans modifier les données de la table. En utilisant des champs calculés, les utilisateurs peuvent économiser du temps et des ressources et augmenter l’efficacité du traitement des données.
Les champs calculés sont des colonnes qui n’existent pas physiquement dans une table de base de données, mais qui sont créées dynamiquement lorsqu’une requête est exécutée. Cela permet aux utilisateurs d’effectuer des opérations mathématiques ou des manipulations de chaînes sur des données existantes, générant de nouvelles valeurs à partir de colonnes existantes.
Par exemple, nous pouvons utiliser un champ calculé pour calculer le prix total de plusieurs articles en multipliant le nombre d’articles par le prix par article et en affichant les résultats dans une seule requête.
Les données stockées dans la table sont des informations statiques qui ne changent que s’il y a une mise à jour manuelle. En revanche, les résultats de calcul des champs calculés sont dynamiques et peuvent changer à chaque exécution d’une requête. Cela signifie que les champs calculés peuvent fournir la dernière valeur en fonction des conditions actuelles sans modifier les données d’origine de la table.
Par exemple, si nous avons des colonnes pour le prix et la quantité, nous pouvons utiliser des champs calculés pour calculer le prix total directement lors de la requête, au lieu de stocker le prix total dans des colonnes distinctes dans la table.
Avantages de l’utilisation des champs calculés
Améliorez l’efficacité de la capture de données.
Les champs calculés permettent aux utilisateurs de récupérer les données traitées directement à partir de la base de données sans avoir besoin de traitement supplémentaire côté client. Cela accélère la réponse de l’application et réduit la charge du réseau, car seules les données nécessaires sont envoyées.
L’efficacité du traitement des données sur le serveur
Les systèmes de gestion de bases de données (SGBD) sont conçus pour traiter les données rapidement et efficacement. Avec les champs calculés, tous les calculs sont effectués sur le serveur, ce qui est généralement plus rapide que s’ils étaient effectués sur le client. Il réduit également l’utilisation des ressources du client, telles que le processeur et la mémoire, améliorant ainsi les performances globales de l’application.
Réduire les besoins de traitement chez le client.
Avec les champs calculés, une grande partie du traitement qui serait normalement effectué par une application cliente peut être déplacée vers le serveur de base de données. Cela signifie que l’application n’a pas besoin d’effectuer de calculs ou de modifier le format des données après les avoir récupérées à partir de la base de données, ce qui permet de gagner du temps et de réduire la complexité du code.
Simplifiez les requêtes pour des rapports ou des besoins spécifiques.
Les champs calculés permettent aux utilisateurs de simplifier les requêtes complexes pour les rendre plus faciles à comprendre et à gérer. Par exemple, au lieu de prendre plusieurs colonnes distinctes et d’effectuer des calculs dans l’application, l’utilisateur peut créer une seule requête avec un champ calculé qui fournit le résultat final souhaité. Cela améliore non seulement la lisibilité des requêtes, mais facilite également la création de rapports ou l’analyse de données.
Comment créer des champs calculés en SQL
Les champs calculés sont créés en ajoutant une formule ou une fonction dans la commande SELECT. Il peut s’agir d’une fusion de texte, d’un calcul de nombre ou d’un autre traitement de données. Les colonnes de résultat de ce calcul ne sont pas stockées dans la table, mais sont automatiquement créées lors de l’exécution de la requête.
Fusion de chaînes avec concat()
L’une des utilisations courantes des champs calculés consiste à combiner des chaînes de plusieurs colonnes en une seule. La fonction Concat() en SQL est utilisée pour combiner deux chaînes ou plus en une seule chaîne.
La fonction Concat() nous permet de combiner les valeurs de plusieurs colonnes. De plus, nous pouvons utiliser des alias avec des mots-clés américains pour nommer les colonnes calculées afin de les rendre plus accessibles et plus compréhensibles.
Exemples de code
Voici un exemple de requête SQL qui utilise Concat() pour combiner le nom et le pays du fournisseur dans une seule nouvelle colonne nommée vend_title :
SELECT Concat(vend_name,'(', vend_country, ')') AS vend_title
FROM vendors
ORDER BY vend_name ;Analyse d’échantillons de code
Concat() : Dans cet exemple, la fonction Concat() combine trois éléments :
- Nom du fournisseur dans la colonne vend_name.
- Chaînes sous forme d’espaces et de crochets ouvrants ‘ (.
- Nom du pays à partir de vend_country colonne.
- Crochets de capuchon ‘)’.
Alias : À l’aide d’AS vend_title, nous donnons un nom au résultat combiné, afin qu’il puisse être référencé en tant que vend_title dans l’application cliente.
Output : Le résultat de cette requête génère une nouvelle colonne contenant la combinaison du nom du fournisseur et du pays dans le format souhaité, par exemple :
+----------------------+
| vend_title |
+----------------------+
| ACME (USA) |
| Anvils R Us (USA) |
| Furball Inc. (USA) |
| Jet Set (England) |
| Jouets Et Ours (France) |
| LT Supplies (USA) |
+----------------------+Supprimer des espaces avec la fonction trim()
Dans la gestion des données, nous rencontrons souvent des problèmes d’espacement indésirables autour des valeurs de chaîne. Pour résoudre ce problème, SQL propose plusieurs fonctions de découpage, à savoir RTrim(), LTrim() et Trim(). Ces fonctions sont très utiles pour nettoyer les données avant de poursuivre le processus.
Fonctions RTrim(), LTrim() et Trim()
- RTrim() : Supprime tous les espaces sur le côté droit de la chaîne.
- LTrim() : Supprime tous les espaces sur le côté gauche de la chaîne.
- Trim() : Supprime tous les espaces de chaque côté de la chaîne.
Ces trois fonctions permettent de s’assurer que les données extraites de la base de données sont propres et prêtes à l’emploi, en particulier lors de l’exécution de jointures de chaînes ou de calculs.
Cas d’utilisation du nettoyage des données
Voici un exemple de requête SQL qui utilise la fonction RTrim() pour supprimer les espaces indésirables avant de combiner les noms de fournisseurs et les pays de fournisseurs :
SELECT Concat(RTrim(vend_name), ''(', RTrim(vend_country),') AS vend_title
FROM vendors
ORDER BY vend_name ;Analyse d’échantillons de code
Concat(RTrim(vend_name), »(‘, RTrim(vend_country),’) : Dans cette requête, nous utilisons RTrim() sur les champs vend_name et vend_country pour nous assurer qu’il n’y a pas d’espaces supplémentaires à la fin du nom du fournisseur ou du pays. Ceci est essentiel pour maintenir un format de sortie soigné et professionnel.
Alias : À l’aide d’AS vend_title, nous donnons un nom à ce résultat combiné, ce qui le rend facile à référencer dans l’application cliente.
Output : Le résultat de cette requête génère une nouvelle colonne nommée vend_title qui contient une combinaison de nom de fournisseur et de pays sans espaces supplémentaires, tels que :
+----------------------+
| vend_title |
+----------------------+
| ACME (USA) |
| Anvils R Us (USA) |
| Furball Inc. (USA) |
| Jet Set (England) |
| Jouets Et Ours (France) |
| LT Supplies (USA) |
+----------------------+Effectuer des calculs mathématiques avec des champs calculés
En SQL, nous pouvons effectuer divers calculs mathématiques à l’aide d’opérateurs de base. Voici les opérateurs les plus fréquemment utilisés :
- + : Sommation
- – : Réduction
- \* : Multiplication
- / : Distribution
Ces opérateurs nous permettent d’effectuer différents types de calculs sur les données récupérées de la table. Nous pouvons également utiliser des parenthèses pour définir l’ordre des opérations dans le calcul.
Exemple de code de calcul
Voici un exemple de requête SQL qui effectue un calcul mathématique pour calculer le prix total d’un article dans une commande :
SELECT prod_id, quantity, item_price, quantity * item_price AS expanded_price
FROM orderitems
WHERE order_num =200005 ;Analyse d’échantillons de code
prod_id, quantity, item_price : Ces colonnes sont extraites de la table des articles de commande, qui contient des informations sur le produit, la quantité commandée et le prix unitaire.
quantity *item_price AS expanded_price : Ici, nous faisons le calcul en multipliant la quantité par item_price (prix unitaire). Le résultat de ce calcul est nommé alias expanded_price, qui apparaîtra sous la forme d’une nouvelle colonne dans les résultats de la requête.
WHERE order_num = 20005 : Cette condition garantit que seuls les articles de la commande portant le numéro 20005 sont prélevés.
Sortie
Le résultat de cette requête générera une table avec les informations suivantes :
+---------+----------+------------+---------------+
| prod_id | quantity | item_price | expanded_price|
+---------+----------+------------+---------------+
| ANV01 | 10 | 5.99 | 59.90 |
| ANV02 | 3 | 9.99 | 29.97 |
| TNT2 | 5 | 10.00 | 50.00 |
| FB | 1 | 10.00 | 10.00 |
+---------+----------+------------+---------------+Dans cette sortie, la colonne expanded_price affiche le prix total de chaque article en fonction de la quantité commandée.
