COURS
&
SQL*Plus
&
SQL
1. INTRODUCTION 7
1.1. DEFINITIONS 7
1.2. L’OFFREORACLE 9
1.3. LES COMMANDES 10
1.4. LES OBJETS 11
2. INTERROGATION DES DONNEES 12
2.1. SYNTAXE DU VERBESELECT 12
2.2. INDEPENDANCE LOGIQUE EXTERNE 14
2.3. ELIMINATION DE DOUBLONS:DISTINCT 21
EXERCICESSERIE1 22
2.4. OPERATION DE SELECTION 23
2.4.1. OPERATEURS ARITHMETIQUES 25
2.4.2. CRITERES DE COMPARAISON : OPERATEURS SUR LES CHAINES : LIKE ET SOUNDEX 26
2.4.3. CRITERES DE COMPARAISON AVEC L’OPERATEUR IN 29
2.4.4. CRITERES DE COMPARAISON AVEC L’OPERATEUR BETWEEN 30
2.4.5. CRITERES DE COMPARAISON AVEC UNE VALEUR NULLE 31
2.4.6. LES OPÉRATEURS ANY, SOME ET ALL 32
EXERCICESSERIE2 34
2.5. EXPRESSIONS ET FONCTIONS 35
2.5.1. LES EXPRESSIONS 36
2.5.2. LES FONCTIONS 39
EXERCICESSERIE3 48
2.6. LES FONCTIONS DE GROUPE/UTILISATION DE FONCTIONS AGGREGATIVES49
2.7. PRESENTATION DU RESULTAT TRIE SELON UN ORDRE PRECIS 50
EXERCICESSERIE4 54
2.9.REQUETES MULTI-RELATIONS SANS SOUS-REQUETES:LA JOINTURE OU PRODUIT CARTESIEN 55
2.9. REQUETES MULTI-RELATIONS SANS SOUS-REQUETES : LA JOINTURE OU PRODUIT CARTESIEN (SUITE) 56
2.9. REQUETES MULTI-RELATIONS SANS SOUS-REQUETES : LA JOINTURE OU PRODUIT CARTESIEN(SUITE) 57
2.10. REQUETES MULTI-RELATIONS AVEC LES OPERATEURS ENSEMBLISTES 58
2.11. SOUS-INTERROGATIONS NON SYNCHRONISEE 61
2.11. SOUS-INTERROGATIONS NON SYNCHRONISEE(SUITE) 62
2.12. LA JOINTURE EXTERNE 64
2.12.LA JOINTURE EXTERNE(SUITE) 65
2.11.SOUS-INTERROGATIONS SYNCHRONISEE 66
2.11.SOUS-INTERROGATIONS SYNCHRONISEE(SUITE) 67
EXERCICESSERIE5 68
2.14. LA RECHERCHE HIERARCHIQUE 69
EXERCICESSERIE6 76
2.15. LE PARTITIONNEMENT 77
2.15. LE PARTITIONNEMENT (SUITE) 78
EXERCICESSERIE7 80
3. MISE A JOUR DES DONNEES 81
3.1. INSERTION DE LIGNES 82
3.2. MODIFICATION DE LIGNES 82
3.3. SUPPRESSION DE LIGNES84
3.3.1. VIA LA COMMANDEDELETE 84
3.3.2. VIA LA COMMANDETRUNCATE 85
EXERCICESSERIE8 88
4. LE SCHEMA DE DONNEES 89
4.1. LES PRINCIPAUX OBJETS D’UNE BASE 90
4.2. LES REGLES DE NOMMAGE DES OBJETS D’UNE BASE 91
4.3. LES TYPES DE DONNEES 92
4.3LES TYPES DE DONNEES(SUITE) 93
4.5 CREATION D’UNE TABLE 95
4.5 CREATION D’UNE TABLE (SUITE) 96
4.5 CREATION D’UNE TABLE (SUITE) 97
4.6 LES CONTRAINTES D’INTEGRITE 98
4.6 LES CONTRAINTES D’INTEGRITE (SUITE) 100
4.6 LES CONTRAINTES D’INTEGRITE (SUITE) 101
4.6 LES CONTRAINTES D’INTEGRITE (SUITE) 102
4.6 LES CONTRAINTES D’INTEGRITE (SUITE) 103
4.6 LES CONTRAINTES D’INTEGRITE (SUITE) 104
4.6 LES CONTRAINTES D’INTEGRITE (SUITE) 105
4.6 LES CONTRAINTES D’INTEGRITE (SUITE) 106
4.6 LES CONTRAINTES D’INTEGRITE (SUITE) 107
4.6 LES CONTRAINTES D’INTEGRITE (SUITE) 108
4.7 CREATION D’UN INDEX 110
EXERCICESSERIE9 111
4.8 MODIFICATION D’UNE TABLE 112
4.8MODIFICATION D’UNE TABLE(SUITE) 113
4.8MODIFICATION D’UNE TABLE(SUITE) 114
4.8MODIFICATION D’UNE TABLE(SUITE) 116
4.8MODIFICATION D’UNE TABLE(SUITE) 117
4.8MODIFICATION D’UNE TABLE(SUITE) 118
4.13LE DICTIONNAIRE DE DONNEES 127
4.13LE DICTIONNAIRE DE DONNEES(SUITE) 128
4.13LE DICTIONNAIRE DE DONNEES(SUITE) 130
4.13LE DICTIONNAIRE DE DONNEES(SUITE) 131
EXERCICESSERIE11 133
5. CONCURRENCE D’ACCES 134
PLAN 134
5.1. TRANSACTION 134
5.2. GESTION DES VERROUS 134
5.1. TRANSACTION 135
EXERCICESSERIE12 138
5.2. GESTION DES VERROUS 139
EXERCICESSERIE13 147
6. LES VUES 152
6.1. CREATION D’UNE VUE 153
6.1. CREATION D’UNE VUE(SUITE) 154
6.2. MANIPULATION SUR LES VUES 155
1. INTRODUCTION 159
2. STRUCTURE D’UN BLOC PL/SQL160
3. LES VARIABLES UTILISEES DANS PL/SQL 162
3.1. LES DIFFERENTS TYPES DE VARIABLES LOCALES 162
3.1.1. VARIABLES DE TYPE ORACLE 163
3.1.2. VARIABLES DE TYPE BOOLEEN 164
3.1.3. VARIABLES FAISANT REFERENCE AU DICTIONNAIRE DE DONNEES 165
3.1.4. INITIALISATION DES VARIABLES 168
3.1.5. VISIBILITE DES VARIABLES 169
3.2. VARIABLES DE L’ENVIRONNEMENT EXTERIEUR APL/SQL 170
4. LES TRAITEMENTS 171
4.1. IF:TRAITEMENT CONDITIONNEL 171
4.2. BOUCLE DE BASELOOP:TRAITEMENT REPETITIF 172
4.3. BOUCLEFOR:TRAITEMENT REPETITIF 173
4.4. BOUCLEWHILE:TRAITEMENT REPETITIF 174
5. LES CURSEURS EN PL/SQL 175
5.1. DEFINITIONS 175
5.2. CURSEUR EXPLICITE 176
5.3. LES ATTRIBUTS D’UN CURSEUR 181
5.3.1. %FOUND 182
5.3.2. %NOTFOUND 184
5.3.3. %ISOPEN 185
5.3.4. %ROWCOUNT 186
5.4. SIMPLIFICATION D’ÉCRITURE 187
5.4.1. DECLARATION DE VARIABLES 187
5.4.2. TRAITEMENT DU CURSEUR 188
6. GESTION DES ERREURS EN PL/SQL 190
7. EXERCICES PL/SQL 195
7.1. EX1:LES BOUCLES195
7.2. EX2:LES CURSEURS 195
7.3. EX3:LES ERREURS195
1. PRESENTATION DE SQL*PLUS 197
2. LES COMMANDES DE L’EDITEUR 200
3. LES COMMANDES DE L’ENVIRONNEMENT 201
3.1. COMMANDES D’ENTREES/SORTIES202
3.2. COMMANDES DE DIALOGUE203
3.3. COMMANDES DE FORMATAGE DE RAPPORT 207
3.4. COMMANDES DE DEFINITION DE L’ENVIRONNEMENT213
4. EXERCICE218
ANNEXEA: 220
SCHEMA ET EXTENSION DE LA BASE AERIENNE 220
ANNEXEB:VARIABLESD’ENVIRONNEMENTIMPORTANTESSOUSUNIX 223
SQL
Une base de données est un ensemble d’informations structurées.
Un SGBDR (Système de Gestion de Bases de Données Relationnel) est un logiciel qui permet de :
- stocker,
- consulter,
- modifier,
- supprimer
les données de la base de données.
Un SGBDR stocke les informations dans des tables.
1.1. Définitions (suite )
SQL (Strutured Query Language) :
- est le langage utilisé pour accéder aux données d'une base de données.
- est normalisé. C'est un standard adopté par l'ANSI (American National Standards Institute).
ANSI SQL92
- est un langage ensembliste (non procédural)
- est un langage « universel » utilisé par :
* les administrateurs
* les développeurs
* les utilisateurs
pour :
* administrer et contrôler
* définir et développer
* manipuler
|
|
Commandes de manipulation des données :
- SELECT : interrogation
- INSERT : insertion
- UPDATE : mise à jour
- DELETE : suppression
Les commandes de définition de données :
- CREATE : création d'un objet
- ALTER : modification d'un objet
- TRUNCATE : supprimer les lignes d'une table
- DROP : supprimer un objet
Remarque : les commandes GRANT et REVOKE seront vues dans le cours d'administration.
Les objets du SGBD Relationnel ORACLE sont les suivants : - les Tables, - les Vues, - les Index, - les Séquences, - les Synonymes, - les Clusters. Seuls les objets TABLES, VUES, INDEX, SYNONYMES et les séquences seront vus dans ce cours. |
SELECT [ALL | DISTINCT] {[schéma.table].*
| expr [c_alias], }
FROM [schéma].obj [t_alias], [schéma].obj [t_alias],
[WHERE <condition>]
[CONNECT BY <condition>
[START WITH <condition>]]
[GROUP BY expr, expr,
[HAVING <condition>]]
[ORDER BY {expr|pos} [ASC|DESC],
[{expr|pos} [ASC|DESC], ]
2.1. Syntaxe du verbe SELECT (suite )
La clause : SELECT
FROM
WHERE
est une traduction simple du langage naturel. Elle permet de rechercher les données dans la base dans une ou plusieurs tables, dans une ou plusieurs vues.
Notes :
| : choix entre différentes options
{} : choix obligatoire
[] : facultatif
a) obj : peut être une TABLE, une VUE ou un SNAPSHOT
b) expr est une expression basée sur les valeurs d'une colonne
c) c_alias est le renommage de l'expression
d) t_alias est le renommage d'une table, vue ou shnapshot
L'objectif ici est de mettre en évidence l'indépendance logique externe.
Table EMP (EMP#,NOM,ADR,SAL)
?
PRIX PROD# N° COUT Prix Produit EMP# AUGM.
-------- ---------- ---- -------- -------------- -------- ---------- coûte .
- Redisposition - Renommage - Calculs horizontaux
des colonnes - Constantes
- Calculs verticaux TOTAL SAL
-----------------
2.2. Indépendance logique externe (suite )
LE RENOMMAGE : - alias d'attributs et - alias des tables Exemple : SQL> SELECT p.pl# num_pilote FROM pilote p; NUM_PILOTE -------------------- 1 2 3 4 5 6 8 9 10 11 12 13 14 15 16 17 16 ligne(s) sélectionnée(s). |
Exemple : Ecrire de 3 manières différentes une projection sur toutes les colonnes de la table PILOTE. SQL> SELECT * FROM pilote; SQL> SELECT a.* FROM pilote a; SQL > SELECT pilote.* from pilote; Même résultat dans tous les cas : PL# PLNOM DNAISS ADR TEL SAL --- ------------ -------- -------------------- ------------ --------- 2 St-exupéry 16/10/32 Lyon 91548254 12300 3 Armstrong 11/03/30 Wapakoneta 96548254 24500 4 Tintin 01/08/29 Bruxelles 93548254 21100 5 Gagarine 12/08/34 Klouchino 93548454 22100 6 Baudry 31/08/59 Toulouse 93548444 21000 8 Bush 28/02/24 Milton 44556254 22000 9 Ruskoi 16/08/30 Moscou 73548254 22000 10 Mathé 12/08/38 Paris 23548254 15000 11 Yen 19/09/42 Munich 13548254 29000 12 Icare 17/12/62 Ithaques 73548211 17000,6 13 Mopolo 04/11/55 Nice 93958211 17000,6 14 Chretien 04/11/45 73223322 15000,6 15 Vernes 04/11/35 Paris 17000,6 16 Tournesol 04/11/29 Bruxelles 15000,6 17 Concorde 04/08/66 Paris 21000,6 16 ligne(s) sélectionnée(s). |
LA REDISPOSITION DES COLONNES (des attributs) Exemple : SQL> desc pilote; Nom Non renseigné NULL? Type ------------------------------- -------- ---- PL# NOT NULL NUMBER(4) PLNOM NOT NULL VARCHAR2(12) DNAISS NOT NULL DATE ADR VARCHAR2(20) SAL NOT NULL NUMBER(7,2) SQL> SELECT pl#, sal, tel,plnom FROM pilote; PL# SAL TEL PLNOM --- --------- ------------ ------------ 1 18009 93548254 Miranda 2 12300 91548254 St-exupéry 3 24500 96548254 Armstrong 4 21100 93548254 Tintin 5 22100 93548454 Gagarine 6 21000 93548444 Baudry 8 22000 44556254 Bush 9 22000 73548254 Ruskoi 10 15000 23548254 Mathé 11 29000 13548254 Yen 12 17000,6 73548211 Icare 13 17000,6 93958211 Mopolo 14 15000,6 73223322 Chretien 15 17000,6 Vernes 16 15000,6 Tournesol 17 21000,6 Concorde |
LES CONSTANTES On peut répéter une constante pour chaque ligne ramenée. Les constantes sont de type numérique ou alphanumérique (entre ' '). Exemple : SQL> SELECT plnom NOM , 'gagne' GAIN , sal SALAIRE FROM pilote; NOM GAIN SALAIRE ------------ ----- --------- Miranda gagne 18009 St-exupéry gagne 12300 Armstrong gagne 24500 Tintin gagne 21100 Gagarine gagne 22100 Baudry gagne 21000 Bush gagne 22000 Ruskoi gagne 22000 Mathé gagne 15000 Yen gagne 29000 Icare gagne 17000,6 Mopolo gagne 17000,6 Chretien gagne 15000,6 Vernes gagne 17000,6 Tournesol gagne 15000,6 Concorde gagne 21000,6 |
LES CALCULS HORIZONTAUX Exemple : SQL> SELECT pl#, sal*12 "SALAIRE ANNUEL" FROM pilote; PL# SALAIRE ANNUEL --- --------------- 1 216108 2 147600 3 294000 4 253200 5 265200 6 252000 8 264000 9 264000 10 180000 11 348000 12 204007,2 13 204007,2 14 180007,2 15 204007,2 16 180007,2 17 252007,2 16 ligne(s) sélectionnée(s). |
LES CALCULS VERTICAUX Les calculs verticaux font intervenir les valeurs d'une colonne sur l'ensemble ou un sous-ensemble des tuples ramenés par une requête. Remarque : l'alias d'une colonne ou d'une expression sera de 30 caractères max. et sera entre "" si l'alias contient des séparateurs. Exemple : SQL> SELECT avtype TYPE, SUM(cap) "CAPACITE TOTALE" FROM avion GROUP BY avtype; TYPE CAPACITE TOTALE ---------- --------------- A300 1300 A320 320 B707 400 B727 250 Caravelle 300 Concorde 650 6 ligne(s) sélectionnée(s). |
Le mot clé DISTINCT dans la clause SELECT : - réalise un tri sur les colonnes et - élimine les doublons. Exemple : SQL> SELECT DISTINCT avtype FROM avion; AVTYPE ---------- A300 A320 B707 B727 Caravelle Concorde Il est possible de faire un DISTINCT de plusieurs colonnes. Exemple : SQL> SELECT DISTINCT avtype,cap FROM avion; AVTYPE CAP ---------- --------- A300 300 A300 400 A320 320 B707 400 B727 250 Caravelle 300 Concorde 300 Concorde 350 |
Alias des attributs
Ecrire la requête qui présente tous les pilotes de la compagnie avec le listing suivant:
Numéro Nom Adresse Salaire Mensuel
Redisposition des attributs
Ecrire la requête qui présente tous les pilotes de la compagnie avec le listing suivant
Nom Salaire Mensuel Numéro Adresse
Alias d’une table
Ecrire la requête qui renomme(alias) la relation PILOTE en P dans une requête.
Calculs horizontaux
Ecrire la requête qui calcule la durée d'un vol.
Ecrire une requête qui calcule le salaire annuel SAL_ANN, pour chaque pilote.
Calculs verticaux
Ecrire une requête qui calcule la somme des salaires des pilotes.
Distinct
Donner tous les types d'avions de la compagnie
SELECT FROM WHERE [NOT] prédicat1 [AND|OR] [NOT] prédicat2 La clause WHERE permet d’effectuer un filtrage de tuples. C'est à dire sélectionner un sous-ensemble de lignes dans les tables. Seules les lignes vérifiant la clause WHERE seront retournées. Prédicat : expression expression - Les opérateurs logiques (AND, OR) peuvent être utilisés dans le cas de prédicats multiples. - L'opérateur NOT inverse le sens du prédicat. - Pas de limite dans le nombre de prédicats. |
2.4. Opération de sélection (suite )
Exemples :
Lister tous les pilotes de la compagnie
SQL> SELECT *
FROM pilote;
==> - pas de sélection
- tous les tuples de la relation PILOTE sont ramenés
Lister les pilotes qui vivent à Nice
SQL> SELECT *
FROM PILOTE
WHERE ADR='Nice';
==> - sélection : clause WHERE
- seuls les tuples de la relation PILOTE vérifant la clause WHERE sont ramenés
Dans les critères de la clause WHERE, nous pouvons avoir les opérateurs de comparaison arithmétiques suivants :
= : égal,
!= : différent,
> : supérieur,
>= : supérieur ou égal,
< : inférieur,
<= : inférieur ou égal.
Exemple :
Liste des pilotes qui gagnent plus de 10000 et dont le numéro de tel est 93000000
SQL> SELECT plnom
FROM pilote
WHERE sal > 10000
AND tel='93000000';
Opérateur LIKE
Caractères jokers de l'opérateur LIKE :
% : remplace 0 à n caractères
_ : remplace 1 et un seul caractère
Exemple 1 :
Sélectionnez les pilotes dont le nom commence par M.
SQL> SELECT *
FROM pilote
WHERE plnom LIKE 'M%';
Exemple 2 :
SQL> SELECT * FROM pilote
WHERE plnom LIKE '___A%';
2.4.2. Critères de comparaison : opérateurs sur les chaînes : LIKE et SOUNDEX (suite )
La clause ESCAPE permet de de-spécialiser les caractères jokers :
_
et
%.
Le caractère précisé derrière la clause ESCAPE permet la recherche des caractères _ et % dans une chaîne de caractères.
Exemple 3 :
Sélectionnez les pilotes dont le nom contient le caractère _.
SQL> SELECT *
FROM pilote
WHERE plnom LIKE '%*_%' ESCAPE '*';
2.4.2. Critères de comparaison : opérateurs sur les chaînes : LIKE et SOUNDEX (suite )
Opérateur SOUNDEX
SOUNDEX(chaîne) est une fonction qui permet une comparaison phonétique.
SOUNDEX(chaîne) génère une valeur numérique sur 4 octets (selon un algorithme précis).
Pour faire une comparaison phonétique entre 2 chaînes :
SOUNDEX(chaîne1) = SOUNDEX(chaîne2)
Exemple :
Sélectionnez les pilotes dont le nom ressemble à Tonton
SQL> SELECT plnom
FROM pilote
WHERE SOUNDEX(plnom) = SOUNDEX('Tonton');
PLNOM
------------
Tintin
IN est l'opérateur qui permet de tester l'appartenance de la valeur d'une colonne à une liste.
Exemples :
Liste des vols dont la ville d'arrivée est Nice ou Paris.
SQL> SELECT vol#
FROM vol
WHERE va IN ('Nice ', 'Paris');
2.4.4. Critères de comparaison avec l'opérateur
BETWEEN est l'opérateur qui permet de tester si une valeur appartient à un intervalle.
Remarque : les bornes sont incluses.
Exemple :
Salaire et nom des pilotes gagnant entre 15000 et 18000
SQL> SELECT plnom, sal
FROM pilote
WHERE sal BETWEEN 15000 AND 18000;
PLNOM SAL
------------ ---------
Icare 17000,6
Mopolo 17000,6
Chretien 15000,6
Vernes 17000,6
Tournesol 15000,6
6 ligne(s) sélectionnée(s).
2.4.5. Critères de comparaison avec une valeur nulle
IS NULL et IS NOT NULL sont les opérateurs qui permettent de tester si une valeur a été définie ou pas pour une colonne. NULL : non défini.
SELECT
FROM table
WHERE coli IS NULL; coli non renseignée ou SELECT
FROM table
WHERE coli IS NOT NULL; coli renseignée
Remarque : pour tester l'absence de valeur , ne pas utiliser = NULL ou != NULL.
Note : la syntaxe de comparaison est la suivante :
colonne IS NULL | IS NOT NULL
Exemple :
Nom des pilotes dont le numéro de tél. n'est pas renseigné
SQL> SELECT plnom
FROM pilote
WHERE tel IS NULL;
2.4.6. Les opérateurs ANY, SOME et ALL
Ils se combinent avec l'un des opérateurs arithmétiques :
{= | != | > | >= | < | <= } ANY : au moins 1
SOME : au moins 1
ALL : tout
Exemple 1 :
Sélectionnez les pilotes dont l'adresse est 'Nice' ou 'Paris'
SQL> SELECT plnom
FROM pilote
WHERE adr = ANY ('Nice', 'Paris');
Remarques :
- l'opérateur ANY est équivalent à l'opérateur SOME.
- la condition =ANY est équivalent à l'opérateur IN.
2.4.6. Les opérateurs ANY, SOME et ALL (suite )
Exemple 2 :
Sélectionnez les pilotes dont le salaire n'est pas un nombre rond.
SQL> SELECT plnom
FROM pilote
WHERE sal != ALL (12000, 13000, 14000, 15000,
25000, 26000, 27000, 28000,29000);
Remarque :
La condition != ALL est équivalente à la condition NOT IN.
"Numéros et type d'avions de capacité supérieure à 300"
"Nom des pilotes habitants Nice ou Paris"
"Quels sont les noms de pilotes comportant un 't' en quatrième position ou dont le nom se prononce 'Bodri'.
"Quels sont les vols au départ de Nice, Paris ou Bordeaux ?"
"Quels sont les avions dont la capacité est comprise entre 250 et 310 ?"
"Quels sont les pilotes dont l'adresse ou le téléphone sont inconnus ?"
"Nom des pilotes ayant un 'a' et un 'e' dans leur nom"
"Nom des pilotes ayant 2 'o' dans leur nom "
"Nom des pilotes dont le numéro de téléphone est renseigné"
L’objectif est de faire des calculs sur des :
- constantes,
- variables
de type :
- numériques,
- caractères,
- dates.
Colonne Colonne
Constante Opérateur Constante
Fonction Fonction
- Opérateurs arithmétiques : + - * /
- Opérateur sur chaînes de caractères : ||
- Pas d'opérateurs spécifiques aux dates.
Exemple1 :
Simuler une augmentation de 10% des salaires des pilotes
SQL> SELECT sal * 1.10 AUGMENTATION
FROM pilote;
Exemple 2 :
Pilotes dont le salaire est supérieur à 2 fois 10000
SQL> SELECT *
FROM pilote
WHERE sal > 10 000 * 2;
2.5.1. Les expressions (suite )
Exemple 3 :
ajouter 3 jours à une date
'08-DEC-90' + 3 = '11-DEC-90'
Exemple 4 :
enlever 3 jours à une date
Exemple 5 :
nombre de jours entre 2 dates
date1 - date 2 = nbjours
2.5.1. Les expressions (suite )
Exemple 6 : Noms et adresses des pilotes SQL> SELECT plnom || ’---->’ || adr FROM pilote; PLNOM||’---->’||ADR ------------------------------------- Miranda ---->Sophia Antipolis St-exupéry ---->Lyon Armstrong ---->Wapakoneta Tintin ---->Bruxelles Gagarine ---->Klouchino Baudry ---->Toulouse Bush ---->Milton Ruskoi ---->Moscou Mathé ---->Paris Yen ---->Munich Icare ---->Ithaques Mopolo ---->Nice Chretien ----> Vernes ---->Paris Tournesol ---->Bruxelles Concorde ---->Paris scott ---->Nice Conficius ---->Pekin 18 ligne(s) sélectionnée(s). |
Fonctions numériques - ABS(n) : valeur absolue de n - SIGN(n) : signe de n (-1 ou 0 ou +1) - CEIL(n) : plus petit entier >= n - FLOOR(n) : plus grand entier <= n - MOD(m,n) : reste de la division de m par n - POWER(m,n) : m élevé à la puissance n - SQRT(n) : racine carrée de n (message d'erreur si n < 0) - ROUND(n,[m]) : arrondi de n à 10-m Ex : ROUND(125.2) = 125 ROUND(1600,-3) = 2000 ROUND(1100,- 3) = 1000 ROUND(345.343,2) = 345.34 ROUND(345.347,2) = 345.35 - TRUNC(n,[m]) : n tronqué à 10-m Ex : TRUNC(2500,-3) = 2000 TRUNC(2400,-3) = 2000 TRUNC(345.343,2) = 345.34 TRUNC(345.347,2) = 345.34 |
Fonctions caractères - UPPER(chaîne) : toutes les lettres de la chaîne en majuscules - LOWER(chaîne) : toutes les lettres de la chaîne en minuscules - INITCAP(chaîne) : première lettre de chaque mot de la chaîne en majuscules, les autres en minuscules) - LPAD(chaîne,lg,[chaîne]) : compléter à gauche par une chaîne de caractères sur une longueur donnée. Exemple : LPAD('DUPOND',10,'*# ') = '*#*#DUPOND' - RPAD(chaîne,lg,[chaîne]) : compléter à droite par une chaîne de caractères sur une longueur donnée. Exemple : RPAD('DUPOND',10,'* ') = 'DUPOND****' Remarque : LPAD et RPAD peuvent tronquer une chaîne si lg < longueur totale de la chaîne. |
- LTRIM(chaîne[,caractères]) : suppression à gauche de caractères dans la chaîne. Exemple : LTRIM('DUPOND','DU ') = 'POND' - RTRIM(chaîne[,caractères]) : suppression à droite de caractères dans la chaîne. Exemple : RTRIM('DUPOND','UD ') = 'DUPON' - SUBSTR(chaîne,position[,longueur]) : extraction d'une chaîne à partir d'une position donnée et sur une longueur donnée Exemple : SUBSTR('DUPOND',2,3) = 'UPO' INSTR('DUPOND','D',1,2) = 6 |
- REPLACE(chaîne,car[,chaîne]) : remplace un ensemble de caractères Exemples : REPLACE('TUTU','U', 'OU') = 'TOUTOU' REPLACE('TATA','T') = 'AA' - TRANSLATE(chaîne,car_source,car_cible) : trancodage de certains caractères par d'autres caractères dans une chaîne de caractères. Exemples : TRANSLATE(plnom,'AM','12') : - le A est remplacé par 1 - le M est remplacé par 2 dans les noms des pilotes - SOUNDEX(chaîne) : (voir 2.7.2) - ASCII(chaîne) : donne la correspondance ASCII du premier caractère de la chaîne. Exemple : ASCII('ADFGRSE') = 65 - CHR(n) : caractère correspondant à la valeur de n en ASCII. Exemple : CHR(65) = 'A' |
Fonctions date : - LAST_DAY(date) : dernier jour du mois d’une date donnée - NEXT_DAY(date, jour) : date du prochain jour à partir d'une date donnée. - ADD_MONTHS(date,n) : ajoute n mois à une date donnée. - MONTHS_BETWEEN(date1,date2) : nombre de mois entre 2 dates. - ROUND(date[,'precision']) : arrondi d'une date en fonction de la précision Exemples : SYSDATE = '12-JUL-96' ROUND(sysdate + 4 ,'MM') = '01-AUG-96' ROUND(sysdate,'YY') = '01-JAN-97' - TRUNC(date[,'precision']) : truncature d'une date en fonction de la précision Exemples : TRUNC(sysdate,'MM') = '01-JUL-96' TRUNC(sysdate + 4 ,'MM') = '01-JUL-96' TRUNC(sysdate,'YY') = '01-JAN-96' |
Fonctions de conversion de types : - TO_NUMBER(chaîne) : conversion d'une chaîne de caractères en nombre Exemple : TO_NUMBER('567') = 567 - TO_CHAR(val[,'format']) : conversion d'une expression (date ou numérique) en chaîne de caractères selon un format de présentation. - TO_DATE(chaîne[,'format']) : conversion d'une chaîne en date selon un format. Quelques formats numériques : 9 Affichage de cette valeur si elle est différente de 0 $ Affichage de la valeur préfixée par le signe '$ ' , Affichage de ',' à l'endroit indiqué . Affichage du point décima à l'endroit indiqué Exemple : TO_CHAR(1234,'0999999') = 0001234 |
Quelques formats de conversion de date : TO_CHAR(date[,’format’]) FORMAT étant la combinaison de codes suivants: YYYY Année YY 2 derniers chiffres de l'année MM numéro du mois DD numéro du jour dans le mois HH heure sur 12 heures HH24 heure sur 24 heures MI minutes SS secondes Exemple : SELECT TO_CHAR(SYSDATE,'DD MM YYYY HH24 : MI') FROM dual; ==> 01 07 1996 10 : 24 |
Pour avoir les dates en lettres utiliser les formats suivants : YEAR année en toutes lettres MONTH mois en toutes lettres DAY nom du jour DY nom du jour sur 3 lettres SP nombre en toutes lettres Exemple : TO_CHAR(SYSDATE,' « LE » DD MONTH YYYY « A » HH24 : MI') ==> LE 26 SEPTEMBER 1996 A 16 : 30 |
Fonctions diverses : NVL(expr,valeur) ==> Si expr IS NULL Alors valeur Sinon expr Finsi Exemple : SQL> SELECT NVL(sal,0) FROM pilote; DECODE(expression, valeur1, result1, [, valeur2, result2] [,defaut] ==> Si expression = valeur1 Alors result1 Sinon Si expression = valeur2 Alors result2 Sinon defaut Finsi Finsi Remarque : result1, result2, defaut peuvent être de types différents. Exemple : Select plnom, decode(tel, null, 'Pas de tél.', 'Tél : '|| tel) "Info Tél" From Pilote; PLNOMInfo Tel Miranda Tel : 93548254 St-exupery Tel : 91548254 … Vernes Pas de tel. Tournesol Pas de tel. … |
"Lister les pilotes avec leur salaire tronqués au millier"
"Lister les pilotes avec leur salaire. Pour ceux gagnant 17000,6 remplacer le salaire par '****' "
"Sélectionner les pilotes et leur téléphone. Pour ceux dont le télephone n'est pas renseigné, mettre ? "
Les fonctions de groupe sont les suivantes :
- AVG(expr) moyenne
- COUNT(expr) nombre
- MIN(expr) valeur minimum
- STDDEV(expr) écart-type
- SUM(expr) somme
- VARIANCE(expr) variance
Remarques :
- les valeurs NULL sont ignorées.
- COUNT(*) permet de compter les lignes d'une table.
Exemple :
SQL> SELECT adr, AVG(sal), COUNT(sal), MAX(sal),
MIN(sal), STDDEV(sal),SUM(sal),
VARIANCE(sal)
FROM pilote GROUP BY adr ;
Un résultat peut être trié grâce à la clause ORDER BY
- de façon ascendante ASC ou
- descendante DESC.
Remarques :
- par défaut en Oracle le tri est toujours ascendant.
- 16 critères de tri maximum.
- dans un tri par ordre croissant les valeurs NULL apparaissent toujours en dernier
Exemple :
SQL> SELECT plnom, adr
FROM pilote
ORDER BY plnom;
Généralités
A chaque table Oracle est associée un ensemble de colonnes implicites. Ces colonnes sont aussi appelées Pseudo Colonnes. Citons par exemple les colonnes
ROWID, USER, SYSDATE, ROWNUM, …
ROWID, USER, SYSDATE et ROWNUM représentent respectivement :
- l'adresse d'un tuple, composé de quatre champs:
* numéro de bloc dans le fichier,
* le numéro de tuple dans le bloc et
* le numéro de fichier,
* le numéro de segment
- l'utilisateur courant d'Oracle
- la date système
- numéro des lignes résultats d'une requête SQL
2.8. Utilisation des pseudo colonnes (suite)
Exemple Select Sysdate, user From Pilote; SYSDATE USER --------- -------- 08-JUN-99 SYSTEM 08-JUN-99 SYSTEM 08-JUN-99 SYSTEM 08-JUN-99 SYSTEM 08-JUN-99 SYSTEM 08-JUN-99 SYSTEM 08-JUN-99 SYSTEM 08-JUN-99 SYSTEM … 16 rows selected. |
2.8. Utilisation des pseudo colonnes (suite)
Exemple La table DUAL La table DUAL possède une seule colonne DUMMY et une seule ligne avec pour valeur X. Cette table sert à sélectionner des constantes, des pseudo colonnes ou des expressions en une seule ligne. Exemple : SQL> select SYSDATE, USER FROM ; SYSDATE USER --------- --------- 08-JUN-99 SYSTEM |
"Ecrire une requête qui donne le salaire du pilote qui gagne le plus :
<valeur à calculer> "Max salaire Pilote "
"Quels sont les noms, l'adresse et le salaire des pilotes de la compagnie, triés en ordre croissant sur l'adresse, et pour une même adresse en ordre décroissant sur le salaire ? "
"Ecrire une requête qui recherche si l'utilisateur courant d'Oracle est un pilote ?"
"Ecrire une requête qui rend ROWID, USER, SYSDATE, Numéros de vol de tous les vols effectués à la date d'aujourd'hui par le pilote Numéro 4 ?". L'heure de départ et d'arrivée doivent apparaître dans la liste des colonnes de projection.
Généralités
L’objectif de la jointure est de ramener sur une même ligne le résultat des informations venant de différentes tables.
Décomposition de la jointure :
1. Sélection
2. Projection des colonnes des différentes tables (colonnes du SELECT + colonnes de jointure)
3. Prédicat de jointure
4. Projection des colonnes du SELECT
Remarques :
- dans le prédicat de jointure comme dans le SELECT, préfixer les attributs si il y a ambiguité.
- dans le prédicat de jointure, les alias des tables peuvent être utilisés.
L'objectif de l'auto-jointure est de ramener sur la même ligne le résultat des informations provenant de 2 lignes de la même table.
2.9. Requêtes multi-relations sans sous-requêtes :
la jointure ou produit cartésien (suite)
Donner la liste des pilotes qui assurent un vol au départ de Nice.
Select distinct plnom
From Pilote p, Vol v
Where p.pl#=v.pilote# and vd = 'Nice';
PLNOM
------------
Armstrong
Bush
Chretien
Gagarine
Miranda
Mopolo
Tintin
7 rows selected.
2.9. Requêtes multi-relations sans sous-requêtes :
la jointure ou produit cartésien(suite)
Exemple 2 : avec auto jointure
Donner les couples des Pilotes qui gagnent le même
Salaire.
Select distinct p1.plnom, p2.plnom,
From Pilote p1, Pilote p2
Where and p1.plnom >p2.plnom
Order by sal;
PLNOM PLNOM SAL
------------ ------------ ---------
Tournesol Chretien 15000.6
Mopolo Icare 17000.6
Vernes Icare 17000.6
Vernes Mopolo 17000.6
Ruskoi Bush 22000
Généralités
L'objectif est de manipuler les ensembles ramenés par plusieurs SELECT à l'aide des opérateurs ensemblistes.
Les opérateurs ensemblistes sont :
- l'union : UNION,
- l'intersection : INTERSECT et
- la différence : MINUS
Principe :
SELECT FROM WHERE ==> ensemble opérateur ensembliste
SELECT FROM WHERE ==> ensemble opérateur ensembliste
SELECT FROM WHERE ==> ensemble
SELECT FROM WHERE ==> ensemble
[ORDER BY]
2.10. Requêtes multi-relations avec les opérateurs ensemblistes (suite )
Règles :
- même nombre de variables en projection
- correspondance de type
- colonne de tri référencées par numéro d'ordre
Résultat :
- les titres des colonnes sont ceux du premier SELECT
- la largeur de la colonne est celle de la plus grande largeur parmi les SELECT
2.10. Requêtes multi-relations avec les opérateurs ensemblistes (suite )
Exemple :
Considérons une compagnie aérienne dont les pilotes sont gérés par pays. Il peut être intéressant pour la direction d'avoir accès à l'ensemble des pilotes de l'entreprise.
Select plnom, sal from pilote_france
UNION
Select plnom, sal from pilote_usa
UNION
Select plnom, sal from pilote_Allemagne ;
Principe : lorsque dans un prédicat un des 2 arguments n'est pas connu, on utilise les sous-interrogations. SELECT FROM WHERE variable Op ? Le ? n'étant pas connu, il sera le résultat d'une sous-requête. Règle d'exécution : c’est la sous-requête de niveau le plus bas qui est évaluée en premier, puis la requête de niveau immédiatement supérieur, CAS 1 : sous-interrogation ramenant une valeur On utilise les opérateurs =, >, CAS 2 : sous-interrogation ramenant plusieurs valeurs On utilise les ALL, IN, ANY, SOME. Remarque : une sous-interrogation peut ramener plusieurs colonnes. (on teste l'égalité ou l'inégalité). |
Exemple lié au cas 1: Donner la liste des Pilote dont le salaire est supérieur à celui du pilote N°1. Select plnom, sal from pilote Where sal > (Select sal From Pilote Where pl# =1); PLNOM SAL ------------ --------- Armstrong 24500 Tintin 21100 Gagarine 22100 Baudry 21000 Bush 22000 Ruskoi 22000 Yen 29000 Concorde 1000.6 8 rows selected. |
2.11. Sous-interrogations (suite )
la sous-interrogation ramène VRAI s'il existe au moins une ligne en réponse à la sous-interrogation, FAUX sinon.
L'interrogation principale s'exécute si VRAI.
Syntaxe :
SELECT
FROM
WHERE [NOT] EXISTS (SELECT )
Exemple :
Donner la liste des Pilotes qui gagnent plus que tous les pilotes habitant Paris.
Select plnom, sal, adr From Pilote p1
WHERE Not Exists(Select From Pilote p2
Where = 'Paris' and <);
PLNOMSAL ADR
Armstrong 24500 Wapakoneta
Tintin 21100 Bruxelles
Gagarine 22100 Klouchino
Bush 22000 Milton
Ruskoi 22000 Moscou Yen 29000 Munich 6 rows selected.
La jointure externe ("outer join") se comporte comme l'opérateur de jointure avec en plus la possibilité de ramener des informations sur les lignes n'ayant pas vérifier la condition de jointure.
Cette fonctionnalité est directement offerte par SQL d'Oracle, en faisant suivre, dans la condition de jointure, la colonne de la table qui ne contient pas l’information recherchée, par le signe "(+)".
L'opérateur "(+)" nous permettra par exemple en un seul trait de lister les noms des Pilotes qui conduisent avec leurs Vols et pour ceux qui ne conduisent pas uniquement leurs noms.
Contraintes :
- l'opérateur de jointure externe "(+)" doit apparaître au plus une fois dans un predicat de jointure - pas de prédicat avec IN ou OR admis
Exemple :
Donner la liste Pilotes et les numéros de vol auxquels ils participent. Pour ceux qui ne participent à aucun, leur nom doit être affiché.
Select plnom, vol# From Pilote p, Vol v
Where p.pl# = v.pilote#(+) ;
Miranda 100
Miranda 150
St-exupery 153
Armstrong 110
Armstrong 290
Tintin 120
Tintin 130
Gagarine 111
Gagarine 200
Baudry
Bush 135
Bush 280
Bush 236
Ruskoi 156
Math
Yen
Icare 125
…
Principe :
lorsque dans un prédicat un des 2 arguments n'est pas connu, on utilise les sous-interrogations
SELECT
FROM
WHERE variable Op ?
(voir plus haut)
Mais lorsque la valeur ? est susceptible de varier pour chaque ligne, on utilise les sous-interrogations synchronisées.
Règles :
- le prédicat de la sous-interrogation fait référence à une colonne de l'interrogation principale
- si une table est présente dans les 2 select, la renommer
Exécution :
L'exécution de la sous-interrogation se fait pour chaque ligne de l'interrogation principale.
Exemple : Donner la liste des vols des Pilotes en service qui gagnent plus entre 20000 et 22000. Select distinct vol#, pilote# From Vol v Where pilote# in (Select p.pl# From Pilote p Where v.# And p.Sal>20000 and p.Sal<22000); VOL# PILOTE# --------- --------- 120 4 130 4 |
Requêtes avec alias obligatoires (auto-jointure) et préfixage d'attributs(naming)
"Donner toutes les paires de noms de pilotes distincts, habitant la même ville"
"Donner tous les noms des pilotes qui ont des noms d’avions ?"
"Ecrire la requête qui donne les noms des pilotes qui conduisent un A300 ou B727 ?".
"Tester la requête suivante :
(SELECT PILOTE#, VD, VA
FROM vol) INTERSECT
(SELECT AVION#, VD, VA
FROM VOL
);
Quel est sa signification en langage naturel ?
Sous-requêtes connectées par les opérateurs ANY, ALL, EXISTS, IN.
"Quel est le nom des avions dont la capacité est supérieure à la capacité de chaque avion localisé à
Nice ?"
"Quel est le nom des avions dont la capacité est au moins égale à celle d'un avion localisé à Nice ? "
"Quel est le nom des pilotes assurant un vol au départ de Nice ?"
"Quel est le nom des pilotes assurant au moins un vol ?"
"Quel est le nom des pilotes dont le salaire est supérieure au salaire maximum de tous les pilotes effectuant un vol au départ de Paris ?"
Requêtes multi-relations avec sous-requêtes indépendantes
"Quels sont les noms des pilotes qui gagnent plus que le pilote nr. 5?"
"Donner le nom des pilotes, et pour ceux qui sont en service, la liste des numéros de vols qu'ils assurent ?"
Généralités
Le SQL d'Oracle permet la représentation et la manipulation de données ayant une structure hiérarchique.
Les lignes résultats sont ordonnées selon le parcours de l'arbre.
Le niveau de la hiérarchie dans lequel se trouvent les données concernées par la recherche peut-être accessible par la pseudo-colonne (attribut implicite de la table), LEVEL, jusqu'à 256 niveaux.
SELECT <colonne [, colonne, ] >
FROM
[WHERE <expr>]
[AND <condition>]
[START WITH <Condition>] ;
Notes :
- START WITH : ligne(s) de départ de construction de l'arborescence (racine de l'arbre)
- CONNECT BY fixe le parcours de la hiérarchie (lien père-fils)
- PRIOR : colonne de départ
Exemple : "Quels sont les vols en correspondance (direct ou indirecte) au départ de Paris ?" Note : NICE ne doit pas être une escale de départ. SQL>column vol_en_corres format A30; SQL> Select LPAD(' ',2*(LEVEL),' ') || vol# vol_en_corres, vd, va From vol START WITH vd='Paris' CONNECT BY PRIOR va=vd AND vd != 'Nice'; Vol_en_CorresVDVA 125 Paris Nice 135 Paris Toulouse 130 Toulouse Beauvais 290 Beauvais Marseille 150 Paris Nantes 156 Paris Lyon 140 Lyon Nice 153 Lyon Nice 236 Lyon Toulouse 130 Toulouse Beauvais 290 Beauvais Marseille 270 Paris New york 12 rows selected. Paris De Paris nous pouvons atteindre Nice Toulouse, Nantes, Lyon et New York. La branche Nice n'est pas développée car Nice ne doit pas être une ville de Départ. De Toulouse nous pouvons atteindre Beauvais. …
Remarque sur le prédicat de sélection : - s'il est placé à l'extérieur de la clause CONNECT BY, il élimine certaines valeurs uniquement (le parcours de l'arborescence n'est pas interrompu) - si il est placé à l'intérieur de la clause CONNECT BY, il élimine certaines valeurs et leurs dépendances (le parcours de l'arborescence est interrompu). Limites : - une requête hiérarchique ne doit pas contenir de jointure - une requête hiérarchique ne peut être effectuée sur une vue de jointure - la clause ORDER BY est prioritaire à la clause CONNECT BY
EXERCICES Série 6"Quels sont les vols en correspondance (direct ou indirecte) au départ de Paris ?" Note : - NICE ne doit pas être une escale de départ. Le partitionnement permet de regrouper les lignes résultat en fonction des différentes valeurs prises par une colonne spécifiée. SELECT FROM <Nom_table> , GROUP BY <Colonne> [, <colonne>, ] [HAVING <condition>] ; La spécification de la clause GROUP BY entraîne la création d'autant de sous-tables qu'il y a de valeurs différentes pour la colonne de partitionnement spécifiée. De même que la clause WHERE joue le rôle de filtre pour la clause SELECT, la clause HAVING joue le rôle de filtre pour la clause GROUP BY. L'exécution de la clause HAVING sera effectuée juste après celle du GROUP BY, pour sélectionner les sous-tables qui satisfont la condition spécifiée. 2.15. Le partitionnement (suite)
EXERCICES Série 9"Créer une relation FORMATION, qui contiendra les renseignements suivants : - le numéro de pilote , - le type de formation (ATT, VDN, PAI, ) - type d'appareil - date de la formation " Attention : - un pilote à une date donnée participe à une formation - un type d'appareil doit être : 'A300', 'A310', 'A320', 'B707', 'Caravelle', 'B727' ou 'Concorde' Créer la clé primaire (comme en V6 : sans utiliser la clause PRIMARY KEY) sur le numéro du pilote et la date de formation. Créer un index unique sur la colonne PLNOM de PILOTE. Que constatez vous. Créer également un index sur la colonne AVTYPE de la table FORMATION. 4.8 Modification d’une table
4.8 Modification d’une table (suite)La clause ALTER TABLE permet (suite): 3. de redéfinir une colonne (type de données, taille, valeur par défaut) ALTER TABLE [<nom_user>.] <Table> MODIFY <def_col> avec <def_col> : Exemple Alter Table Pilote Modify (sal number(7,2)); Alter Table Pilote Modify (sal number(7,2) not null); Alter Table Pilote Modify (adr Default 'Nice');
4. de supprimer une colonne (type de données, taille, valeur par défaut) ALTER TABLE [<nom_user>.] <Table> DROP Column {col | ( col1, col2, … , coln)} Exemple Alter table Pilote Drop column age; Alter table Pilote Drop column (age, sal);
3.1.3. Variables faisant référence au dictionnaire de données (suite )
3.1.3. Variables faisant référence au dictionnaire de données (suite ) - Variable de même type qu'une autre variable Syntaxe : nom_var2 nom_var1%TYPE; Exemple : DECLARE ancien_sal NUMBER(5); nouveau_sal ancien_sal%TYPE;--NUMBER(5); BEGIN END; 3.1.4. Initialisation des variables
3.1.5. Visibilité des variables
|