SCI6306 Bases de données documentaires

Une expression avant la clause FROM signifie que l'on ne veut pas simplement faire afficher un champ tel quel, mais plutôt une certaine expression calculée à partir d'un ou de plusieurs champs. Voici un exemple d'un tel usage d'une expression : SELECT UCASE(NOM) FROM ETUD;

On peut bien sûr demander l'affichage d'une ou plusieurs expressions et d'un ou plusieurs champs dans le même énoncé SELECT : SELECT NO_PROF, UCASE(NOM), BUREAU FROM PROF;

En réalité, l'ensemble d'une clause WHERE est simplement une expression, qui peut être plus ou moins complexe selon les cas, et qui est souvent composée de sous-expressions reliées entre elles par des opérateurs booléens (le plus souvent, AND : le « et » logique).

La particularité d'une expression constituant une clause WHERE est qu'elle doit « retourner » une valeur de type booléen (ou « logique »). Une valeur booléenne (ou « logique ») est l'une des deux valeurs « VRAI » ou « FAUX ».

Le fait que la clause WHERE d'un énoncé SELECT doive retourner une valeur booléenne veut donc dire qu'en « calculant » la valeur de l'expression pour chacune des lignes de la table à laquelle s'applique l'énoncé, on doit obtenir à chaque fois une valeur finale de « VRAI » ou « FAUX ». Notez que certaines valeurs intermédiaires de l'expression peuvent ne pas être booléennes; l'important est que la valeur finale soit booléenne.

Supposons que NOM soit le nom d'un champ (de type caractère) d'une table à laquelle on applique un énoncé SELECT. Voici un exemple d'expression retournant une valeur booléenne : NOM LIKE 'ber%' Il s'agit d'une forme de comparaison entre deux chaînes de caractères, utilisant l'opérateur LIKE. Cette comparaison donne la valeur VRAI si la chaîne de gauche est conforme au patron de recherche donné par la chaîne de droite. Dans le patron de recherche, le caractère « % » est un caractère générique qui représente 0, 1 ou plusieurs caractères quelconques; il représente donc en fait la troncature. Notez que les valeurs comparées elles-mêmes sont de type caractère, mais le résultat final de l'expression est soit VRAI, soit FAUX; l'expression donne donc bien un résultat de type booléen. En cette qualité, elle pourrait être utilisée comme clause WHERE dans un SELECT : SELECT * FROM ETUD WHERE NOM LIKE 'ber%';

La sélection repêchera donc exactement les lignes de ETUD dans lesquelles le champ NOM commence par « ber » (Berriman, Bernier, Bernard, Bergeron, etc.). L'opérateur LIKE est discuté plus en détail dans la section sur les OPÉRATEURS DE RELATION ci-dessous.

Une expression qui retourne une valeur booléenne s'appelle (très justement, d'ailleurs) une condition. C'est pourquoi on réfère souvent à la clause WHERE d'un énoncé SELECT comme à la condition de sélection de l'énoncé.

Il est à noter que les expressions survenant avant la clause FROM dans un énoncé SELECT ne sont pas soumises, comme la clause WHERE, à des restrictions sur le type de valeurs qu'elles peuvent retourner.

Une constante peut être un nombre, sans guillemet (par ex. 1, 2, 25); une chaîne de caractères où il faut taper les guillemets (par ex. 'A', 'Carmel, Lucie'); une date qui doit être mise entre guillemets (par ex. '1990-01-01'); ou une valeur logique : true pour Vrai et false pour Faux. Une constante se retourne « elle même » comme valeur. Par exemple, la constante 'ABC' retourne comme valeur la chaîne de caractères 'ABC' (qui est bien sûr de type caractère).

Les guillemets doubles sont la plupart du temps acceptés au lieu des guillemets simples, mais pas partout. C'est pourquoi nous avons systématiquement utilisé les guillemets simples dans nos exemples. Pour inscrire un guillemet simple comme caractère dans une chaîne, il suffit de le doubler (l'inscrire deux fois, et non inscrire un guillemet double), par exemple : 'L''hiver', ou le faire précéder d'une barre oblique inversée, par exemple 'L\'hiver'.

Il s'agit des noms de champ de la table à laquelle s'applique l'énoncé. Par exemple, dans un énoncé travaillant sur la table ETUD, les noms de champ sont NO_ETUD, NOM, ADRESSE et DAT_NAIS. Pour chaque ligne sur laquelle l'énoncé travaille, la valeur retournée par un nom de champ est le contenu du champ correspondant dans la ligne en question. Un champ numérique retourne une valeur numérique, un champ logique une valeur logique, un champ date une valeur date, et un champ caractère, une valeur caractère.

