Sélection des données de table
Note : Pour suivre les tutoriels et les exemples de cette section, vous devez être connecté à Oracle Database en tant qu'utilisateur HR à partir de SQL Developer. Pour obtenir des instructions, voir "Connexion à Oracle Database en tant qu'utilisateur HR à partir de SQL Developer".
À propos des interrogations
Une interrogation ou un énoncé SQL SELECT sélectionne des données dans une ou plusieurs tables ou vues.
La forme d'interrogation la plus simple présente la syntaxe suivante :
SELECT select_list FROM source_listLa valeur select_list spécifie les colonnes à partir desquelles les données doivent être sélectionnées, et la valeur source_list spécifie les tables ou les vues contenant ces colonnes.
Une interrogation imbriquée dans un autre énoncé SQL est appelée sous-interrogation.
Dans l'environnement SQL*Plus, vous pouvez entrer une interrogation (ou toute autre instruction SQL) après l'invite SQL>.
Dans l'environnement SQL Developer, vous pouvez entrer une interrogation (ou toute autre instruction SQL) dans la feuille de calcul.
Note : Lorsque le résultat d'une interrogation est affiché, les enregistrements peuvent être dans n'importe quel ordre, sauf si vous spécifiez leur commande avec la clause ORDER BY. Pour plus d'informations, voir "Tri des données sélectionnées".
Voir aussi :
-
Informations de référence sur le langage SQL pour Oracle Database pour plus d'informations sur les interrogations et les sous-interrogations
-
Informations de référence sur le langage SQL pour Oracle Database pour plus d'informations sur l'énoncé SELECT
-
Guide et référence de l'utilisateur SQL*Plus pour plus d'informations sur l'interface de ligne de commande SQL*Plus
-
Oracle SQL Developer User's Guide pour plus d'informations sur l'utilisation de la feuille de calcul dans SQL Developer
Exécuter des interrogations dans SQL Developer
Cette section explique comment exécuter des interrogations dans SQL Developer, à l'aide de la feuille de calcul.
Note : La feuille de calcul ne se limite pas aux interrogations; vous pouvez l'utiliser pour exécuter n'importe quel énoncé SQL.
Etapes d'exécution des interrogations dans SQL Developer :
-
Si le cadre droit de SQL Developer affiche le volet hr_conn :
-
Si le sous-volet Feuille de calcul ne s'affiche pas, sélectionnez l'onglet Feuille de calcul.
-
Allez à l'étape 4.
-
-
Sélectionnez l'icône Feuille de calcul SQL.
-
Si la fenêtre Select Connection s'ouvre :
-
Si le champ Connexion ne contient pas la valeur
hr_conn, sélectionnez cette valeur dans le menu. -
Sélectionnez OK.
Un volet s'affiche avec un onglet nommé hr_conn et deux sous-volets, Feuille de calcul et Générateur d'interrogations. Dans la feuille de calcul, vous pouvez entrer une instruction SQL.
-
-
Dans la feuille de calcul, tapez une interrogation (instruction SELECT).
-
Cliquez sur l'icône Exécuter l'énoncé.
L'interrogation est exécutée. Sous la feuille de calcul, le volet Query Result apparaît et affiche le résultat de l'interrogation.
-
Sous l'onglet hr_conn, cliquez sur l'icône Effacer.
L'interrogation 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 exécutée précédemment.
Voir aussi : Oracle SQL Developer User's Guide pour plus d'informations sur l'utilisation de la feuille de calcul dans SQL Developer
Tutoriel : Sélectionner toutes les colonnes d'une table
Ce tutoriel explique comment sélectionner toutes les colonnes de la table EMPLOYEES.
Etapes de sélection de toutes les colonnes de la table EMPLOYEES :
-
Si un volet avec l'onglet hr_conn s'affiche, sélectionnez-le. Sinon, cliquez sur l'icône Feuille de calcul SQL, comme dans "Exécution d'interrogations dans SQL Developer".
-
Dans la feuille de calcul, entrez l'interrogation suivante :
SELECT * FROM EMPLOYEES; -
Cliquez sur l'icône Exécuter l'énoncé.
L'interrogation est exécutée. Sous la feuille de calcul, le volet Query Result apparaît et affiche toutes les colonnes de la table EMPLOYEES.
Attention : Veillez à utiliser SELECT * sur les tables contenant des colonnes qui stockent des données sensibles, telles que des mots de passe ou des informations de carte de crédit.
Voir aussi : "Tutoriel : Consultation des propriétés et des données de table EMPLOYEES avec SQL Developer" pour plus d'informations sur une autre façon de voir les données de table avec SQL Developer
Tutoriel : Sélectionner des colonnes spécifiques d'une table
Ce tutoriel explique comment sélectionner uniquement les colonnes FIRST_NAME, LAST_NAME et DEPARTMENT_ID de la table EMPLOYEES.
Étapes pour sélectionner uniquement FIRST_NAME, LAST_NAME et DEPARTMENT_ID :
-
Si un volet avec l'onglet hr_conn s'affiche, sélectionnez-le. Sinon, cliquez sur l'icône SQL Worksheet, comme dans "Exécution d'interrogations dans SQL Developer".
-
Si le volet Feuille de calcul contient une interrogation, 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'énoncé.
L'interrogation est exécutée. Sous la feuille de calcul, le volet Query Result s'affiche et affiche les résultats de l'interrogation, 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 des colonnes sélectionnées sous les nouveaux en-têtes
Dans les résultats d'interrogation 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, spécifiez le nouvel en-tête (alias) immédiatement après le nom de la colonne. L'alias renomme la colonne pendant la durée de l'interrogation, mais ne change pas son nom dans la base de données.
L'interrogation dans Exemple 2-5 sélectionne les mêmes colonnes que l'interrogation dans "Tutoriel : Sélection de colonnes spécifiques d'une table", mais elle spécifie également des alias pour ces colonnes. Comme les alias ne sont pas placés entre guillemets, ils sont affichés en majuscules.
Si vous placez les alias de colonne entre guillemets, la casse est conservée et les alias peuvent inclure des espaces, comme dans Exemple 2-6.
Voir aussi : Informations de référence sur le langage SQL pour Oracle Database pour plus d'informations sur l'énoncé SELECT, notamment l'alias de colonne (c_alias)
Exemple 2-5 : Affichage des 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 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 : Préservation de cas et inclusion d'espaces dans des alias de colonne
SELECT FIRST_NAME "Given Name", LAST_NAME "Family Name"
FROM EMPLOYEES;Le résultat 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 des données qui satisfont aux conditions précisées
Pour sélectionner uniquement les données correspondant à une condition spécifiée, incluez la clause WHERE dans l'instruction SELECT.
La condition de la clause WHERE peut être n'importe quelle condition SQL (pour plus d'informations sur les conditions SQL, voir Informations de référence sur le langage SQL pour Oracle Database).
L'interrogation de l'exemple 2-7 sélectionne les données uniquement pour les 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);L'interrogation dans Exemple 2-8 sélectionne les données uniquement pour les 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 dans Exemple 2-9 teste deux conditions : si le salaire est d'au moins 11000 et si le pourcentage de commission n'est pas nul.
Voir aussi :
-
Informations de référence sur le langage SQL pour Oracle Database pour plus d'informations sur l'énoncé SELECT, y compris la clause WHERE
-
Informations de référence sur le langage SQL pour Oracle Database pour plus d'informations sur les conditions SQL
Exemple 2-7 : Sélectionner des données dans un service
SELECT FIRST_NAME, LAST_NAME, DEPARTMENT_ID
FROM EMPLOYEES
WHERE DEPARTMENT_ID = 90;Le résultat 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 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 répondant à deux conditions
SELECT FIRST_NAME, LAST_NAME, SALARY, COMMISSION_PCT "%"
FROM EMPLOYEES
WHERE (SALARY >= 11000) AND (COMMISSION_PCT IS NOT NULL);Le résultat 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 les résultats de l'interrogation sont affichés, les enregistrements peuvent être dans n'importe quel ordre, sauf si vous spécifiez leur ordre avec la clause ORDER BY.
Les résultats de l'interrogation sous Exemple 2-10 sont triés par LAST_NAME, en ordre croissant (valeur par défaut).
Sinon, dans SQL Developer, vous pouvez omettre la clause ORDER BY et cliquer deux fois 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 l'indique l'exemple 2-11.
Voir aussi : Informations de référence sur le langage SQL pour Oracle Database pour plus d'informations sur l'énoncé SELECT, y compris la clause ORDER BY
Exemple 2-10 : Tri des données sélectionnées par LAST_NAME
SELECT FIRST_NAME, LAST_NAME, HIRE_DATE
FROM EMPLOYEES
ORDER BY LAST_NAME;Résultat :
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 par une colonne non sélectionnée
SELECT FIRST_NAME, HIRE_DATE
FROM EMPLOYEES
ORDER BY LAST_NAME;Résultat :
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 interrogation appelée jointure. Les tables d'une jointure doivent partager au moins un nom de colonne.
Supposons que vous souhaitiez sélectionner les valeurs FIRST_NAME, LAST_NAME et DEPARTMENT_NAME de chaque employé. FIRST_NAME et LAST_NAME se trouvent dans la table EMPLOYEES et DEPARTMENT_NAME dans la table DEPARTMENTS. Les deux tables ont la valeur DEPARTMENT_ID. Vous pouvez utiliser l'interrogation dans Exemple 2-12.
Les qualificatifs de nom de table sont facultatifs pour les noms de colonne qui apparaissent dans une seule table d'une jointure, mais sont requis pour les noms de colonne qui apparaissent dans les deux tables. L'interrogation suivante équivaut à l'interrogation dans Exemple 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 les interrogations qui utilisent des noms de colonne qualifiés plus lisibles, utilisez des alias de table, comme illustré 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 créiez les alias dans la clause FROM, vous pouvez les utiliser plus tôt dans l'interrogation, comme illustré dans 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 : Informations de référence sur le langage SQL pour Oracle Database pour plus d'informations sur les jointures
Exemple 2-12 : Sélectionner des données dans deux tables (joindre 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ésultat :
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 interrogations
La liste select_list d'une interrogation peut inclure des expressions SQL, qui peuvent inclure des opérateurs SQL et des fonctions SQL. Ces opérateurs et fonctions peuvent avoir des données de table en tant qu'opérandes et arguments. Les expressions SQL sont évaluées et leurs valeurs apparaissent dans les résultats de l'interrogation.
Voir aussi :
-
Informations de référence sur le langage SQL pour Oracle Database pour plus d'informations sur les opérateurs SQL
-
Informations de référence sur le langage SQL pour Oracle Database pour plus d'informations sur les fonctions SQL
Utiliser des opérateurs arithmétiques dans les interrogations
Les opérateurs arithmétiques de base -+ (addition), - (soustraction), \* (multiplication) et / (division) - fonctionnent sur les valeurs de colonne.
L'interrogation dans Exemple 2-13 affiche LAST_NAME, SALARY (paie mensuelle) et la paie annuelle de chaque employé du service 90, par ordre décroissant de SALARY.
Exemple 2-13 : Utilisation d'une expression arithmétique dans une interrogation
SELECT LAST_NAME,
SALARY "Monthly Pay",
SALARY * 12 "Annual Pay"
FROM EMPLOYEES
WHERE DEPARTMENT_ID = 90
ORDER BY SALARY DESC;Résultat :
LAST_NAME Monthly Pay Annual Pay
------------------------- ----------- ----------
King 24000 288000
De Haan 17000 204000
Kochhar 17000 204000Utilisation des fonctions numériques dans les interrogations
Les fonctions numériques acceptent les entrées numériques et retournent des valeurs numériques. Chaque fonction numérique renvoie une seule valeur pour chaque ligne évaluée.
Les fonctions numériques prises en charge par SQL sont répertoriées et décrites dans Informations de référence sur le langage SQL pour Oracle Database.
L'interrogation dans Exemple 2-14 utilise la fonction numérique ROUND pour afficher la paie quotidienne de chaque employé du service 100, arrondie au cent le plus proche.
L'interrogation dans Exemple 2-15 utilise la fonction numérique TRUNC pour afficher la paie quotidienne de chaque employé dans le service 100, tronquée au dollar le plus proche.
Voir aussi : Informations de référence sur le langage SQL pour Oracle Database pour plus d'informations sur les fonctions numériques SQL
Exemple 2-14 : Arrondissement 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ésultat :
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ésultat :
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 interrogations
L'opérateur de concaténation (||) combine deux chaînes en une seule chaîne, en ajoutant la deuxième chaîne à la première. Par exemple, 'a'||'b'='ab'. Vous pouvez utiliser cet opérateur pour combiner les informations de deux colonnes ou expressions dans la même colonne d'un résultat d'interrogation.
L'interrogation dans Exemple 2-16 concatène le prénom, une espace et le nom de chaque employé sélectionné.
Voir aussi : Informations de référence sur le langage SQL pour Oracle Database 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ésultat :
Name
----------------------------------------------
John Chen
Daniel Faviet
Nancy Greenberg
Luis Popp
Ismael Sciarra
Jose Manuel Urman
6 rows selected.Utilisation des fonctions de caractère dans les interrogations
Les fonctions de caractère acceptent l'entrée de caractères. La plupart retournent des valeurs de caractère, mais certaines renvoient des valeurs numériques. Chaque fonction de caractère renvoie une valeur unique pour chaque ligne évaluée.
Les fonctions de caractère prises en charge par SQL sont répertoriées et décrites dans Informations de référence sur le langage SQL pour Oracle Database.
Les fonctions UPPER, INITCAP et LOWER affichent leurs arguments de caractère en majuscules, en majuscules et en minuscules, respectivement.
L'interrogation dans Exemple 2-17 affiche LAST_NAME en majuscules, FIRST_NAME avec le premier caractère en majuscules et tous les autres en minuscules, et EMAIL en minuscules.
Voir aussi : Informations de référence sur le langage SQL pour Oracle Database pour plus d'informations sur les fonctions de caractère SQL
Exemple 2-17 : Modifier les données de cas de caractère
SELECT UPPER(LAST_NAME) "Last",
INITCAP(FIRST_NAME) "First",
LOWER(EMAIL) "E-Mail"
FROM EMPLOYEES
WHERE DEPARTMENT_ID = 100
ORDER BY EMAIL;Résultat :
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 des fonctions date et heure dans les interrogations
Les fonctions DATE et heure fonctionnent selon la DATE, l'horodatage et les valeurs d'intervalle. Chaque fonction date-heure retourne une valeur unique pour chaque rangée évaluée.
Les fonctions date-heure prises en charge par SQL sont répertoriées et décrites dans Informations de référence sur le langage SQL pour Oracle Database.
Pour chaque 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 spécifier 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, voir Informations de référence sur le langage SQL pour Oracle Database.
Pour plus d'informations sur le type de données TIMESTAMP, voir Informations de référence sur le langage SQL pour Oracle Database.
Pour plus d'informations sur les autres types de données d'horodatage et les types de données d'intervalle, voir Informations de référence sur le langage SQL pour Oracle Database.
L'interrogation dans Exemple 2-18 utilise les fonctions EXTRACT et SYSDATE pour montrer combien d'années chaque employé du service 100 a été employé. La fonction SYSDATE retourne la DATE courante de l'horloge système en tant que valeur DATE. Pour plus d'informations sur la fonction SYSDATE, voir Informations de référence sur le langage SQL pour Oracle Database. Pour plus d'informations sur la fonction EXTRACT, voir Informations de référence sur le langage SQL pour Oracle Database.
L'interrogation dans Exemple 2-19 utilise la fonction SYSTIMESTAMP pour afficher la date et l'heure courantes du système. La fonction SYSTIMESTAMP retourne une valeur TIMESTAMP. Pour plus d'informations sur la fonction SYSTIMESTAMP, voir Informations de référence sur le langage SQL pour Oracle Database.
La table de la clause FROM de l'interrogation DUAL est une table à une ligne qu'Oracle Database crée automatiquement avec le dictionnaire de données. Sélectionnez DUAL pour calculer une expression constante à l'aide de l'instruction SELECT. DUAL n'ayant qu'une seule ligne, la constante est renvoyée une seule fois. Pour plus d'informations sur la sélection dans DUAL, voir Informations de référence sur le langage SQL pour Oracle Database.
Voir aussi : Informations de référence sur le langage SQL pour Oracle Database pour plus d'informations sur les fonctions date-heure SQL
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ésultat :
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 courante, mais ont le format suivant :
System Time and Date
-------------------------------------------------------------------
18:17:53, 12/27/2012Utilisation des fonctions de conversion dans les interrogations
Les fonctions de conversion convertissent un type de données en un autre.
Les fonctions de conversion prises en charge par SQL sont répertoriées et décrites dans Informations de référence sur le langage SQL pour Oracle Database.
L'interrogation dans Exemple 2-20 utilise la fonction TO_CHAR pour convertir les valeurs HIRE_DATE (de type DATE) en valeurs de caractère ayant le 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 datetime. Pour plus d'informations sur les modèles de format date-heure, voir Informations de référence sur le langage SQL pour Oracle Database.
L'interrogation dans 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 :
-
Informations de référence sur le langage SQL pour Oracle Database pour plus d'informations sur les fonctions de conversion SQL
Exemple 2-20 : Conversion de dates en caractères à 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ésultat :
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ésultat :
CITY Old Code New Code
------------------------------ ------------ ----------
Southlake 26192 26193
South Brunswick 50090 50091
Seattle 98199 98200
South San Francisco 99236 99237
4 rows selected.Utiliser des fonctions d'agrégation dans les interrogations
Une fonction d'agrégation prend un groupe de lignes et retourne une seule ligne de résultat. Le groupe de lignes peut être une table ou une vue complète.
Les fonctions d'agrégation prises en charge par SQL sont répertoriées et décrites dans Informations de référence sur le langage SQL pour Oracle Database.
Les fonctions d'agrégation sont particulièrement puissantes lorsqu'elles sont utilisées avec la clause GROUP BY, qui regroupe les résultats d'interrogation par une ou plusieurs colonnes, avec un résultat pour chaque groupe.
L'interrogation dans Exemple 2-22 utilise la fonction COUNT et la clause GROUP BY pour afficher le nombre de personnes relevant de chaque gestionnaire. Le caractère générique, *, représente un enregistrement entier. Exemple 2-22 indique qu'un employé ne relève pas d'un gestionnaire. L'interrogation suivante sélectionne le prénom, le nom et le titre d'emploi de cet employé :
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ésultat :
FIRST_NAME LAST_NAME JOB_TITLE
---------- ---------- ----------
Steven King PresidentPour que l'interrogation ne retourne que des rangées lorsque les valeurs d'agrégation répondent aux conditions spécifiées, utilisez une fonction d'agrégation dans la clause HAVING de l'interrogation.
L'interrogation dans Exemple 2-23 montre combien chaque service dépense annuellement sur les salaires, mais uniquement pour les services pour lesquels ce montant dépasse 1 000 000 $.
L'interrogation dans Exemple 2-24 utilise plusieurs fonctions d'agrégation pour afficher des statistiques sur les salaires de chaque JOB_ID.
Voir aussi : Informations de référence sur le langage SQL pour Oracle Database pour plus d'informations sur les fonctions d'agrégation SQL
Exemple 2-22 : Compter le nombre de rangées dans chaque groupe
SELECT MANAGER_ID "Manager",
COUNT(*) "Number of Reports"
FROM EMPLOYEES
GROUP BY MANAGER_ID
ORDER BY MANAGER_ID;Résultat :
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 : Limiter les fonctions d'agrégation aux rangées qui satisfont une condition
SELECT DEPARTMENT_ID "Department",
SUM(SALARY*12) "All Salaries"
FROM EMPLOYEES
HAVING SUM(SALARY * 12) >= 1000000
GROUP BY DEPARTMENT_ID;Résultat :
Department All Salaries
---------- ------------
50 1876800
80 3654000Exemple 2-24 : Utiliser des fonctions d'agrégation pour les informations 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ésultat :
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.Utiliser des fonctions liées à la valeur NULL dans les interrogations
Les fonctions liées à la valeur NULL facilitent le traitement des valeurs NULL.
Les fonctions liées à la valeur NULL prises en charge par SQL sont répertoriées et décrites dans Informations de référence sur le langage SQL pour Oracle Database.
L'interrogation dans Exemple 2-25 retourne le nom et la commission des employés dont le nom commence par 'B'. Si un employé ne reçoit aucune commission (c'est-à-dire si COMMISSION_PCT a la valeur NULL), la fonction NVL remplace la valeur NULL par "Not Applicable".
L'interrogation dans Exemple 2-26 retourne le nom, le salaire et le revenu des employés dont le nom commence par 'B', à l'aide de la fonction NVL2 : Si COMMISSION_PCT n'est pas NULL, le revenu est le salaire plus la commission; si COMMISSION_PCT est NULL, le revenu est seulement le salaire.
Voir aussi :
-
Informations de référence sur le langage SQL pour Oracle Database pour plus d'informations sur la fonction NVL
-
Informations de référence sur le langage SQL pour Oracle Database pour plus d'informations sur la fonction NVL2
Exemple 2-25 : Remplacer une chaîne par une valeur NULL
SELECT LAST_NAME,
NVL(TO_CHAR(COMMISSION_PCT), 'Not Applicable') "COMMISSION"
FROM EMPLOYEES
WHERE LAST_NAME LIKE 'B%'
ORDER BY LAST_NAME;Résultat :
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 : Spécification d'expressions différentes pour les valeurs NULL et non 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ésultat :
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 interrogations
Une expression CASE vous permet d'utiliser la logique IF … THEN … ELSE dans les instructions SQL sans appeler de sous-programmes. Il existe deux types d'expressions CASE, simples et recherchées.
L'interrogation dans Exemple 2-27 utilise une expression CASE simple pour afficher le nom du pays pour chaque code de pays.
L'interrogation de l'exemple 2-28 utilise une expression CASE recherchée pour afficher les augmentations de salaire proposées (15 %, 10 %, 5 % ou 0 %) en fonction des intervalles de dates associés à l'ancienneté.
Voir aussi :
-
Informations de référence sur le langage SQL pour Oracle Database pour plus d'informations sur les expressions CASE
-
Informations de référence sur le langage PL/SQL pour Oracle Database pour plus d'informations sur les expressions CASE
Exemple 2-27 : Utilisation d'une expression CASE simple dans une interrogation
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ésultat :
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 interrogation
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ésultat :
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 interrogations
La fonction DECODE compare une expression à plusieurs valeurs de recherche. Lorsque la valeur de l'expression correspond à une valeur de recherche, DECODE retourne le résultat associé à cette valeur de recherche. Si DECODE ne trouve aucune correspondance, il renvoie la valeur par défaut (si elle est spécifiée) ou NULL (si aucune valeur par défaut n'est spécifiée).
L'interrogation dans Exemple 2-29 utilise la fonction DECODE pour afficher les augmentations de salaire proposées pour trois emplois 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.
Note : Les arguments de la fonction DECODE peuvent être n'importe quel type de caractère ou numérique SQL. Oracle convertit automatiquement l'expression et chaque valeur de recherche au 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 au type de données VARCHAR2.
Voir aussi :
-
Informations de référence sur le langage SQL pour Oracle Database pour plus d'informations sur la fonction DECODE
Exemple 2-29 : Utilisation de la fonction DECODE dans une interrogation
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ésultat :
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.