Introduction
Dans une base de données, les fonctions d'agrégation consistent à effectuer des opérations sur un ensemble de données.
Ces fonctions prendront leurs données en fonction d'un agrégat ou d'un regroupement de données.
Ces fonctions sont généralement utiles dans la création de rapports ou de données statistiques.
Voici quelques fonctions disponibles :
- Avg()
- Permet d'obtenir la moyenne d'un champ
- Count()
- Permet d'obtenir le nombre d'occurrences
- Max()
- Permet d'obtenir la valeur maximale d'un champ
- Min()
- Permet d'obtenir la valeur minimale d'un champ
- Sum()
- Permet de calculer la somme d'un champ en excluant les valeurs
NULL.
- Permet de calculer la somme d'un champ en excluant les valeurs
- Total()
- Permet de calculer la somme d'un champ en remplaçant les
NULLpar 0.
- Permet de calculer la somme d'un champ en remplaçant les
Pour avoir accès à la liste complète des fonctions d'agrégation en SQLite : https://www.sqlite.org/lang_aggfunc.html
Agrégation simple
Les premiers exemples se feront à partir de toutes les enregistrements de la table.
Téléchargez la base de données bd_cours7.sqlite dans LÉA.
La base de données a la table Employes. Voici ces données.
Id Nom Age Ville Salaire ---------- ---------- ---------- ------------- ---------- 1 Paul 22 Drummondville 20000.0 2 Pierre 25 Montréal 15000.0 3 Ted 23 Québec 20000.0 4 Marc 25 Lévis 65000.0 5 David 22 Montréal 85000.0 6 Kim 22 Sherbrooke 45000.0 7 Jean 23 Magog 10000.0 8 George 23 NULL NULL 9 Antoine 23 NULL NULL 10 François 22 Montréal 17000.0
Les requêtes d'agrégation simple seront faites sur cette table.
Il est important de ne pas mettre d'autres champs lors de l'utilisation d'une fonction d'agrégation si aucune clause GROUP BY n'est présente dans la requête. L'utilisation de cette clause sera présentée à la section 4. SQLite le permet et il va afficher une des valeurs de la table, sans aucun lien avec le calcul. D'autres moteurs de base de données vont refuser la requête tout simplement.
Il est possible de mettre des conditions (WHERE) dans le SELECT pour restreindre l'agrégat. La logique est identique à une projection standard.
Count()
La fonction Count() permet de compter le nombre d'enregistrements d'un agrégat.
Pour obtenir le nombre d'enregistrements de la table au complet.
SELECT Count(*) AS NbEmployesFROM Employes;
Pour obtenir le nombre d'employés qui sont de la ville de Montréal.
SELECT Count(*) AS NbEmployesFROM EmployesWHERE Ville = 'Montréal';
Pour obtenir le nombre d'employés qui ont plus de 22.
SELECT Count(*) AS NbEmployesFROM EmployesWHERE Age > 22;
Pour obtenir le nombre de villes différentes dans la base de données. La ville de Montréal s'y retrouve 2 fois, donc elle compte seulement pour 1.
Les valeurs NULL sont automatiquement exclues.
SELECT Count(DISTINCT Ville) AS NbVilleFROM Employes;
Min() et Max()
La fonction Min() retourne la plus petite valeur d'un champ en fonction de l'agrégat.
La fonction Max() retourne la plus petite valeur d'un champ en fonction de l'agrégat.
La valeur NULL est exclue du calcul.
Pour obtenir le plus petit salaire.
SELECT Min(Salaire) AS MinSalaireFROM Employes;
Pour obtenir le plus grand salaire.
SELECT Max(Salaire) AS MaxSalaireFROM Employes;
Pour obtenir le plus grand salaire des 25 ans.
SELECT Max(Salaire) AS MaxSalaireFROM EmployesWHERE Age = 25;
Avg()
La fonction Avg() calcule la moyenne d'un champ en fonction de l'agrégat.
Pour obtenir le salaire moyen.
SELECT Avg(Salaire) AS MoySalaireFROM Employes;
Il peut être intéressant d'arrondir la valeur avec 2 décimale. La fonction Round() permet de le faire.
SELECT Round(Avg(Salaire),2) AS MoySalaireFROM Employes;
Pour obtenir la moyenne du salaire des 25 ans.
SELECT Avg(Salaire) AS MoySalaireFROM EmployesWHERE Age = 25;
Pour obtenir la moyenne des salaires des employées de Montréal.
SELECT Avg(Salaire) AS MoySalaireFROM EmployesWHERE Ville = 'Montréal';
Sum() et Total()
La fonction Sum() calcule la somme d'un champ en fonction de l'agrégat. Si la somme est NULL, la valeur NULL sera affichée.
La fonction Total() calcule la somme d'un champ en fonction de l'agrégat. Si la somme est NULL, la valeur 0 sera affichée.
Pour obtenir la somme de tous les salaires. Dans l'exemple ci-dessous, la somme et le total ont la même valeur.
SELECT Sum(Salaire) AS SommeSalaire, Total(Salaire) AS TotalSalaireFROM Employes;
Pour obtenir la somme des employés de 23 ans. Il y a 2 employés de 23 ans que leur salaire est NULL. Dans l'exemple ci-dessous, la somme et le total ont la même valeur, car la fonction Sum() va ignorer la valeur NULL et la fonction Total() va utiliser 0.
Donc
- Sum() => 10 000 + 20 000 = 30 000
- Total() => 10 000 + 20 000 + 0 + 0 = 30 000
SELECT Sum(Salaire) AS SommeSalaire, Total(Salaire) AS TotalSalaireFROM EmployesWHERE Age = 23;
Il faut obtenir la somme de tous les salaires des employés qui ont la valeur NULL pour la ville. Dans l'exemple ci-dessous, la somme est NULL et le total est 0.
Donc
- Sum() => rien = null
- Total() => 0 + 0 = 0
SELECT Sum(Salaire) AS SommeSalaire, Total(Salaire) AS TotalSalaireFROM EmployesWHERE Ville IS NULL;
Il est possible d'utiliser la fonction IfNULL également pour donner une valeur par défaut dans le cas que le résultat de la fonction d'agrégation donne NULL. Il faut afficher -1 si la valeur est NULL.
SELECT IfNULL(Sum(Salaire), -1) AS SommeSalaireFROM EmployesWHERE Ville IS NULL;
La fonction IfNULL(Sum(champ), 0) est équivalente à Total(champ).
Jointure
Il est possible de faire des requêtes avec des jointures et faire de l'agrégation.
Prenons les tables Etudiants et Pays. La table Etudiants a une clé étrangère vers la table parent Pays.
Les valeurs de la table Etudiants.
EtudiantId Prenom Nom DA PaysId ---------- ---------- ---------- --------- ------ 1 François St-Hilaire 011234521 1 2 François Simard 02012545 1 3 Julie St-Hilaire 21014520 1 4 Gianni Ferrari 19875245 3 5 Pierre-Luc Boucher 214587413 1 6 Jules Pigeon 22017487 2 7 Mike Dundee 227878541 4 8 Simone Lapierre 202487454 2 9 Brigitte Morin 225487963 2 10 Beatrice Bignone 210145874 3 11 Julie Boucher 029875217 1
Les valeurs de la table Pays.
PaysId Nom ------ --------- 1 Canada 2 France 3 Italie 4 Australie 5 États-Unis
Pour obtenir le nombre d'étudiants du Canada.
SELECT Count(*) NbEtudiantFROM EtudiantsINNER JOIN Pays ON Etudiants.PaysId = Pays.PaysIdWHERE Pays.Nom = 'Canada';
Regroupement - GROUP BY
La clause GROUP BY permet de calculer les fonctions d'agrégation à partir d'un regroupement précis.
Les champs qui se trouvent dans le SELECT doivent être obligatoirement être dans le regroupement.
SQL regroupe tous les enregistrements dont les valeurs sont identiques dans la clause GROUP BY et effectue le calcul pour ce sous-ensemble de données.
Table Employes
Les exemples ci-dessous utiliseront uniquement la table Employes pour faire le regroupement.
Voici un rappel du contenu de la table.
Id Nom Age Ville Salaire ---------- ---------- ---------- ------------- ---------- 1 Paul 22 Drummondville 20000.0 2 Pierre 25 Montréal 15000.0 3 Ted 23 Québec 20000.0 4 Marc 25 Lévis 65000.0 5 David 22 Montréal 85000.0 6 Kim 22 Sherbrooke 45000.0 7 Jean 23 Magog 10000.0 8 George 23 NULL NULL 9 Antoine 23 NULL NULL 10 François 22 Montréal 17000.0
Pour les 3 premiers exemples, le GROUP BY sera déconstruit pour comprendre comment la création d'un agrégat ou d'un regroupement fonctionne.
Exemple 1 - Somme des salaires par âge
Il faut calculer la somme des salaires par âge.
SELECT Age, Sum(Salaire) AS SommeSalaireFROM EmployesGROUP BY Age;
Le résultat est :
Age SommeSalaire --- -------- 22 167000.0 23 30000.0 25 80000.0
La clause GROUP BY indique qu'il faut faire plusieurs agrégats ou regroupements en fonction de l'âge.
Il y a 3 âges distincts dans la sélection.
Le GROUP BY définit les clés de l'agrégat comme la requête ci-dessous.
SELECT DISTINCT AgeFROM Employes;
La base de données retourne les regroupements ci-dessous.
Age --- 22 25 23
Le GROUP BY regroupe les données de la table comme ci-dessous pour chacun des groupes.
SELECT *FROM EmployesWHERE Age = 22;/*EmployeId Nom Age Ville Salaire--------- ----- --- ------------- -------1 Paul 22 Drummondville 20000.05 David 22 Montréal 85000.06 Kim 22 Sherbrooke 45000.010 François 22 Montréal 17000.0*/SELECT *FROM EmployesWHERE Age = 23;/*EmployeId Nom Age Ville Salaire--------- ------- --- ------ -------3 Ted 23 Québec 20000.07 Jean 23 Magog 10000.08 George 23 NULL NULL9 Antoine 23 NULL NULL*/SELECT *FROM EmployesWHERE Age = 25;/*EmployeId Nom Age Ville Salaire--------- ------ --- -------- -------2 Pierre 25 Montréal 15000.04 Marc 25 Lévis 65000.0*/
Ensuite, pour chacun des regroupements, la fonction d'agrégation est calculée.
SELECT Sum(Salaire) AS SommeSalaireFROM EmployesWHERE Age = 22;/*SommeSalaire--------167000.0*/SELECT Sum(Salaire) AS SommeSalaireFROM EmployesWHERE Age = 23;/*SommeSalaire--------30000.0*/SELECT Sum(Salaire) AS SommeSalaireFROM EmployesWHERE Age = 25;/*SommeSalaire--------80000.0*/
Finalement, il associe la colonne Age au résultat de l'agrégation correspondant.
Age SommeSalaire --- -------- 22 167000.0 23 30000.0 25 80000.0
Exemple 2 - La somme des salaires par age et ville
Il faut calculer la somme des salaires par âge et par la ville. Pour faciliter le visuel, la requête sera triée par Age et ensuite par Ville.
SELECT Age, Ville, Sum(Salaire) AS SommeSalaireFROM EmployesGROUP BY Age, VilleORDER BY Age, Ville;
Le résultat est :
Age Ville SommeSalaire --- ------------- ------------ 22 Drummondville 20000.0 22 Montréal 102000.0 22 Sherbrooke 45000.0 23 NULL NULL 23 Magog 10000.0 23 Québec 20000.0 25 Lévis 65000.0 25 Montréal 15000.0
La clause GROUP BY indique qu'il faut faire plusieurs agrégats ou regroupements en fonction du couple âge et ville.
SELECT DISTINCT Age, VilleFROM EmployesORDER BY Age, Ville;
La base de données retourne les regroupements ci-dessous.
Il y a 8 couples âge et ville distincts dans la sélection de base.
Age Ville --- ------------- 22 Drummondville 22 Montréal 22 Sherbrooke 23 NULL 23 Magog 23 Québec 25 Lévis 25 Montréal
Le GROUP BY regroupe les données de la table comme ci-dessous pour chacun des groupes.
SELECT *FROM EmployesWHERE Age = 22 AND Ville = 'Drummondville';/*EmployeId Nom Age Ville Salaire--------- ---- --- ------------- -------1 Paul 22 Drummondville 20000.0*/SELECT *FROM EmployesWHERE Age = 22 AND Ville = 'Montréal';/*EmployeId Nom Age Ville Salaire--------- -------- --- -------- -------5 David 22 Montréal 85000.010 François 22 Montréal 17000.0*/SELECT *FROM EmployesWHERE Age = 22 AND Ville = 'Sherbrooke';/*EmployeId Nom Age Ville Salaire--------- --- --- ---------- -------6 Kim 22 Sherbrooke 45000.0*/SELECT *FROM EmployesWHERE Age = 23 AND Ville IS NULL;/*EmployeId Nom Age Ville Salaire--------- ------- --- ----- -------8 George 239 Antoine 23*/SELECT *FROM EmployesWHERE Age = 23 AND Ville = 'Magog';/*EmployeId Nom Age Ville Salaire--------- ---- --- ----- -------7 Jean 23 Magog 10000.0*/SELECT *FROM EmployesWHERE Age = 23 AND Ville = 'Québec';/*EmployeId Nom Age Ville Salaire--------- --- --- ------ -------3 Ted 23 Québec 20000.0*/SELECT *FROM EmployesWHERE Age = 25 AND Ville = 'Lévis'; /*EmployeId Nom Age Ville Salaire--------- ---- --- ----- -------4 Marc 25 Lévis 65000.0*/SELECT *FROM EmployesWHERE Age = 25 AND Ville = 'Montréal'; /*EmployeId Nom Age Ville Salaire--------- ------ --- -------- -------2 Pierre 25 Montréal 15000.0*/
Ensuite, pour chacun des regroupements, la fonction d'agrégation est calculée.
SELECT Sum(Salaire) AS SommeSalaireFROM EmployesWHERE Age = 22 AND Ville = 'Drummondville';/*SommeSalaire------------20000.0*/SELECT Sum(Salaire) AS SommeSalaireFROM EmployesWHERE Age = 22 AND Ville = 'Montréal';/*SommeSalaire------------102000.0*/SELECT Sum(Salaire) AS SommeSalaireFROM EmployesWHERE Age = 22 AND Ville = 'Sherbrooke';/*SommeSalaire------------45000.0*/SELECT Sum(Salaire) AS SommeSalaireFROM EmployesWHERE Age = 23 AND Ville IS NULL;/*SommeSalaire------------NULL*/SELECT Sum(Salaire) AS SommeSalaireFROM EmployesWHERE Age = 23 AND Ville = 'Magog';/*SommeSalaire------------10000.0*/SELECT Sum(Salaire) AS SommeSalaireFROM EmployesWHERE Age = 23 AND Ville = 'Québec';/*SommeSalaire------------20000.0*/SELECT Sum(Salaire) AS SommeSalaireFROM EmployesWHERE Age = 25 AND Ville = 'Lévis'; /*SommeSalaire------------65000.0*/SELECT Sum(Salaire) AS SommeSalaireFROM EmployesWHERE Age = 25 AND Ville = 'Montréal'; /*SommeSalaire------------15000.0*/
Finalement, il associe la colonne Age et Ville au résultat de l'agrégation correspondant.
Age Ville SommeSalaire --- ------------- ------------ 22 Drummondville 20000.0 22 Montréal 102000.0 22 Sherbrooke 45000.0 23 NULL NULL 23 Magog 10000.0 23 Québec 20000.0 25 Lévis 65000.0 25 Montréal 15000.0
Le salaire moyen par âge des plus de 22 ans
Il est possible d'ajouter un WHERE avant le GROUP BY pour réduire le nombre d'enregistrements à regrouper.
SELECT Age, Avg(Salaire) AS MoyenneSalaireFROM EmployesWHERE Age > 22GROUP BY Age
Le résultat est :
Age SommeSalaire --- -------- 23 15000.0 25 40000.0
La clause GROUP BY indique qu'il faut faire plusieurs agrégats ou regroupements en fonction de l'âge. Mais le WHERE se fait avant le regroupement.
Le GROUP BY définit les clés de l'agrégat comme la requête ci-dessous.
SELECT DISTINCT AgeFROM EmployesWHERE Age > 22;
La base de données retourne les regroupements ci-dessous.
Age --- 25 23
Le GROUP BY regroupe les données de la table comme ci-dessous pour chacun des groupes.
SELECT *FROM EmployesWHERE Age = 23;/*EmployeId Nom Age Ville Salaire--------- ------- --- ------ -------3 Ted 23 Québec 20000.07 Jean 23 Magog 10000.08 George 23 NULL NULL9 Antoine 23 NULL NULL*/SELECT *FROM EmployesWHERE Age = 25;/*EmployeId Nom Age Ville Salaire--------- ------ --- -------- -------2 Pierre 25 Montréal 15000.04 Marc 25 Lévis 65000.0*/
Ensuite, pour chacun des regroupements, la fonction d'agrégation est calculée.
SELECT Avg(Salaire) AS MoyenneSalaireFROM EmployesWHERE Age = 23;/*SommeSalaire--------15000.0*/SELECT Avg(Salaire) AS MoyenneSalaireFROM EmployesWHERE Age = 25;/*SommeSalaire--------40000.0*/
Finalement, il associe la colonne Age au résultat de l'agrégation correspondant.
Age SommeSalaire --- -------- 23 15000.0 25 40000.0
Pour 23 ans, la somme est de 30 000, il y a 4 employés, mais la moyenne est de 15 000 et non 10 000.
La raison est que la moyenne d'un champ prend en compte uniquement les enregistrements que la valeur du salaire n'est pas NULL. Dans ce cas-ci, il y a 2 enregistrements avec une valeur, donc c'est la somme divisée par 2.
Donc en réalité, le sous-regroupement est comme ceci.
SELECT *FROM EmployesWHERE Age = 23 AND Salaire IS NOT NULL; /*EmployeId Nom Age Ville Salaire--------- ------- --- ------ -------3 Ted 23 Québec 20000.07 Jean 23 Magog 10000.0*/
Exemple 4 - Le nombre d'employés par âge
Voici 2 requêtes pour obtenir le nombre d'employés par âge.
La première effectue le Count(*) sur l'étoile.
La deuxième effectue le Count(Salaire) sur le champ Salaire.
SELECT Age, Count(*) AS NbEmployesFROM EmployesGROUP BY Age;SELECT Age, Count(Salaire) AS NbEmployesFROM EmployesGROUP BY Age;
Est-ce qu'il y a une différence ?
Voici les résultats.
--Count(*) Age NbEmployes --- ---------- 22 3 23 4 -- Différent 25 2 --Count(Salaire) Age NbEmployes --- ---------- 22 3 23 2 -- Différent 25 2
La valeur pour le groupe 23 est différente.
La raison est que le Count(*) compte le nombre de lignes dans le regroupement, alors que Count(salaire) compte le nombre de lignes qui ont une valeur non nulle pour le champ Salaire.
Tables Etudiants et Pays
Il est possible de faire des regroupements avec des requêtes avec des jointures.
Exemple 1 - Le nombre d'étudiants par pays
SELECT Pays.PaysId, Pays.Nom, Count(*) AS NbEtudiantFROM PaysINNER JOIN Etudiants ON Pays.PaysId = Etudiants.PaysIdGROUP BY Pays.PaysId, Pays.Nom;
Voici le résultat.
PaysId Nom NbEtudiant ------ --------- ---------- 1 Canada 5 2 France 3 3 Italie 2 4 Australie 1
Exemple 2 - Le nombre d'étudiants par pays, mais inclure les pays sans étudiant
Les États-Unis ne sont pas dans la requête. Pour les inclure, il faut faire un LEFT OUTER JOIN.
SELECT Pays.PaysId, Pays.Nom, Count(*) AS NbEtudiantFROM PaysLEFT OUTER JOIN Etudiants ON Pays.PaysId = Etudiants.PaysIdGROUP BY Pays.PaysId, Pays.Nom;
Voici le résultat.
PaysId Nom NbEtudiant ------ ---------- ---------- 1 Canada 5 2 France 3 3 Italie 2 4 Australie 1 5 États-Unis 1
Les États-Unis donne 1 ? Pour quelle raison ?
Le Count(*) compte le nombre d'enregistrements. La relation null consiste à un enregistrement.
SELECT *FROM PaysLEFT OUTER JOIN Etudiants ON Pays.PaysId = Etudiants.PaysId;/*PaysId Nom EtudiantId Prenom Nom DA PaysId------ ---------- ---------- ---------- ---------- --------- ------1 Canada 2 François Simard 02012545 11 Canada 1 François St-Hilaire 011234521 11 Canada 11 Julie Boucher 029875217 11 Canada 3 Julie St-Hilaire 21014520 11 Canada 5 Pierre-Luc Boucher 214587413 12 France 9 Brigitte Morin 225487963 22 France 6 Jules Pigeon 22017487 22 France 8 Simone Lapierre 202487454 23 Italie 10 Beatrice Bignone 210145874 33 Italie 4 Gianni Ferrari 19875245 34 Australie 7 Mike Dundee 227878541 45 États-Unis NULL NULL NULL NULL NULL */
Pour régler ce problème, il faut faire le Count() sur un champ de la table Etudiants.
Il est préférable de le faire sur la clé primaire.
SELECT Pays.PaysId, Pays.Nom, Count(Etudiants.EtudiantId) AS NbEtudiantFROM PaysLEFT OUTER JOIN Etudiants ON Pays.PaysId = Etudiants.PaysIdGROUP BY Pays.PaysId, Pays.Nom;
Voici le résultat.
PaysId Nom NbEtudiant ------ ---------- ---------- 1 Canada 5 2 France 3 3 Italie 2 4 Australie 1 5 États-Unis 0
Il faudrait trier les pays par le nombre d'étudiants, du plus petit au plus grand.
Il est possible de mettre une fonction d'agrégation dans le ORDER BY. La clause ORDER BY doit être après la clause GROUP BY, car le trie se fait sur le résultat du regroupement.
SELECT Pays.PaysId, Pays.Nom, Count(Etudiants.EtudiantId) AS NbEtudiantFROM PaysLEFT OUTER JOIN Etudiants ON Pays.PaysId = Etudiants.PaysIdGROUP BY Pays.PaysId, Pays.NomORDER BY Count(Etudiants.EtudiantId) ASC;
Il est possible également d'utiliser la colonne d'agrégation au lieu de faire le calcul de nouveau.
SELECT Pays.PaysId, Pays.Nom, Count(Etudiants.EtudiantId) AS NbEtudiantFROM PaysLEFT OUTER JOIN Etudiants ON Pays.PaysId = Etudiants.PaysIdGROUP BY Pays.PaysId, Pays.NomORDER BY NbEtudiant ASC;
Voici le résultat.
PaysId Nom NbEtudiant ------ ---------- ---------- 5 États-Unis 0 4 Australie 1 3 Italie 2 2 France 3 1 Canada 5
La clause HAVING
La clause HAVING permet de filtrer les données après que le SELECT et le WHERE aient retourné des résultats.
Elle est indispensable dès qu'un filtre porte sur une colonne calculée, comme c'est le cas avec les fonctions d'agrégations.
Il faut afficher la somme des salaires par ville, mais il faut exclure les villes qui ont moins de 30 000.
Je ne peux faire la requête suivante :
SELECT Ville, Sum(Salaire) AS SommeSalaireFROM EmployesWHERE Sum(Salaire) >= 30000
La requête retourne l'erreur : misuse of aggregate: SUM(), car la fonction d'agrégations ne peut être utilisée dans un WHERE.
Il faut donc utiliser un HAVING
SELECT Ville, Sum(Salaire) AS SommeSalaireFROM EmployesGROUP BY VilleHAVING Sum(Salaire) >= 30000;
Le résultat est ceci.
Ville SommeSalaire ---------- ------------ Lévis 65000.0 Montréal 117000.0 Sherbrooke 45000.0
Donc le HAVING fonctionne comme ceci.
En premier, il faut sortir le regroupement au complet.
SELECT Ville, Sum(Salaire) AS SommeSalaireFROM EmployesGROUP BY Ville;/*Ville SommeSalaire------------- ------------Drummondville 20000.0Lévis 65000.0Magog 10000.0Montréal 117000.0Québec 20000.0Sherbrooke 45000.0*/
Ensuite, la ou les conditions du HAVING sont appliquées.
HAVING Sum(Salaire) >= 30000; Ville SommeSalaire ------------- ------------ Drummondville 20000.0 -- À exclure, car ce n'est pas >= 30000 Lévis 65000.0 Magog 10000.0 -- À exclure, car ce n'est pas >= 30000 Montréal 117000.0 Québec 20000.0 -- À exclure, car ce n'est pas >= 30000 Sherbrooke 45000.0
Les entiers et la division
Si vous divisez deux entiers, le résultat sera la valeur entière de la division.
SELECT 13/3; → 4, et non pas 4.3333
Pour obtenir une réponse en virgule flottante, il suffit de multiplier un des deux entiers par 1.0
SELECT (1.0*13)/3; → 4.333
Il est possible de faire une conversion de type (casting)
SELECT Cast(13 as float)/3; → 4.333
Autres fonctions
Il existe plusieurs fonctions pour effectuer des transformations ou des opérations.
Voici une liste des fonctions : https://www.sqlite.org/lang_corefunc.html
Les plus utilisés sont :
- Upper()
- Mettre une chaine de caractère en majuscule.
- Lower()
- Mettre une chaine de caractère en minuscule.
- SubStr()
- Extraite une sous-chaine.
- Replace()
- Remplacer une chaine de caractères par une autre.
- Length()
- Obtenir la longueur d'une chaine de caractères.
- Round()
- Arrondir une valeur
- Abs()
- Obtenir la valeur absolue d'un nombre.
Exemples
Exercices
Version originale par François St-Hilaire
Produit à partir des notes de Benoit Desrosiers
Mise à jour 2023 par Pierre-Luc Boulanger