Si un énoncé implique un nom de champs identique entre deux tables (par exemple, pour une jointure) qu'il peut y avoir ambiguïté sur la provenance d'un champ, on fait précéder le nom du champ du nom de la table d'où il provient suivi d'un point (e.g. ETUD.NO_ETUD).

Les noms de variable sont analogues aux constantes, mais au lieu de retourner toujours la même valeur, elles retournent une valeur définie, par exemple, par l'utilisateur ou l'utilisatrice. Les noms de variables sont précédés par un arobas (@).

Il s'agit d'opérateurs permettant d'effectuer certains calculs sur des valeurs. Les opérateurs +, , * et /, appliqués à des valeurs numériques, correspondent aux quatre opérations arithmétiques usuelles.

Les opérateurs de relation sont similaires aux opérateurs de transformation, mais retournent toujours une valeur logique. Il s'agit par exemple d'opérateurs comme = (égal à), <> (différent de), <= (plus petit ou égal à), >= (plus grand ou égal à). Les opérateurs de relation retournent la valeur VRAI ou FAUX dépendant que la comparaison à laquelle ils correspondent est vraie ou fausse avec les valeurs qui leur sont fournies. Ainsi, l'expression 1=2 retourne la valeur FAUX, alors que 1<>2 retourne VRAI. L'expression 'ABC'<'B' a la valeur VRAI.

Un opérateur de relation utile pour les champs de type texte est l'opérateur LIKE. Cet opérateur recherche une chaîne de caractères dans un ou des champs de type caractère, et offre des possibilités de masquage et de troncature, avec les caractères '_' (masquage d'un seul caractère) et '%' (troncature, utilisable à gauche, à droite ou à l'intérieur d'une chaîne).

Un autre opérateur de relation important est le IN. Utilisé le plus souvent en conjonction avec une sous-requête, il permet de vérifier si une valeur apparaît dans une liste (par ex. NO_ETUD IN (10001, 10002)).

Il s'agit de fonctions permettant de calculer certaines valeurs à partir d'autres valeurs. Dans une condition de sélection, les valeurs sur lesquelles on appliquera des fonctions seront surtout des valeurs provenant de champs de la table à laquelle s'applique l'énoncé SELECT. Les valeurs sur lesquelles une fonction doit opérer sont données entre parenthèses après le nom de la fonction, et séparées entre elles par des virgules s'il y en a plus d'une. On appelle ces valeurs les « arguments » de la fonction. Le nombre d'arguments que l'on doit fournir à une fonction, de même que leur type, dépendent de la fonction elle même, et sont indiqués dans la documentation de la fonction. La valeur retournée par une fonction est le résultat d'un calcul effectué par la fonction sur les valeurs spécifiques qu'on lui fournit en arguments.

Les fonctions UCASE et LCASE prennent toutes deux en argument une valeur de type caractère et retournent respectivement la chaîne de caractères en majuscules et en minuscules. À titre d'exemple, l'expression LCASE('Géographie 102') retourne la valeur 'géographie 102'. Évidemment, si le champ TITRE d'une des lignes d'une table à laquelle on applique un énoncé SELECT contient la chaîne 'Géographie 102', alors l'expression LCASE(TITRE) retournera aussi la valeur 'géographie 102' pour cette ligne.

