Sélection de données de table
Remarque : pour terminer les tutoriels et les exemples de cette section, vous devez être connecté à Oracle Database en tant qu'utilisateur HR de SQL Developer. Pour obtenir des instructions, reportez-vous à Connexion à Oracle Database en tant qu'utilisateur RH à partir de SQL Developer.
A propos des requêtes
Une requête, ou instruction SQL SELECT, permet de sélectionner des données dans des tables ou vues.
La syntaxe de la forme de requête la plus simple est la suivante :
SELECT select_list FROM source_listLa valeur select_list indique les colonnes dans lesquelles sélectionner des données et l'élément source_list indique les tables ou les vues qui contiennent ces colonnes.
Une requête imbriquée dans une autre instruction SQL est appelée une requête imbriquée.
Dans l'environnement SQL*Plus, vous pouvez entrer une requête (ou toute autre instruction SQL) après l'invite SQL>.
Dans l'environnement SQL Developer, vous pouvez entrer une requête (ou toute autre instruction SQL) dans la feuille de calcul.
Remarque : lorsque les résultats d'une requête sont affichés, les enregistrements peuvent figurer dans n'importe quel ordre, sauf si vous indiquez leur ordre avec la clause ORDER BY. Pour plus d'informations, reportez-vous à la section "Tri des données sélectionnées".
Voir aussi :
-
Manuel Oracle Database SQL Language Reference pour plus d'informations sur les requêtes et les requêtes imbriquées
-
Oracle Database SQL Language Reference, pour plus d'informations sur l'instruction SELECT
-
Guide de l'utilisateur et référence SQL*Plus, pour plus d'informations sur l'interface de ligne de commande SQL*Plus
-
Guide de l'utilisateur Oracle SQL Developer, pour plus d'informations sur l'utilisation de la feuille de calcul dans SQL Developer
Exécution de requêtes dans SQL Developer
Cette section explique comment exécuter des requêtes dans SQL Developer à l'aide de la feuille de calcul.
Remarque : La feuille de calcul n'est pas limitée aux requêtes. Vous pouvez l'utiliser pour exécuter n'importe quelle instruction SQL.
Etapes d'exécution des requêtes dans SQL Developer :
-
Si le cadre droit de SQL Developer affiche le volet hr_conn :
-
Si le sous-volet Feuille de travail ne s'affiche pas, sélectionnez l'onglet Feuille de travail.
-
Accédez à l'étape 4.
-
-
Cliquez sur l'icône Feuille de calcul SQL.
-
Si la fenêtre Sélectionner une connexion apparaît :
-
Si le champ Connexion n'a pas la valeur
hr_conn, sélectionnez-la dans le menu. -
Sélectionnez OK.
Un volet s'affiche avec un onglet intitulé hr_conn et deux sous-volets, Worksheet et Query Builder. Dans la feuille de calcul, vous pouvez saisir une instruction SQL.
-
-
Dans la feuille de calcul, saisissez une requête (instruction SELECT).
-
Cliquez sur l'icône Run Statement (Exécuter une instruction).
La requête est exécutée. Sous Worksheet, le volet Query Result apparaît et affiche le résultat de la requête.
-
Sous l'onglet hr_conn, cliquez sur l'icône Effacer.
La requête disparaît et vous pouvez entrer une autre instruction SQL dans la feuille de calcul. Lorsque vous exécutez une autre instruction SQL, son résultat apparaît dans le volet Query Result, remplaçant le résultat de l'instruction SQL précédemment exécutée.
Voir aussi : Guide de l'utilisateur Oracle SQL Developer pour plus d'informations sur l'utilisation de la feuille de calcul dans SQL Developer
Tutoriel : Sélection de l'ensemble des colonnes d'une table
Ce tutoriel explique comment sélectionner l'ensemble des colonnes de la table EMPLOYEES.
Pour sélectionner toutes les colonnes de la page EMPLOYEES - Etapes :
-
Si un volet contenant l'onglet hr_conn s'affiche, sélectionnez-le. Sinon, cliquez sur l'icône Feuille de calcul SQL, comme dans "Exécution de requêtes dans SQL Developer".
-
Dans la feuille de calcul, entrez l'interrogation suivante :
SELECT * FROM EMPLOYEES; -
Cliquez sur l'icône Exécuter l'instruction.
La requête est exécutée. Sous Worksheet, le volet Query Result apparaît et affiche toutes les colonnes de la table EMPLOYEES.
Attention : Soyez très prudent lorsque vous utilisez SELECT * sur des tables contenant des colonnes qui stockent des données confidentielles, telles que des mots de passe ou des informations de carte de crédit.
Voir aussi : "Tutoriel : Visualisation des propriétés et des données de table EMPLOYEES avec SQL Developer" pour plus d'informations sur une autre façon de visualiser les données de table avec SQL Developer
Tutoriel : Sélection de colonnes spécifiques dans une table
Ce tutoriel explique comment sélectionner uniquement les colonnes FIRST_NAME, LAST_NAME et DEPARTMENT_ID de la table EMPLOYEES.
Etapes de sélection des colonnes FIRST_NAME, LAST_NAME et DEPARTMENT_ID uniquement :
-
Si un volet contenant l'onglet hr_conn s'affiche, sélectionnez-le. Sinon, cliquez sur l'icône SQL Worksheet, comme dans "Exécution de requêtes dans SQL Developer".
-
Si le panneau Feuille de calcul contient une requête, effacez-la en sélectionnant l'icône Effacer.
-
Dans la feuille de calcul, entrez l'interrogation suivante :
SELECT FIRST_NAME, LAST_NAME, DEPARTMENT_ID FROM EMPLOYEES; -
Cliquez sur l'icône Exécuter l'instruction.
La requête est exécutée. Sous Feuille de travail, le volet Résultat de la requête s'affiche, affichant les résultats de la requête, qui sont similaires au texte suivant.
FIRST_NAME LAST_NAME DEPARTMENT_ID
-------------------- ------------------------- -------------
Donald OConnell 50
Douglas Grant 50
Jennifer Whalen 10
Michael Hartstein 20
Pat Fay 20
Susan Mavris 40
Hermann Baer 70
Shelley Higgins 110
William Gietz 110
Steven King 90
Neena Kochhar 90
FIRST_NAME LAST_NAME DEPARTMENT_ID
-------------------- ------------------------- -------------
Lex De Haan 90
...
Kevin Feeney 50
107 rows selected.Affichage de colonnes sélectionnées sous de nouveaux en-têtes
Dans les résultats de requête affichés, les en-têtes de colonne par défaut sont des noms de colonne. Pour afficher une colonne sous un nouvel en-tête (alias), indiquez-la immédiatement après le nom de colonne. L'alias remplace le nom de la colonne pendant la requête, mais pas dans la base de données.
La requête de l'Exemple 2-5 permet de sélectionner les mêmes colonnes que dans la rubrique Tutoriel : Sélection de colonnes spécifiques d'une table et d'indiquer également les alias pour ces colonnes. Puisque les alias ne figurent pas entre guillemets doubles, ils sont affichés en lettres majuscules.
Si vous placez les alias de colonne entre guillemets doubles, la casse est conservée et les alias peuvent comprendre des espaces, comme dans l'Example 2-6.
Voir aussi : Oracle Database SQL Language Reference pour plus d'informations sur l'instruction SELECT, y compris l'alias de colonne (c_alias)
Exemple 2-5 Affichage de colonnes sélectionnées sous de nouveaux en-têtes
SELECT FIRST_NAME First, LAST_NAME last, DEPARTMENT_ID DepT
FROM EMPLOYEES;Le résultat obtenu est similaire au texte suivant :
FIRST LAST DEPT
-------------------- ------------------------- ----------
Donald OConnell 50
Douglas Grant 50
Jennifer Whalen 10
Michael Hartstein 20
Pat Fay 20
Susan Mavris 40
Hermann Baer 70
Shelley Higgins 110
William Gietz 110
Steven King 90
Neena Kochhar 90
FIRST LAST DEPT
-------------------- ------------------------- ----------
Lex De Haan 90
...
Kevin Feeney 50
107 rows selected.Exemple 2-6 : conservation de la casse et inclusion d'espaces dans les alias de colonne
SELECT FIRST_NAME "Given Name", LAST_NAME "Family Name"
FROM EMPLOYEES;Le résultat obtenu est similaire au texte suivant :
Given Name Family Name
-------------------- -------------------------
Donald OConnell
Douglas Grant
Jennifer Whalen
Michael Hartstein
Pat Fay
Susan Mavris
Hermann Baer
Shelley Higgins
William Gietz
Steven King
Neena Kochhar
Given Name Family Name
-------------------- -------------------------
Lex De Haan
...
Kevin Feeney
107 rows selected.Sélection de données vérifiant des conditions indiquées
Pour sélectionner uniquement des données vérifiant une condition indiquée, ajoutez la clause WHERE dans l'instruction SELECT.
La condition dans la clause WHERE peut être une condition SQL quelconque (Pour plus d'informations sur les conditions SQL, reportez-vous à Oracle Database SQL Language Reference).
La requête de l'Exemple 2-7 sélectionne uniquement les données des employés du service 90.
Pour sélectionner des données uniquement pour les employés des services 100, 110 et 120, utilisez la clause WHERE suivante :
WHERE DEPARTMENT_ID IN (100, 110, 120);La requête de l'Exemple 2-8 sélectionne uniquement les données des employés dont le nom commence par "Ma".
Pour sélectionner des données uniquement pour les employés dont le nom inclut "ma", utilisez la clause WHERE suivante :
WHERE LAST_NAME LIKE '%ma%';L'interrogation de l'Exemple 2-9 vérifie deux conditions : si le salaire est d'au moins 11000 et si le pourcentage de commission n'est pas NULL.
Voir aussi :
-
Manuel Oracle Database SQL Language Reference pour plus d'informations sur l'instruction SELECT, y compris la clause WHERE
-
Manuel Oracle Database SQL Language Reference pour plus d'informations sur les conditions SQL
Exemple 2-7 Sélection de données d'un seul service
SELECT FIRST_NAME, LAST_NAME, DEPARTMENT_ID
FROM EMPLOYEES
WHERE DEPARTMENT_ID = 90;Le résultat obtenu est similaire au texte suivant :
FIRST_NAME LAST_NAME DEPARTMENT_ID
-------------------- ------------------------- -------------
Steven King 90
Neena Kochhar 90
Lex De Haan 90
3 rows selected.Exemple 2-8 Sélection de données pour les noms commençant par la même sous-chaîne
SELECT FIRST_NAME, LAST_NAME
FROM EMPLOYEES
WHERE LAST_NAME LIKE 'Ma%';Le résultat obtenu est similaire au texte suivant :
FIRST_NAME LAST_NAME
-------------------- -------------------------
Jason Mallin
Steven Markle
James Marlow
Mattea Marvins
Randall Matos
Susan Mavris
6 rows selected.Exemple 2-9 Sélection de données vérifiant deux conditions
SELECT FIRST_NAME, LAST_NAME, SALARY, COMMISSION_PCT "%"
FROM EMPLOYEES
WHERE (SALARY >= 11000) AND (COMMISSION_PCT IS NOT NULL);Le résultat obtenu est similaire au texte suivant :
FIRST_NAME LAST_NAME SALARY %
-------------------- ------------------------- ---------- ----------
John Russell 14000 .4
Karen Partners 13500 .3
Alberto Errazuriz 12000 .3
Gerald Cambrault 11000 .3
Lisa Ozer 11500 .25
Ellen Abel 11000 .3
6 rows selected.Tri des données sélectionnées
Lorsque des résultats d'une requête sont affichés, les enregistrements peuvent figurer dans n'importe quel ordre, sauf si vous indiquez leur ordre avec la clause ORDER BY.
Les résultats de la requête de l'Example 2-10 sont triés par LAST_NAME, dans l'ordre croissant (valeur par défaut).
Dans SQL Developer, vous pouvez également omettre la clause ORDER BY et double-cliquer sur le nom de la colonne à trier.
Le critère de tri n'a pas besoin d'être inclus dans la liste de sélection, comme le montre l'exemple 2-11.
Voir aussi : Oracle Database SQL Language Reference pour plus d'informations sur l'instruction SELECT, y compris la clause ORDER BY.
Exemple 2-10 Tri des données sélectionnées en fonction de La valeur LAST_NAME
SELECT FIRST_NAME, LAST_NAME, HIRE_DATE
FROM EMPLOYEES
ORDER BY LAST_NAME;Résultats :
FIRST_NAME LAST_NAME HIRE_DATE
-------------------- ------------------------- ---------
Ellen Abel 11-MAY-04
Sundar Ande 24-MAR-08
Mozhe Atkinson 30-OCT-05
David Austin 25-JUN-05
Hermann Baer 07-JUN-02
Shelli Baida 24-DEC-05
Amit Banda 21-APR-08
Elizabeth Bates 24-MAR-07
...
FIRST_NAME LAST_NAME HIRE_DATE
-------------------- ------------------------- ---------
Jose Manuel Urman 07-MAR-06
Peter Vargas 09-JUL-06
Clara Vishney 11-NOV-05
Shanta Vollman 10-OCT-05
Alana Walsh 24-APR-06
Matthew Weiss 18-JUL-04
Jennifer Whalen 17-SEP-03
Eleni Zlotkey 29-JAN-08
107 rows selectedExemple 2-11 Tri des données sélectionnées en fonction d'une colonne non sélectionnée
SELECT FIRST_NAME, HIRE_DATE
FROM EMPLOYEES
ORDER BY LAST_NAME;Résultats :
FIRST_NAME HIRE_DATE
-------------------- ---------
Ellen 11-MAY-04
Sundar 24-MAR-08
Mozhe 30-OCT-05
David 25-JUN-05
Hermann 07-JUN-02
Shelli 24-DEC-05
Amit 21-APR-08
Elizabeth 24-MAR-07
...
FIRST_NAME HIRE_DATE
-------------------- ---------
Jose Manuel 07-MAR-06
Peter 09-JUL-06
Clara 11-NOV-05
Shanta 10-OCT-05
Alana 24-APR-06
Matthew 18-JUL-04
Jennifer 17-SEP-03
Eleni 29-JAN-08
107 rows selected.Sélection de données dans plusieurs tables
Pour sélectionner des données dans plusieurs tables, vous utilisez une requête appelée jointure. Les tables d'une jointure doivent partager au moins un nom de colonne.
Supposons que vous voulez sélectionner les valeurs FIRST_NAME, LAST_NAME et DEPARTMENT_NAME correspondant à chaque employé. FIRST_NAME et LAST_NAME figurent dans la table EMPLOYEES et DEPARTMENT_NAME dans la table DEPARTMENTS. Les deux tables comportent DEPARTMENT_ID. Vous pouvez utiliser la requête dans l'Example 2-12.
Les qualificatifs de nom de table sont facultatifs pour les noms de colonne figurant dans une seule table d'une jointure, mais obligatoires pour les noms de colonne présents dans les deux tables. La requête suivante est équivalente à la requête de l'Example 2-12 :
SELECT FIRST_NAME "First",
LAST_NAME "Last",
DEPARTMENT_NAME "Dept. Name"
FROM EMPLOYEES, DEPARTMENTS
WHERE EMPLOYEES.DEPARTMENT_ID = DEPARTMENTS.DEPARTMENT_ID
ORDER BY DEPARTMENT_NAME, LAST_NAME;Pour rendre plus lisibles les requêtes qui utilisent des noms d'une colonne qualifiée, utilisez des alias de table, comme indiqué dans l'exemple suivant :
SELECT FIRST_NAME "First",
LAST_NAME "Last",
DEPARTMENT_NAME "Dept. Name"
FROM EMPLOYEES e, DEPARTMENTS d
WHERE e.DEPARTMENT_ID = d.DEPARTMENT_ID
ORDER BY d.DEPARTMENT_NAME, e.LAST_NAME;Bien que vous ayez créé les alias dans la clause FROM, vous pouvez les utiliser plus tôt dans la requête, comme l'illustre l'exemple suivant.
SELECT e.FIRST_NAME "First",
e.LAST_NAME "Last",
d.DEPARTMENT_NAME "Dept. Name"
FROM EMPLOYEES e, DEPARTMENTS d
WHERE e.DEPARTMENT_ID = d.DEPARTMENT_ID
ORDER BY d.DEPARTMENT_NAME, e.LAST_NAME;Voir aussi : Oracle Database SQL Language Reference, pour plus d'informations sur les jointures
Exemple 2-12 Sélection de données à partir de deux tables (jointure de deux tables)
SELECT EMPLOYEES.FIRST_NAME "First",
EMPLOYEES.LAST_NAME "Last",
DEPARTMENTS.DEPARTMENT_NAME "Dept. Name"
FROM EMPLOYEES, DEPARTMENTS
WHERE EMPLOYEES.DEPARTMENT_ID = DEPARTMENTS.DEPARTMENT_ID
ORDER BY DEPARTMENTS.DEPARTMENT_NAME, EMPLOYEES.LAST_NAME;Résultats :
First Last Dept. Name
-------------------- ------------------------- ------------------------------
William Gietz Accounting
Shelley Higgins Accounting
Jennifer Whalen Administration
Lex De Haan Executive
Steven King Executive
Neena Kochhar Executive
John Chen Finance
...
Jose Manuel Urman Finance
Susan Mavris Human Resources
David Austin IT
...
Valli Pataballa IT
Pat Fay Marketing
Michael Hartstein Marketing
Hermann Baer Public Relations
Shelli Baida Purchasing
...
Sigal Tobias Purchasing
Ellen Abel Sales
...
Eleni Zlotkey Sales
Mozhe Atkinson Shipping
...
Matthew Weiss Shipping
106 rows selected.Utilisation d'opérateurs et de fonctions dans les requêtes
L'élément select_list d'une requête peut comprendre des expressions SQL qui peuvent elles-mêmes inclure des opérateurs SQL et des fonctions SQL. Ces opérateurs et ces fonctions peuvent employer des données de table comme opérandes et arguments. Les expressions SQL sont évaluées et leurs valeurs s'affichent dans les résultats de la requête.
Voir aussi :
-
Manuel Oracle Database SQL Language Reference, pour plus d'informations sur les opérateurs SQL
-
Manuel Oracle Database SQL Language Reference, pour plus d'informations sur les fonctions SQL
Utilisation d'opérateurs arithmétiques dans les requêtes
Les opérateurs arithmétiques de base (+ (addition), - (soustraction), \* (multiplication) et / (division) fonctionnent sur les valeurs de colonne.
La requête dans l'exemple 2-13 permet d'afficher les valeurs LAST_NAME, SALARY (salaire mensuel), et le salaire annuel pour chaque employé du service 90, par ordre décroissant de la valeur SALARY.
Exemple 2-13 Utilisation d'une expression arithmétique dans une requête
SELECT LAST_NAME,
SALARY "Monthly Pay",
SALARY * 12 "Annual Pay"
FROM EMPLOYEES
WHERE DEPARTMENT_ID = 90
ORDER BY SALARY DESC;Résultats :
LAST_NAME Monthly Pay Annual Pay
------------------------- ----------- ----------
King 24000 288000
De Haan 17000 204000
Kochhar 17000 204000Utilisation de fonctions numériques dans les requêtes
Les fonctions numériques acceptent des entrées numériques et renvoient des valeurs numériques. Chaque fonction numérique renvoie une seule valeur par ligne évaluée.
Les fonctions numériques que prend en charge SQL sont répertoriées et décrites dans le manuel Oracle Database SQL Language Reference.
La requête dans l'exemple 2-14 emploie la fonction numérique ROUND pour afficher le salaire journalier de chaque employé du service 100, arrondi au centime le plus proche.
La requête dans l'exemple 2-15 emploie la fonction numérique TRUNC pour afficher le salaire journalier de chaque employé du service 100, arrondi au dollar le plus proche.
Voir aussi : Oracle Database SQL Language Reference, pour plus d'informations sur les fonctions SQL numériques.
Exemple 2-14 Arrondi des données numériques
SELECT LAST_NAME,
ROUND (((SALARY * 12)/365), 2) "Daily Pay"
FROM EMPLOYEES
WHERE DEPARTMENT_ID = 100
ORDER BY LAST_NAME;Résultats :
LAST_NAME Daily Pay
------------------------- ----------
Chen 269.59
Faviet 295.89
Greenberg 394.52
Popp 226.85
Sciarra 253.15
Urman 256.44
6 rows selected.Exemple 2-15 Troncation de données numériques
SELECT LAST_NAME,
TRUNC ((SALARY * 12)/365) "Daily Pay"
FROM EMPLOYEES
WHERE DEPARTMENT_ID = 100
ORDER BY LAST_NAME;Résultats :
LAST_NAME Daily Pay
------------------------- ----------
Chen 269
Faviet 295
Greenberg 394
Popp 226
Sciarra 253
Urman 256
6 rows selected.Utilisation de l'opérateur de concaténation dans les requêtes
L'opérateur de concaténation (||) combine deux chaînes en une seule, en ajoutant la deuxième chaîne à la première. Par exemple, 'a'||'b'='ab'. Cet opérateur permet de combiner les informations de deux colonnes ou expressions dans une même colonne d'un résultat de requête.
La requête de l'Exemple 2-16 concatène le prénom, un espace et le nom de chaque employé sélectionné.
Voir aussi : Oracle Database SQL Language Reference, pour plus d'informations sur l'opérateur de concaténation.
Exemple 2-16 Concaténation de données alphanumériques
SELECT FIRST_NAME || ' ' || LAST_NAME "Name"
FROM EMPLOYEES
WHERE DEPARTMENT_ID = 100
ORDER BY LAST_NAME;Résultats :
Name
----------------------------------------------
John Chen
Daniel Faviet
Nancy Greenberg
Luis Popp
Ismael Sciarra
Jose Manuel Urman
6 rows selected.Utilisation de fonctions de caractère dans les requêtes
Les fonctions de caractère acceptent les entrées de caractère. La plupart de ces fonctions renvoient des valeurs alphanumériques, mais certaines renvoient des valeurs numériques. Chaque fonction de caractère renvoie une seule valeur par ligne évaluée.
Les fonctions de caractère que prend en charge SQL sont répertoriées et décrites dans le manuel Oracle Database SQL Language Reference.
Les fonctions UPPER, INITCAP et LOWER affichent respectivement leurs arguments alphanumérique en majuscules, majuscule initiale et minuscules.
La requête de l'Exemple 2-17 affiche la valeur LAST_NAME en majuscules, la valeur FIRST_NAME avec le premier caractère en majuscule et les autres en minuscules, et la valeur EMAIL en minuscules.
Voir aussi : Oracle Database SQL Language Reference pour plus d'informations sur les fonctions SQL de type caractère.
Exemple 2-17 Modification de la casse des données alphanumériques
SELECT UPPER(LAST_NAME) "Last",
INITCAP(FIRST_NAME) "First",
LOWER(EMAIL) "E-Mail"
FROM EMPLOYEES
WHERE DEPARTMENT_ID = 100
ORDER BY EMAIL;Résultats :
Last First E-Mail
------------------------- -------------------- -------------------------
FAVIET Daniel dfaviet
SCIARRA Ismael isciarra
CHEN John jchen
URMAN Jose Manuel jmurman
POPP Luis lpopp
GREENBERG Nancy ngreenbe
6 rows selected.Utilisation de fonctions date/heure dans les requêtes
Les fonctions de DATE/heure fonctionnent sur les valeurs DATE, d'horodatage et d'intervalle. Chaque fonction date/heure renvoie une seule valeur par ligne évaluée.
Les fonctions date/heure que prend en charge SQL sont répertoriées et décrites dans le manuel Oracle Database SQL Language Reference.
Pour chaque valeur DATE et horodatage, Oracle Database stocke les informations suivantes :
-
Year
-
Month
-
Date
-
Hour
-
Minute
-
Second
Pour chaque valeur d'horodatage, Oracle Database stocke également la partie fractionnaire de la seconde, dont vous pouvez indiquer la précision. Pour stocker également le fuseau horaire, utilisez le type de données TIMESTAMP WITH TIME ZONE ou TIMESTAMP WITH LOCAL TIME ZONE.
Pour plus d'informations sur le type de données DATE, reportez-vous à Référence de langage SQL Oracle Database.
Pour plus d'informations sur le type de données TIMESTAMP, reportez-vous à Référence du langage SQL Oracle Database.
Pour plus d'informations sur les autres types de données d'horodatage et les types de données d'intervalle, reportez-vous à Référence du langage SQL Oracle Database.
La requête dans l'exemple 2-18 utilise les fonctions EXTRACT et SYSDATE pour afficher le nombre d'années d'embauche de chaque employé du service 100. La fonction SYSDATE renvoie la DATE actuelle de l'horloge système en tant que valeur DATE. Pour plus d'informations sur la fonction SYSDATE, reportez-vous au document Oracle Database SQL Language Reference. Pour plus d'autres informations sur la fonction EXTRACT, reportez-vous au manuelOracle Database SQL Language Reference.
La requête de l'Exemple 2-19 utilise la fonction SYSTIMESTAMP pour afficher la date et l'heure système actuelles. La fonction SYSTIMESTAMP renvoie une valeur TIMESTAMP. Pour plus d'autres informations sur la fonction SYSTIMESTAMP, reportez-vous au manuelOracle Database SQL Language Reference.
La table de la clause FROM de l'interrogation, DUAL, est une table monoligne créée automatiquement par Oracle Database avec le dictionnaire de données. Sélectionnez DUAL lorsque vous voulez calculer une expression constante avec l'instruction SELECT. Puisque DUAL ne comporte qu'une seule ligne, la constante n'est renvoyée qu'une seule fois. Pour plus d'informations sur la sélection à partir de DUAL, reportez-vous au guide Oracle Database SQL Language Reference.
Voir aussi : Oracle Database SQL Language Reference, pour plus d'informations sur les fonctions SQL de date/heure
Exemple 2-18 Affichage du nombre d'années entre les dates
SELECT LAST_NAME,
(EXTRACT(YEAR FROM SYSDATE) - EXTRACT(YEAR FROM HIRE_DATE)) "Years Employed"
FROM EMPLOYEES
WHERE DEPARTMENT_ID = 100
ORDER BY "Years Employed";Résultats :
LAST_NAME Years Employed
------------------------- --------------
Popp 5
Urman 6
Chen 7
Sciarra 7
Greenberg 10
Faviet 10
6 rows selected.Exemple 2-19 Affichage de la date et de l'heure du système
SELECT EXTRACT(HOUR FROM SYSTIMESTAMP) || ':' ||
EXTRACT(MINUTE FROM SYSTIMESTAMP) || ':' ||
ROUND(EXTRACT(SECOND FROM SYSTIMESTAMP), 0) || ', ' ||
EXTRACT(MONTH FROM SYSTIMESTAMP) || '/' ||
EXTRACT(DAY FROM SYSTIMESTAMP) || '/' ||
EXTRACT(YEAR FROM SYSTIMESTAMP) "System Time and Date"
FROM DUAL;Les résultats dépendent de la valeur SYSTIMESTAMP en cours, mais ils respectent le format suivant :
System Time and Date
-------------------------------------------------------------------
18:17:53, 12/27/2012Utilisation de fonctions de conversion dans les requêtes
Les fonctions de conversion permettent d'effectuer des conversion entre les différents types de données.
Les fonctions de conversion que prend en charge SQL sont répertoriées et décrites dans le manuel Oracle Database SQL Language Reference.
La requête dans l'Exemple 2-20 utilise la fonction TO_CHAR pour convertir les valeurs HIRE_DATE (de type DATE) en valeurs alphanumérique au format FMMonth DD YYYY. FM supprime les blancs de début et de fin du nom du mois. FMMonth DD YYYY est un exemple de modèle de format de date/heure. Pour plus d'informations sur les modèles de format date/heure, reportez-vous au manuel Oracle Database SQL Language Reference.
La requête dans l'Exemple 2-21 utilise la fonction TO_NUMBER pour convertir les valeurs POSTAL_CODE (de type VARCHAR2) en valeurs de type NUMBER, qu'elle utilise dans les calculs.
Voir aussi :
-
Manuel Oracle Database SQL Language Reference, pour plus d'informations sur les fonctions d'exécution SQL
Exemple 2-20 Conversion de dates en caractère à l'aide d'un modèle de format
SELECT LAST_NAME,
HIRE_DATE,
TO_CHAR(HIRE_DATE, 'FMMonth DD YYYY') "Date Started"
FROM EMPLOYEES
WHERE DEPARTMENT_ID = 100
ORDER BY LAST_NAME;Résultats :
LAST_NAME HIRE_DATE Date Started
------------------------- --------- -----------------
Chen 28-SEP-05 September 28 2005
Faviet 16-AUG-02 August 16 2002
Greenberg 17-AUG-02 August 17 2002
Popp 07-DEC-07 December 7 2007
Sciarra 30-SEP-05 September 30 2005
Urman 07-MAR-06 March 7 2006
6 rows selected.Exemple 2-21 Conversion de caractères en nombres
SELECT CITY,
POSTAL_CODE "Old Code",
TO_NUMBER(POSTAL_CODE) + 1 "New Code"
FROM LOCATIONS
WHERE COUNTRY_ID = 'US'
ORDER BY POSTAL_CODE;Résultats :
CITY Old Code New Code
------------------------------ ------------ ----------
Southlake 26192 26193
South Brunswick 50090 50091
Seattle 98199 98200
South San Francisco 99236 99237
4 rows selected.Utilisation de fonctions d'agrégation dans les requêtes
Une fonction d'agrégation prend un groupe de lignes et renvoie une seule ligne de résultat. Ce groupe peut correspondre à une table ou une vue entière.
Les fonctions d'agrégation que prend en charge SQL sont répertoriées et décrites dans le manuel Oracle Database SQL Language Reference.
Les fonctions d'agrégation sont particulièrement puissantes lorsqu'elles sont utilisées avec la clause GROUP BY, qui regroupe le résultat de requête par colonnes avec un résultat pour chaque groupe.
La requête de l'Exemple 2-22 utilise la fonction COUNT et la clause GROUP BY pour indiquer le nombre de personnes relevant de chaque responsable. Le caractère générique, *, représente un enregistrement entier. L'exemple 2-22 montre qu'un employé ne relève pas d'un manager. La requête suivante sélectionne son prénom, son nom de famille et sa fonction :
COLUMN FIRST_NAME FORMAT A10;
COLUMN LAST_NAME FORMAT A10;
COLUMN JOB_TITLE FORMAT A10;
SELECT e.FIRST_NAME,
e.LAST_NAME,
j.JOB_TITLE
FROM EMPLOYEES e, JOBS j
WHERE e.JOB_ID = j.JOB_ID
AND MANAGER_ID IS NULL;Résultats :
FIRST_NAME LAST_NAME JOB_TITLE
---------- ---------- ----------
Steven King PresidentPour que la requête ne renvoie que les lignes dont les valeurs agrégées remplissent les conditions indiquées, utilisez une fonction d'agrégation dans la clause HAVING de la requête.
La requête dans l'exemple 2-23 affiche le montant annuel de chaque service salarié pour chaque service, mais uniquement pour les services pour lesquels ce montant dépasse 1 000 000 $.
La requête dans l'Example 2-24 utilise plusieurs fonctions d'agrégation pour afficher les statistiques sur les salaires de chaque identificateur JOB_ID.
Voir aussi : Oracle Database SQL Language Reference, pour plus d'informations sur les fonctions SQL d'agrégation.
Exemple 2-22 Décompte du nombre de lignes dans chaque groupe
SELECT MANAGER_ID "Manager",
COUNT(*) "Number of Reports"
FROM EMPLOYEES
GROUP BY MANAGER_ID
ORDER BY MANAGER_ID;Résultats :
Manager Number of Reports
---------- -----------------
100 14
101 5
102 1
103 4
108 5
114 5
120 8
121 8
122 8
123 8
124 8
145 6
146 6
147 6
148 6
149 6
201 1
205 1
1
19 rows selected.Exemple 2-23 Limitation de fonctions d'agrégation à des lignes vérifiant une condition
SELECT DEPARTMENT_ID "Department",
SUM(SALARY*12) "All Salaries"
FROM EMPLOYEES
HAVING SUM(SALARY * 12) >= 1000000
GROUP BY DEPARTMENT_ID;Résultats :
Department All Salaries
---------- ------------
50 1876800
80 3654000Exemple 2-24 Utilisation des fonctions d'agrégation pour les statistiques
SELECT JOB_ID,
COUNT(*) "#",
MIN(SALARY) "Minimum",
ROUND(AVG(SALARY), 0) "Average",
MEDIAN(SALARY) "Median",
MAX(SALARY) "Maximum",
ROUND(STDDEV(SALARY)) "Std Dev"
FROM EMPLOYEES
GROUP BY JOB_ID
ORDER BY JOB_ID;Résultats :
JOB_ID # Minimum Average Median Maximum Std Dev
---------- ---------- ---------- ---------- ---------- ---------- ----------
AC_ACCOUNT 1 8300 8300 8300 8300 0
AC_MGR 1 12008 12008 12008 12008 0
AD_ASST 1 4400 4400 4400 4400 0
AD_PRES 1 24000 24000 24000 24000 0
AD_VP 2 17000 17000 17000 17000 0
FI_ACCOUNT 5 6900 7920 7800 9000 766
FI_MGR 1 12008 12008 12008 12008 0
HR_REP 1 6500 6500 6500 6500 0
IT_PROG 5 4200 5760 4800 9000 1926
MK_MAN 1 13000 13000 13000 13000 0
MK_REP 1 6000 6000 6000 6000 0
PR_REP 1 10000 10000 10000 10000 0
PU_CLERK 5 2500 2780 2800 3100 239
PU_MAN 1 11000 11000 11000 11000 0
SA_MAN 5 10500 12200 12000 14000 1525
SA_REP 30 6100 8350 8200 11500 1524
SH_CLERK 20 2500 3215 3100 4200 548
ST_CLERK 20 2100 2785 2700 3600 453
ST_MAN 5 5800 7280 7900 8200 1066
19 rows selected.Utilisation de fonctions associées à NULL dans les requêtes
Les fonctions associées à NULL facilitent la gestion des valeurs NULL.
Les fonctions associées à NULL que prend en charge SQL sont répertoriées et décrites dans le manuel Oracle Database SQL Language Reference.
La requête dans l'Exemple 2-25 renvoie le nom et les commissions des employés dont le nom commence par "B". Si un employé ne reçoit aucune commission (si COMMISSION_PCT a la valeur NULL), la fonction NVL remplace "Not Applicable" (Non applicable) par NULL.
La requête de l'Exemple 2-26 renvoie le nom de Famille, le salaire et les revenus des employés dont le nom de Famille commence par B, à l'aide de la fonction NVL2 : si COMMISSION_PCT a la valeur NULL, le revenu est le salaire plus la commission ; si COMMISSION_PCT a la valeur NULL, le revenu est uniquement au salaire.
Voir aussi :
-
Manuel Oracle Database SQL Language Reference, pour plus d'informations sur la fonction NVL
-
Manuel Oracle Database SQL Language Reference, pour plus d'informations sur la fonction NVL2
Exemple 2-25 Remplacement d'une valeur NULL par une chaîne
SELECT LAST_NAME,
NVL(TO_CHAR(COMMISSION_PCT), 'Not Applicable') "COMMISSION"
FROM EMPLOYEES
WHERE LAST_NAME LIKE 'B%'
ORDER BY LAST_NAME;Résultats :
LAST_NAME COMMISSION
------------------------- ----------------------------------------
Baer Not Applicable
Baida Not Applicable
Banda .1
Bates .15
Bell Not Applicable
Bernstein .25
Bissot Not Applicable
Bloom .2
Bull Not Applicable
9 rows selected.Exemple 2-26 : indication d'expressions distinctes pour les valeur NULL et les valeur différentes de NULL
SELECT LAST_NAME, SALARY,
NVL2(COMMISSION_PCT, SALARY + (SALARY * COMMISSION_PCT), SALARY) INCOME
FROM EMPLOYEES WHERE LAST_NAME LIKE 'B%'
ORDER BY LAST_NAME;Résultats :
LAST_NAME SALARY INCOME
------------------------- ---------- ----------
Baer 10000 10000
Baida 2900 2900
Banda 6200 6820
Bates 7300 8395
Bell 4000 4000
Bernstein 9500 11875
Bissot 3300 3300
Bloom 10000 12000
Bull 4100 4100
9 rows selected.Utilisation d'expressions CASE dans les requêtes
L'expression CASE permet d'utiliser la logique IF … THEN … ELSE dans les instructions SQL sans appel de sous-programmes. Il existe deux types d'expressions CASE, simples et recherchées.
La requête de l'Example 2-27 utilise une expression CASE simple pour afficher le nom de pays de chaque code pays.
L'interrogation de l'Example 2-28 utilise une expression CASE recherchée pour afficher les augmentations de salaire proposées (15 %, 10 %, 5 % ou 0 %), en fonction des plages de dates associées à l'ancienneté.
Voir aussi :
-
Manuel Oracle Database SQL Language Reference, pour plus d'informations sur les expressions CASE
-
Manuel Oracle Database PL/SQL Language Reference, pour plus d'informations sur les expressions CASE
Exemple 2-27 Utilisation d'une expression CASE simple dans une requête
SELECT UNIQUE COUNTRY_ID ID,
CASE COUNTRY_ID
WHEN 'AU' THEN 'Australia'
WHEN 'BR' THEN 'Brazil'
WHEN 'CA' THEN 'Canada'
WHEN 'CH' THEN 'Switzerland'
WHEN 'CN' THEN 'China'
WHEN 'DE' THEN 'Germany'
WHEN 'IN' THEN 'India'
WHEN 'IT' THEN 'Italy'
WHEN 'JP' THEN 'Japan'
WHEN 'MX' THEN 'Mexico'
WHEN 'NL' THEN 'Netherlands'
WHEN 'SG' THEN 'Singapore'
WHEN 'UK' THEN 'United Kingdom'
WHEN 'US' THEN 'United States'
ELSE 'Unknown'
END COUNTRY
FROM LOCATIONS
ORDER BY COUNTRY_ID;Résultats :
ID COUNTRY
-- --------------
AU Australia
BR Brazil
CA Canada
CH Switzerland
CN China
DE Germany
IN India
IT Italy
JP Japan
MX Mexico
NL Netherlands
SG Singapore
UK United Kingdom
US United States
14 rows selected.Exemple 2-28 Utilisation d'une expression CASE recherchée dans une requête
SELECT LAST_NAME "Name",
HIRE_DATE "Started",
SALARY "Salary",
CASE
WHEN HIRE_DATE < TO_DATE('01-Jan-03', 'dd-mon-yy')
THEN TRUNC(SALARY*1.15, 0)
WHEN HIRE_DATE >= TO_DATE('01-Jan-03', 'dd-mon-yy') AND
HIRE_DATE < TO_DATE('01-Jan-06', 'dd-mon-yy')
THEN TRUNC(SALARY*1.10, 0)
WHEN HIRE_DATE >= TO_DATE('01-Jan-06', 'dd-mon-yy') AND
HIRE_DATE < TO_DATE('01-Jan-07', 'dd-mon-yy')
THEN TRUNC(SALARY*1.05, 0)
ELSE SALARY
END "Proposed Salary"
FROM EMPLOYEES
WHERE DEPARTMENT_ID = 100
ORDER BY HIRE_DATE;Résultats :
Name Started Salary Proposed Salary
------------------------- --------- ---------- ---------------
Faviet 16-AUG-02 9000 10350
Greenberg 17-AUG-02 12008 13809
Chen 28-SEP-05 8200 9020
Sciarra 30-SEP-05 7700 8470
Urman 07-MAR-06 7800 8190
Popp 07-DEC-07 6900 6900
6 rows selected.Utilisation de la fonction DECODE dans les requêtes
La fonction DECODE compare une expression à plusieurs valeurs de recherche. Lorsque la valeur de l'expression correspond à une valeur de recherche, DECODE renvoie le résultat associé à cette valeur de recherche. Si DECODE ne trouve aucune correspondance, la fonction renvoie la valeur par défaut (si elle est indiquée) ou NULL (si aucune valeur par défaut n'est spécifiée).
La requête dans l'Exemple 2-29 utilise la fonction DECODE pour afficher les augmentations des salaires proposées pour trois types de travail différents. L'expression est JOB_ID ; les valeurs de recherche sont "PU_CLERK", "SH_CLERK" et "ST_CLERK" ; la valeur par défaut est SALARY.
Remarque : Les arguments de la fonction DECODE peuvent être de n'importe quel type de caractère ou numérique SQL. Oracle convertit automatiquement l'expression et chaque valeur de recherche dans le type de données de la première valeur de recherche avant la comparaison. Oracle convertit automatiquement la valeur renvoyée au même type de données que le premier résultat. Si le premier résultat a le type de données CHAR ou si le premier résultat est NULL, Oracle convertit la valeur renvoyée en type de données VARCHAR2.
Voir aussi :
-
Manuel Oracle Database SQL Language Reference, pour plus d'informations sur la fonction DECODE
Exemple 2-29 Utilisation de la fonction DECODE dans une requête
SELECT LAST_NAME, JOB_ID, SALARY,
DECODE(JOB_ID,
'PU_CLERK', SALARY * 1.10,
'SH_CLERK', SALARY * 1.15,
'ST_CLERK', SALARY * 1.20,
SALARY) "Proposed Salary"
FROM EMPLOYEES
WHERE JOB_ID LIKE '%_CLERK'
AND LAST_NAME < 'E'
ORDER BY LAST_NAME;Résultats :
LAST_NAME JOB_ID SALARY Proposed Salary
------------------------- ---------- ---------- ---------------
Atkinson ST_CLERK 2800 3360
Baida PU_CLERK 2900 3190
Bell SH_CLERK 4000 4600
Bissot ST_CLERK 3300 3960
Bull SH_CLERK 4100 4715
Cabrio SH_CLERK 3000 3450
Chung SH_CLERK 3800 4370
Colmenares PU_CLERK 2500 2750
Davies ST_CLERK 3100 3720
Dellinger SH_CLERK 3400 3910
Dilly SH_CLERK 3600 4140
11 rows selected.