La fonction CONCAT permet de concaténer (c'est-à-dire de « coller ensemble ») les valeurs de différentes expressions pour un enregistrement (valeurs d'un champ, chaîne de texte fixe, résultat d'une autre fonction, etc.). À titre d'exemple, l'expression CONCAT(NO_ETUD," / ", UCASE(NOM)) retournera ‘10004 / ASIMOV, ISAAC' pour la ligne correspondant à cet étudiant.

La fonction GROUP_CONCAT permet de concaténer (c'est-à-dire de « coller ensemble ») les valeurs des différents enregistrements regroupés par une clause GROUP BY. À titre d'exemple, l'expression GROUP_CONCAT(ETUD.NO_ETUD separator ‘, ‘) pour un regroupement par cours retournera la liste concaténée de tous les numéros d'étudiant.e.s suivant le même cours comme ‘10004, 10002'.

Les fonctions CURRENT_DATE(), CURRENT_TIME(), CURRENT_TIMESTAMP() sont des fonctions SANS ARGUMENT, ce qui fait qu'elle apparaît toujours sous la forme « CURRENT_DATE() » (avec les parenthèses et rien dedans) dans une expression. Un synonyme de CURRENT_TIMESTAMP() est NOW(). Ces fonctions retournent une valeur de type date, respectivement égales à la date courante du jour, à l'heure courante du jour, à la date et l'heure courante du jour, telles que réglées au niveau du serveur. On peut utiliser ces fonctions comme n'importe quelle valeur de type date dans une expression.

La fonction DATE_FORMAT est une fonction permettant de changer le format d'un champ de type « date/heure ». Elle prend la forme : DATE_FORMAT(« nom du champ », « format désiré ») où « format désiré » est une combinaison des différentes possibilités d'affichage du jour, du mois, de l'année et de l'heure, combinaison indiquée entre guillemets simples ou doubles. Les principales possibilités sont :

• %d affiche le jour en format numérique à 2 chiffres (e.g. 01, 31)

• %a affiche le jour en format textuel abrégé (lun., mar., etc.)

• %W affiche le jour en format textuel complet (lundi, mardi, etc.)

• %m affiche le mois en format numérique à 2 chiffres (e.g. 01, 12)

• %b affiche le mois en format textuel abrégé (janv, fév, etc.)

• %M affiche le mois en format textuel complet (janvier, février, etc.)

• %y affiche l'année en format numérique à 2 chiffres (e.g. 99, 01)

• %Y affiche l'année en format à 4 chiffres

Exemples : soit le champ date_naissance avec comme valeur « 10 novembre 2009 »

• DATE_FORMAT(date_naissance,'%Y') affichera « 2009 »

• DATE_FORMAT(date_naissance,'%y') affichera « 09 »

• DATE_FORMAT(date_naissance,'%W %d %M %Y') affichera « mardi 10 novembre 2009 »

Toute chaîne de caractère dans le format désiré qui ne correspond pas à un des éléments de date ou d'heure sera indiqué tel quel. Par exemple, DATE_FORMAT(date_naissance,'%W, le %d %M %Y') affichera « mardi, le 10 novembre 2009 ».

Le système vous retourne les noms des mois ou des jours en anglais et vous les voudriez en français? Ajoutez la ligne suivante avant votre énoncé SELECT pour modifier la langue utilisée :SET lc_time_names = 'fr_FR';

La fonction DATEDIFF permet de calculer la différence entre deux dates en nombre de jours.

La fonction EXISTS, utilisée avec une sous-requête, permet de tester si le résultat de la sous-requête est vide ou non.

La fonction IF permet de sélectionner une de deux valeurs en fonction d'une condition. Cette fonction comporte trois arguments : IF(condition, valeur si vrai, valeur si faux). Par exemple, l'expression « IF (prix > 1000, 'Cher', 'Abordable') » retournera la chaîne 'Cher' si prix est supérieur à 1000 et 'Abordable' autrement.

La fonction ISNULL permet de vérifier si un champ (ou une valeur quelconque) est NULL. Par exemple, « IsNull(local) » retournera la valeur booléenne VRAI si le champ « local » contient la valeur NULL, et FAUX autrement.

La fonction IFNULL permet de vérifier si un champ (ou une valeur quelconque) est NULL et, si c'est le cas, d'afficher autre chose que NULL. Par exemple, « IfNull(local,'Aucun local assigné') » retournera la chaîne de caracètre ‘Aucun local assigné' si le champ « local » contient la valeur NULL, et le local autrement.

La fonction ROUND permet d'arrondir une valeur numérique. Cette fonction demande deux arguments : (1) le nom du champ, et (2) le nombre de décimales souhaité. Par exemple, « round(note,0) » permet d'arrondir le contenu du champ « note » à un nombre entier (c'est-à-dire sans décimales).

Les opérateurs booléens sont similaires aux opérateurs de transformation, mais opèrent toujours sur des valeurs logiques, et retournent toujours également une valeur logique. Il s'agit de AND, OR et NOT. Ces opérateurs permettent de combiner plusieurs valeurs logiques selon les règles de la logique booléenne.

Les parenthèses sont utilisées pour modifier l'ordre d'évaluation des expressions. Les différents opérateurs dans Access ont une priorité relative qui détermine lesquels sont exécutés en premier, en l'absence de parenthèses. On peut mémoriser ces priorités relatives, et n'utiliser les parenthèses que lorsqu'elles sont absolument nécessaires. Une autre approche, plus simple, consiste à toujours utiliser des parenthèses dès qu'il y aurait ambiguïté possible, même s'il pouvait s'avérer qu'elles ne soient pas nécessaires. Il est toujours permis d'utiliser autant de niveaux de parenthèses que l'on veut.

Ainsi, l'expression : (LCASE(CONCAT('A','B'))) est tout à fait valide, et retourne la valeur caractère 'ab'.