D49996FR10 sg2

THESE eKIT MATERIALS ARE FOR YOUR USE IN THIS CLASSROOM ONLY.
COPYING eKIT MATERIALS FROM THIS COMPUTER IS STRICTLY PROHIBITED
D52770
Edition 1.0
Janvier 2008
D49996FR10
®
SQL (I)
Manuel du stagiaire - Volume II

Oracle Database 11g :
Les fondamentaux du langage
Oracle University and OMNIDATA. use only

Copyright © 2007, Oracle. Tous droits réservés.
THESE eKIT MATERIALS ARE FOR YOUR USE IN THIS CLASSROOM ONLY. COPYING eKIT MATERIALS FROM THIS COMPUTER IS STRICTLY PROHIBITED
Auteur
Avertissement
Puja Singh
Cette documentation contient des informations qui sont la propriété d'Oracle Corporation
Révisions et et sont protégées par les lois relatives aux droits d'auteur et à la propriété intellectuelle.
contributions techniques Vous ne pouvez copier et imprimer ce document qu'à des fins d'utilisation personnelle
lors de la participation à une formation dispensée par Oracle. Le document ne peut être
Claire Bennett modifié ou altéré en aucune manière. A l'exception des cas où l'utilisation faite du
document s'inscrit dans le respect des lois relatives aux droits d'auteur, vous ne pouvez
Tom Best pas utiliser, partager, télécharger, copier, imprimer, afficher, exécuter, reproduire, publier,
Purjanti Chang breveter, diffuser, transmettre ou distribuer ce document, en partie ou en totalité, sans
Ken Cooper l'autorisation expresse d'Oracle.
László Czinkóczki
Les informations fournies dans ce document sont susceptibles de modification sans
Burt Demchick préavis. Par ailleurs, Oracle Corporation ne garantit pas qu'elles soient exemptes
Mark Fleming d'erreurs et vous invite, le cas échéant, à lui en faire part par écrit à l'adresse suivante :
Gerlinde Frenzen Oracle University, 500 Oracle Parkway, Redwood Shores, California 94065 USA.
Nancy Greenberg
Restrictions applicables au gouvernement américain :
Chaitanya Koratamaddi Restricted Rights Notice
Wendy Lo

Timothy Mcglue If this documentation is delivered to the United States Government or anyone using the
Alan Paulson documentation on behalf of the United States Government, the following notice is
applicable:
Bryan Roberts
Abhishek Singh U.S. GOVERNMENT RIGHTS
Lori Tritz The U.S. Government’s rights to use, modify, reproduce, release, perform, display,
Michael Versaci or disclose these training materials are restricted by the terms of the applicable Oracle
license agreement and/or the applicable U.S. Government contract.
Lex van der Werff
Marques
Concepteurs graphique
Oracle est une marque déposée d'Oracle Corporation et/ou de ses filiales. Tout autre
Satish Bettegowda nom de produit ou de société peut être une marque de son propriétaire.
Samir Mozumdar
Rédacteurs
Amitha Narayan
Vijayalakshmi Narasimhan
Editeur
Sujatha Nagendra
Table des matières
Préface
I Introduction
Objectifs du cours I-2
Contenu du chapitre I-3
Objectifs du cours I-4
Contenu du cours I-5
Annexes du cours I-7

Oracle Database 11g : Domaines ciblés I-9
Oracle Database 11g I-10
Oracle Fusion Middleware I-12
Oracle Enterprise Manager Grid Control 10g I-13
Oracle BI Publisher I-14
Systèmes de gestion de base de données relationnelle et relationnelle objet I-16
Stocker des données sur différents supports I-17
Concept de base de données relationnelle I-18
Définition d'une base de données relationnelle I-19
Modèles de données I-20
Modèle entité/relation (ER) I-21
Conventions de modélisation entité/relation I-23
Lier plusieurs tables I-25
Base de données relationnelle : Terminologie I-27
Utiliser le langage SQL pour interroger une base de données I-30
Instructions SQL I-31
Environnements de développement pour le langage SQL I-32
Oracle SQL Developer : Présentation I-34
Oracle SQL Developer : Caractéristiques I-35
Interface d'Oracle SQL Developer I-36
Créer une connexion de base de données I-37
Consulter les objets de base de données I-40
Utiliser SQL Worksheet I-41
Exécuter des instructions SQL I-44
Formater le code SQL I-45
Enregistrer des instructions SQL I-46
iii
Exécuter des fichiers script I-47
Lancer SQL*Plus à partir d'Oracle SQL Developer I-48

Instructions SQL dans SQL*Plus I-49
Schéma Human Resources (HR) I-51
Tables utilisées dans le cours I-52
Documentation relative à Oracle Database 11g I-54
Ressources supplémentaires I-55
Synthèse I-56
Présentation de l'exercice I I-57
1 Extraire des données à l'aide de l'instruction SQL SELECT

Objectifs 1-2

Contenu du chapitre 1-3
Fonctionnalités des instructions SQL SELECT 1-4
Instruction SELECT de base 1-5
Sélectionner toutes les colonnes 1-6
Sélectionner des colonnes spécifiques 1-7
Ecrire des instructions SQL 1-8
En-têtes de colonne par défaut 1-9
Expressions arithmétiques 1-11
Utiliser des opérateurs arithmétiques 1-12
Priorité des opérateurs 1-13
Définir une valeur NULL 1-14
Valeurs NULL dans les expressions arithmétiques 1-15
Définir un alias de colonne 1-17
Utiliser des alias de colonne 1-18
Opérateur de concaténation 1-20
Chaînes de caractères littérales 1-21
Utiliser des chaînes de caractères littérales 1-22
Opérateur de délimitation (q) alternatif 1-23
Lignes en double 1-24
Afficher la structure d'une table 1-26
Utiliser la commande DESCRIBE 1-27
Synthèse 1-28
Présentation de l'exercice 1 1-29
iv
2 Restreindre et trier les données
Objectifs 2-2
Limiter les lignes par sélection 2-4
Limiter les lignes sélectionnées 2-5
Utiliser la clause WHERE 2-6
Chaînes de caractères et dates 2-7
Opérateurs de comparaison 2-8
Utiliser des opérateurs de comparaison 2-9
Indication d'une plage à l'aide de l'opérateur BETWEEN 2-10
Condition d'appartenance à l'aide de l'opérateur IN 2-11
Correspondance avec un modèle à l'aide de l'opérateur LIKE 2-12
Combiner des caractères génériques 2-13
Utiliser les conditions NULL 2-14

Définir des conditions à l'aide des opérateurs logiques 2-15
Utiliser l'opérateur AND 2-16
Utiliser l'opérateur OR 2-17
Utiliser l'opérateur NOT 2-18
Règles de priorité 2-20
Utiliser la clause ORDER BY 2-23
Tri 2-24
Variables de substitution 2-27
Utiliser une variable de substitution avec esperluette simple 2-29
Chaînes de caractères et dates avec variables de substitution 2-31
Indiquer des noms de colonne, des expressions et du texte 2-32
Utiliser une variable de substitution avec esperluette double 2-33
Utiliser la commande DEFINE 2-35
Utiliser la commande VERIFY 2-36
Synthèse 2-37
3 Utiliser des fonctions monolignes pour personnaliser les résultats

Objectifs 3-2
Fonctions SQL 3-4
Deux types de fonction SQL 3-5
Fonctions monolignes 3-6
Fonctions de type caractère 3-9
v
Fonctions de conversion de casse 3-11
Utiliser les fonctions de conversion de casse 3-12

Fonctions de manipulation de caractères 3-13
Utiliser les fonctions de manipulation de caractères 3-14
Fonctions numériques 3-16
Utiliser la fonction ROUND 3-17
Utiliser la fonction TRUNC 3-18
Utiliser la fonction MOD 3-19
Utiliser des dates 3-21
Format de date RR 3-22
Utiliser la fonction SYSDATE 3-24
Opérations arithmétique avec des dates 3-25

Utiliser des opérateurs arithmétiques avec des dates 3-26
Fonctions de manipulation de dates 3-28
Utiliser les fonctions de type date 3-29
Utiliser les fonctions ROUND et TRUNC avec des dates 3-30
Synthèse 3-31
4 Utiliser des fonctions de conversion et des expressions conditionnelles

Objectifs 4-2
Fonctions de conversion 4-4
Conversion implicite de types de données 4-5
Conversion explicite de types de données 4-7
Utiliser la fonction TO_CHAR avec des dates 4-11
Eléments du modèle de format de date 4-12
Utiliser la fonction TO_CHAR avec des dates 4-16
Utiliser la fonction TO_CHAR avec des nombres 4-17
Utiliser les fonctions TO_NUMBER et TO_DATE 4-20
Utiliser les fonctions TO_CHAR et TO_DATE avec le format de date RR 4-22
Fonctions d'imbrication 4-24
Fonctions générales 4-27
Fonction NVL 4-28
Utiliser la fonction NVL 4-29
Utiliser la fonction NVL2 4-30
Utiliser la fonction NULLIF 4-31
vi
Utiliser la fonction COALESCE 4-32

Expressions conditionnelles 4-36
Expression CASE 4-37
Utiliser l'expression CASE 4-38
Fonction DECODE 4-39
Utiliser la fonction DECODE 4-40
Synthèse 4-42
5 Créer un état avec des données agrégées à l'aide des fonctions de groupe
Objectifs 5-2
Fonctions de groupe : Présentation 5-4

Types de fonctions de groupe 5-5
Fonctions de groupe : Syntaxe 5-6
Utiliser les fonctions AVG et SUM 5-7
Utiliser les fonctions MIN et MAX 5-8
Utiliser la fonction COUNT 5-9
Utiliser le mot-clé DISTINCT 5-10
Fonctions de groupe et valeurs NULL 5-11
Créer des groupes de données 5-13
Créer des groupes de données : Syntaxe de la clause GROUP BY 5-14
Utiliser la clause GROUP BY 5-15
Procéder à un regroupement sur la base de plusieurs colonnes 5-17
Utiliser la clause GROUP BY sur plusieurs colonnes 5-18
Interrogations non autorisées avec les fonctions de groupe 5-19
Interrogations non autorisées avec les fonctions de groupe 5-20
Restreindre les résultats d'un groupe 5-21
Restreindre les résultats d'un groupe avec la clause HAVING 5-22
Utiliser la clause HAVING 5-23
Imbriquer des fonctions de groupe 5-26
Synthèse 5-27
6 Afficher des données provenant de plusieurs tables

Objectifs 6-2
Obtenir des données à partir de plusieurs tables 6-4
Types de jointure 6-5
Joindre des tables à l'aide de la syntaxe SQL:1999 6-6
vii
Qualifier les noms de colonne ambigus 6-7

Créer des jointures naturelles 6-9
Extraire des enregistrements avec des jointures naturelles 6-10
Créer des jointures à l'aide de la clause USING 6-11
Joindre des noms de colonne 6-12
Extraire des enregistrements avec la clause USING 6-13
Utiliser des alias de table avec la clause USING 6-14
Créer des jointures avec la clause ON 6-15
Extraire des enregistrements avec la clause ON 6-16
Créer des jointures à trois liens avec la clause ON 6-17
Appliquer des conditions supplémentaires à une jointure 6-18
Joindre une table à elle-même 6-20

Auto-jointures à l'aide de la clause ON 6-21
Non-équijointures 6-23
Extraire des enregistrements à l'aide de non-équijointures 6-24
Renvoyer des enregistrements sans correspondance directe à l'aide
de jointures externes 6-26
Comparaison entre les jointures INNER et OUTER 6-27
LEFT OUTER JOIN 6-28
RIGHT OUTER JOIN 6-29
FULL OUTER JOIN 6-30
Produit cartésien 6-32
Générer un produit cartésien 6-33
Créer des jointures croisées 6-34
Synthèse 6-35
7 Utiliser des sous-interrogations pour résoudre des interrogations

Objectifs 7-2
Utiliser une sous-interrogation
pour résoudre un problème 7-4
Syntaxe des sous-interrogations 7-5
Utiliser une sous-interrogation 7-6
Règles d'utilisation des sous-interrogations 7-7
Types de sous-interrogation 7-8
Sous-interrogations monolignes 7-10
viii
Exécuter des sous-interrogations monolignes 7-11
Utiliser des fonctions de groupe dans une sous-interrogation 7-12

Clause HAVING avec des sous-interrogations 7-13
Qu'est-ce qui est incorrect dans cette instruction ? 7-14
L'interrogation interne ne renvoie aucune ligne 7-15
Sous-interrogations multilignes 7-17
Utiliser l'opérateur ANY dans des sous-interrogations multilignes 7-18
Utiliser l'opérateur ALL dans des sous-interrogations multilignes 7-19
Valeurs NULL dans une sous-interrogation 7-21
Synthèse 7-23

8 Utiliser des opérateurs ensemblistes
Objectifs 8-2
Opérateurs ensemblistes (SET) 8-4
Règles relatives aux opérateurs ensemblistes 8-5
Le serveur Oracle et les opérateurs ensemblistes 8-6
Tables utilisées dans le chapitre 8-8
Opérateur UNION 8-13
Utiliser l'opérateur UNION 8-14
Opérateur UNION ALL 8-16
Utiliser l'opérateur UNION ALL 8-17
Opérateur INTERSECT 8-19
Utiliser l'opérateur INTERSECT 8-20
Opérateur MINUS 8-22
Utiliser l'opérateur MINUS 8-23
Assurer la correspondence des instructions SELECT 8-25
Assurer la correspondance des instructions SELECT : Exemple 8-26
Utiliser la clause ORDER BY dans des opérations ensemblistes 8-28
Synthèse 8-29
ix
9 Manipuler des données
Objectifs 9-2
Langage de manipulation de données 9-4
Ajouter une nouvelle ligne à une table 9-5
Syntaxe de l'instruction INSERT 9-6
Insérer de nouvelles lignes 9-7
Insérer des lignes comprenant des valeurs NULL 9-8
Insérer des valeurs spéciales 9-9
Insérer des valeurs de date et d'heure spécifiques 9-10
Créer un script 9-11
Copier des lignes depuis une autre table 9-12
Modifier des données dans une table 9-14

Syntaxe de l'instruction UPDATE 9-15
Mettre à jour des lignes d'une table 9-16
Mettre à jour deux colonnes avec une sous-interrogation 9-17
Mettre à jour des lignes sur la base d'une autre table 9-18
Supprimer une ligne d'une table 9-20
Instruction DELETE 9-21
Supprimer des lignes d'une table 9-22
Supprimer des lignes sur la base d'une autre table 9-23
Instruction TRUNCATE 9-24
Transactions de base de données 9-26
Transactions de base de données : Début et fin 9-27
Avantages des instructions COMMIT et ROLLBACK 9-28
Instructions explicites de contrôle des transactions 9-29
Annuler des modifications jusqu'à un marqueur 9-30
Traitement implicite des transactions 9-31
Etat des données avant exécution de l'instruction COMMIT ou ROLLBACK 9-33
Etat des données après exécution de l'instruction COMMIT 9-34
Valider les données 9-35
Etat des données après exécution de l'instruction ROLLBACK 9-36
Etat des données après exécution de l'instruction ROLLBACK : Exemple 9-37
Annulation au niveau instruction 9-38
Cohérence en lecture 9-40
Implémenter la cohérence en lecture 9-41
Clause FOR UPDATE dans une instruction SELECT 9-43
Clause FOR UPDATE : Exemples 9-44
x
Synthèse 9-46
10 Utiliser des instructions LDD pour créer et gérer des tables

Objectifs 10-2
Objets de base de données 10-4
Règles d'appellation 10-5
Instruction CREATE TABLE 10-7
Référencer les tables d'un autre utilisateur 10-8
Option DEFAULT 10-9
Créer des tables 10-10

Types de données 10-12
Types de données date-heure 10-14
Inclure des contraintes 10-17
Règles relatives aux contraintes 10-18
Définir des contraintes 10-19
Contrainte NOT NULL 10-21
Contrainte UNIQUE 10-22
Contrainte PRIMARY KEY 10-24
Contrainte FOREIGN KEY 10-25
Contrainte FOREIGN KEY : Mots-clés 10-27
Contrainte CHECK 10-28
CREATE TABLE : Exemple 10-29
Violation de contraintes 10-30
Créer une table à l'aide d'une sous-interrogation 10-33
Instruction ALTER TABLE 10-36
Tables en lecture seule 10-37
Supprimer une table 10-39
Synthèse 10-40
11 Créer d'autres objets de schéma

Objectifs 11 -2
Contenu du chapitre 11 -3
Objets de base de données 11 -4
Vue : Présentation 11 -5
xi
Avantages des vues 11 -6
Vues simples et vues complexes 11 -7

Créer une vue 11 -8
Extraire des données d'une vue 11 -11
Modifier une vue 11 -12
Créer une vue complexe 11 -13
Règles relatives à l'exécution d'opérations LMD sur une vue 11 -14
Utiliser la clause WITH CHECK OPTION 11 -17
Empêcher les opérations LMD 11 -18
Supprimer une vue 11 -20
Présentation de l'exercice 11 : Première partie 11 -21
Séquences 11 -23
Instruction CREATE SEQUENCE : Syntaxe 11 -25

Créer une séquence 11 -26
Pseudo-colonnes NEXTVAL et CURRVAL 11 -27
Utiliser une séquence 11 -29
Mettre en mémoire cache les valeurs d'une séquence 11 -30
Modifier une séquence 11 -31
Règles de modification d'une séquence 11 -32
Index 11 -34
Modes de création d'un index 11 -36
Créer un index 11 -37
Règles de création d'un index 11 -38
Supprimer un index 11 -39
Synonymes 11 -41
Créer un synonyme pour un objet 11 -42
Créer et supprimer des synonymes 11 -43
Synthèse 11 -44
Présentation de l'exercice 11 : Deuxième partie 11 -45
Annexe A - Solutions des exercices

Annexe B - Description des tables
Annexe C - Syntaxe de jointure Oracle
Annexe D - Utiliser SQL*Plus
Annexe E - Effectuer des opérations LMD et LDD à l'aide de l'interface
graphique SQL Developer
Index
Exercices supplémentaires
Solutions des exercices supplémentaires
xii
Préface


Profil
Avant de commencer
Avant de commencer ce cours, vous devez savoir utiliser une interface graphique. Le prérequis
pour ce cours est de maîtriser les techniques et les concepts de traitement des données.
Organisation du cours
OracleAS 11g : Les fondamentaux du langage SQL (I) est un cours en salle comprenant un exposé
théorique et des exercices pratiques. Les démonstrations en ligne et les sessions d'exercices
permettent de renforcer les concepts et les techniques présentés.
Préface - 3
Documentation
Documentation Oracle
Titre Référence
Oracle® Database Reference 11g Release 1 (11.1) B28320-01
Oracle® Database SQL Language Reference 11g B28286-01
Release 1 (11.1)
Oracle® Database Concepts 11g Release 1 (11.1) B28318-01
Oracle® Database SQL Developer User's Guide E10406-01
Release 1.2
Autre documentation
• System release bulletins (Bulletins techniques)

• Guides d'installation et guides de l'utilisateur
• Fichiers readme
• Articles du groupe IOUG (International Oracle User's Group)
• Oracle Magazine
Préface - 4
Conventions typographiques
Les deux listes suivantes de conventions typographiques sont utilisées pour du texte ou du code.
Conventions typographiques concernant le texte
Convention Elément Exemple
Majuscules Commandes, Utilisez la commande SELECT pour
fonctions, visualiser les informations stockées dans la
noms de colonne, colonne LAST_NAME de la table
noms de table, EMPLOYEES.
objets PL/SQL,
schémas
Minuscules, Noms de fichier, où : rôle correspond au nom du en
italiques Variables rôle à définir.
noms d'utilisateur,

mots de passe
Initiale Déclencheur et Attribuez un déclencheur When-Validate- en
majuscule boutons Item au bloc ORD.
Cliquez sur Cancel.
Italiques Manuels, titres de Pour en savoir plus, voir
cours et de Oracle SQL Reference
manuels, Manual
locutions et
mots mis en évidence N'enregistrez pas les modifications dans la
base de données.
Guillemets Titres de chapitre Ce sujet est traité dans le chapitre 3,
cités en référence "Gérer les objets."
au sein d'un cours
Préface - 5
Conventions typographiques (suite)
Conventions typographiques concernant le texte

Convention Elément Exemple
Majuscules Commandes et SELECT employee_id
fonctions FROM employees;
Minuscules Variables CREATE ROLE role;
italiques
Initiale Déclencheurs Trigger level: S_ITEM.QUANTITY
en majuscule Oracle Forms item
Trigger name: When-Validate-Item
. . .

Minuscules Noms de colonne, . . .
noms de table, OG_ACTIVATE_LAYER
noms de fichier, (OG_GET_LAYER ('prod_pie_layer'))
objets PL/SQL . . .
SELECT last_name
FROM employees;
Gras Texte devant être CREATE USER scott
saisi par un IDENTIFIED BY tiger;
utilisateur
Préface - 6

Manipuler des données

Objectifs
A la fin de ce chapitre, vous pourrez :

• décrire chaque instruction LMD (Langage de manipulation
de données)
• insérer des lignes dans une table
• mettre à jour des lignes d'une table
• supprimer des lignes d'une table
• contrôler les transactions

Objectifs
Dans ce chapitre, vous allez apprendre à utiliser les instructions LMD (Langage de
manipulation de données) pour insérer des lignes dans une table, et mettre à jour ou
supprimer des lignes existantes dans une table. Vous allez également apprendre à contrôler
les transactions avec les instructions COMMIT, SAVEPOINT et ROLLBACK.
Oracle Database 11g : Les fondamentaux du langage SQL (I) 9 - 2

Contenu du chapitre
• Ajouter de nouvelles lignes dans une table

– Instruction INSERT
• Modifier des données dans une table
– Instruction UPDATE
• Supprimer des lignes d'une table :
– Instruction DELETE
– Instruction TRUNCATE
• Contrôler les transactions de base de données à l'aide
des instructions COMMIT, ROLLBACK et SAVEPOINT

• Cohérence en lecture
• Clause FOR UPDATE dans une instruction SELECT

Langage de manipulation de données
• Une instruction LMD est exécutée dans les cas suivants :

– Vous ajoutez de nouvelles lignes à une table.
– Vous modifiez des lignes existantes d'une table.
– Vous supprimez des lignes existantes d'une table.
• Une transaction est composée d'un ensemble d'instructions
LMD qui forment une unité de travail logique.

Langage de manipulation de données

Le langage de manipulation de données (LMD) est un composant essentiel du langage
SQL. Lorsque vous ajoutez, mettez à jour ou supprimez des données dans la base, vous
exécutez une instruction LMD. Un ensemble d'instructions LMD formant une unité de
travail logique est appelé une transaction.
Prenons l'exemple d'une base de données bancaire. Lorsqu'un client de la banque transfère
de l'argent d'un compte d'épargne vers un compte chèques, la transaction peut être
décomposée en trois opérations distinctes : débit du compte d'épargne, crédit du compte
chèques et enregistrement de la transaction dans le journal des transactions. Le serveur
Oracle doit vérifier que les trois instructions SQL sont exécutées de manière à préserver
l'équilibre des comptes. Si quelque chose empêche l'exécution de l'une des instructions de
la transaction, les autres instructions doivent être annulées.
Remarque : La plupart des instructions LMD étudiées de ce chapitre supposent l'absence
de violation des contraintes concernant la table. Les contraintes seront traitées
ultérieurement dans ce cours.
Remarque : Dans SQL Developer, pour exécuter les instructions LMD, cliquez sur l'icône
Run Script ou appuyez sur [F5]. Les messages renvoyés apparaissent dans l'onglet Script
Output.

Ajouter une nouvelle ligne à une table
Nouvelle
DEPARTMENTS ligne
Insérez une nouvelle ligne

dans la table
DEPARTMENTS.

Ajouter une nouvelle ligne à une table

Le graphique de la diapositive ci-dessus illustre l'ajout d'un nouveau département à la table
DEPARTMENTS.

Syntaxe de l'instruction INSERT
• Ajoutez de nouvelles lignes à une table à l'aide de

l'instruction INSERT :
INSERT INTO table [(column [, column...])]
VALUES (value [, value...]);
• Avec cette syntaxe, une seule ligne est insérée à la fois.

Syntaxe de l'instruction INSERT

Vous pouvez ajouter de nouvelles lignes à une table en exécutant l'instruction INSERT.
Dans la syntaxe :
table Est le nom de la table.
column Est le nom de la colonne dans la table à remplir.
value Est la valeur correspondante de la colonne.
Remarque : Pour ajouter une seule ligne à la fois à une table, utilisez la clause VALUES.

Insérer de nouvelles lignes
• Insérez une nouvelle ligne contenant des valeurs

pour chaque colonne.
• Enumérez les valeurs dans l'ordre par défaut des colonnes
de la table.
• Enumérez éventuellement les colonnes indiquées
dans la clause INSERT.
INSERT INTO departments(department_id,
department_name, manager_id, location_id)
VALUES (70, 'Public Relations', 100, 1700);

• Placez les valeurs de type caractère et date entre
apostrophes.
Insérer de nouvelles lignes

Puisque vous pouvez insérer une nouvelle ligne contenant des valeurs pour chaque colonne,
la liste de colonnes n'est pas obligatoire dans la clause INSERT. Toutefois, si vous
n'indiquez pas de liste de colonnes, vous devez énumérer les valeurs selon l'ordre par défaut
des colonnes de la table et fournir une valeur pour chaque colonne.
DESCRIBE departments
Pour plus de clarté, précisez la liste de colonnes dans la clause INSERT.

Placez les valeurs de type date et de type caractère entre apostrophes. En revanche, il est
déconseillé d'en faire autant avec les valeurs numériques.

Insérer des lignes comprenant des valeurs NULL
• Méthode implicite : Omettre la colonne de la liste.

INSERT INTO departments (department_id,
department_name)
VALUES (30, 'Purchasing');
• Méthode explicite : Indiquer le mot-clé NULL dans la clause

VALUES.
INSERT INTO departments
VALUES (100, 'Finance', NULL, NULL);

Insérer des lignes comprenant des valeurs NULL

Méthode Description
Implicite Omettre la colonne de la liste.
Explicite Indiquer le mot-clé NULL dans la liste VALUES.
Indiquer la chaîne vide ('') dans la liste VALUES pour les chaînes
de caractères et les dates.
Assurez-vous de pouvoir utiliser des valeurs NULL dans la colonne considérée, à l'aide
de la commande DESCRIBE.
Le serveur Oracle applique automatiquement l'ensemble des types de données, des plages
de données et des contraintes d'intégrité des données. Toute colonne qui n'est pas indiquée
explicitement reçoit une valeur NULL dans la nouvelle ligne.
Les erreurs courantes qui peuvent se produire pendant la saisie par l'utilisateur sont
vérifiées dans l'ordre suivant :
• Valeur obligatoire manquante pour une colonne NOT NULL.
• Valeur en double violant une contrainte de clé unique ou primaire.
• Valeur quelconque (Any) violant une contrainte CHECK.
• Préservation de l'intégrité référentielle en cas de contrainte de clé étrangère.
• Non-concordance des types de données ou valeurs trop longues pour tenir dans la
colonne.
Remarque : Il est recommandé d'indiquer la liste de colonnes car l'instruction INSERT est
ainsi plus lisible et plus fiable, ou moins sujette aux erreurs.

Insérer des valeurs spéciales
La fonction SYSDATE enregistre la date du jour et l'heure

actuelle.
INSERT INTO employees (employee_id,
first_name, last_name,
email, phone_number,
hire_date, job_id, salary,
commission_pct, manager_id,
department_id)
VALUES (113,
'Louis', 'Popp',

'LPOPP', '515.124.4567',
SYSDATE, 'AC_ACCOUNT', 6900,
NULL, 205, 110);
Insérer des valeurs spéciales

Vous pouvez utiliser des fonctions pour entrer des valeurs spéciales dans une table.
L'exemple de la diapositive ci-dessus enregistre des informations concernant l'employé
Popp dans la table EMPLOYEES. Il insère la date du jour et l'heure actuelle dans la colonne
HIRE_DATE. Il utilise pour cela la fonction SYSDATE qui renvoie la date du jour et
l'heure actuelle du serveur de base de données. Vous pouvez aussi utiliser la fonction
CURRENT_DATE pour obtenir la date du jour correspondant au fuseau horaire de la
session. Lors de l'insertion de lignes dans une table, vous pouvez par ailleurs utiliser la
fonction USER , qui enregistre le nom de l'utilisateur en cours.
Vérifier les ajouts à la table
SELECT employee_id, last_name, job_id, hire_date, commission_pct
FROM employees
WHERE employee_id = 113;

Insérer des valeurs de date et d'heure spécifiques
• Ajoutez un nouvel employé.

INSERT INTO employees
VALUES (114,
'Den', 'Raphealy',
'DRAPHEAL', '515.127.4561',
TO_DATE('FEB 3, 1999', 'MON DD, YYYY'),
'SA_REP', 11000, 0.2, 100, 60);
• Vérifiez votre ajout.

Insérer des valeurs de date et d'heure spécifiques

Le format utilisé pour l'insertion d'une valeur de date est généralement DD-MON-RR.
Avec le format RR, le système fournit automatiquement le siècle correct.
Vous pouvez également fournir la date au format DD-MON-YYYY. Ce format est
recommandé car il indique clairement le siècle et ne dépend pas de la logique interne
associée au format RR.
Si une date doit être saisie dans un format autre que celui par défaut (par exemple, avec un
autre siècle ou une heure spécifique), vous devez utiliser la fonction TO_DATE.
L'exemple de la diapositive ci-dessus enregistre des informations concernant l'employé
Raphealy dans la table EMPLOYEES. Il attribue la valeur February 3, 1999 à la colonne
HIRE_DATE.

Créer un script
• Utilisez une variable de substitution avec esperluette (&) dans

une instruction SQL pour afficher une invite de saisie de valeur.
• Une telle variable est un paramètre substituable pour une
valeur.
(department_id, department_name, location_id)
VALUES (&department_id, '&department_name',&location);

Créer un script
Vous pouvez enregistrer des commandes comprenant des variables de substitution dans un
fichier, puis exécuter ce fichier. L'exemple de la diapositive ci-dessus enregistre des
informations concernant un département dans la table DEPARTMENTS.
Lorsque vous exécutez le fichier script, vous êtes invité à saisir une valeur pour chacune
des variables avec esperluette (&) d'interprétation. Après avoir saisi la valeur appropriée,
cliquez sur le bouton OK. Les valeurs que vous indiquez sont utilisées dans l'instruction.
Vous pouvez ainsi exécuter indéfiniment le même fichier script, en fournissant un jeu de
valeurs différent à chaque fois.

Copier des lignes depuis une autre table
• Ecrivez votre instruction INSERT avec une

sous-interrogation :
INSERT INTO sales_reps(id, name, salary, commission_pct)
SELECT employee_id, last_name, salary, commission_pct
FROM employees
WHERE job_id LIKE '%REP%';
• N'utilisez pas la clause VALUES.

• Le nombre de colonnes de la clause INSERT doit

correspondre à celui de la sous-interrogation.
• Insérez toutes les lignes renvoyées par la sous-interrogation
dans la table sales_reps.
Copier des lignes depuis une autre table

Vous pouvez utiliser l'instruction INSERT pour ajouter à une table des lignes dont les
valeurs proviennent de tables existantes. Dans l'exemple de la diapositive ci-dessus, pour
que l'instruction INSERT INTO fonctionne, vous devez avoir créé la table sales_reps
à l'aide de l'instruction CREATE TABLE. Cette instruction sera décrite dans le chapitre
suivant, "Utiliser des instructions LDD pour créer et gérer des tables".
A la place de la clause VALUES, vous utilisez une sous-interrogation.
Syntaxe
INSERT INTO table [ column (, column) ] subquery;
Dans la syntaxe :
column Est le nom de la colonne à remplir dans la table.
subquery Est la sous-interrogation qui renvoie des lignes vers la table.
Les colonnes indiquées dans la clause INSERT doivent correspondre en termes de nombre
et de type de données aux valeurs de la sous-interrogation. Le nombre de lignes ajoutées
dépend du nombre de lignes renvoyées par la sous-interrogation. Pour créer une copie des
lignes d'une table, utilisez SELECT * dans la sous-interrogation :
INSERT INTO copy_emp
SELECT *
FROM employees;

Contenu du chapitre



Modifier des données dans une table
EMPLOYEES
Mettez des lignes à jour dans la table

EMPLOYEES :

Modifier des données dans une table

La diapositive ci-dessus illustre la modification de l'ID de département pour les employés
du département 60 (qui est remplacé par 80).

Syntaxe de l'instruction UPDATE
• Modifiez les valeurs existantes d'une table avec l'instruction

UPDATE :
UPDATE table
SET column = value [, column = value, ...]
[WHERE condition];
• Mettez à jour plusieurs lignes à la fois (si nécessaire).

Syntaxe de l'instruction UPDATE

Vous pouvez modifier les valeurs existantes d'une table à l'aide de l'instruction UPDATE.
Dans la syntaxe :
column Est le nom de la colonne à remplir dans la table.
value Est la valeur ou la sous-interrogation associée à la colonne.
condition Identifie les lignes à mettre à jour et se compose de noms de colonne,
d'expressions, de constantes, de sous-interrogations et d'opérateurs
de comparaison.
Vérifiez l'opération de mise à jour en interrogeant la table pour afficher les lignes
modifiées.
Pour plus d'informations, reportez-vous à la section "UPDATE" du manuel Oracle
Database SQL Language Reference 11g, Release 1 (11.1).
Remarque : En règle générale, utilisez la colonne de clé primaire dans la clause WHERE
pour identifier une ligne unique à mettre à jour. L'utilisation d'autres colonnes peut
entraîner la mise à jour inattendue de plusieurs lignes. Par exemple, il peut s'avérer
dangereux d'identifier une ligne unique de la table EMPLOYEES en fonction du nom, car
plusieurs employés peuvent porter le même nom.

Mettre à jour des lignes d'une table
• Si vous indiquez la clause WHERE, seules les valeurs

d'une ou plusieurs lignes spécifiques sont modifiées :
UPDATE employees
SET department_id = 50
• Si vous omettez la clause WHERE, les valeurs de toutes

les lignes de la table sont modifiées :

UPDATE copy_emp
SET department_id = 110;
• Indiquez SET column_name= NULL pour remplacer

la valeur d'une colonne par NULL.
Mettre à jour des lignes d'une table

Si la clause WHERE est indiquée, l'instruction UPDATE modifie les valeurs d'une ou de
plusieurs lignes spécifiques. L'exemple de la diapositive ci-dessus illustre le transfert de
l'employé 113 (Popp) vers le département 50.
Si vous omettez la clause WHERE, les valeurs de toutes les lignes de la table sont modifiées.
Examinez les lignes mises à jour dans la table COPY_EMP.
SELECT last_name, department_id
FROM copy_emp;
…
Par exemple, un employé qui occupait le poste SA_REP occupe désormais le poste
IT_PROG. Son JOB_ID doit donc être mis à jour et la valeur NULL doit être attribuée au
champ de commission.
UPDATE employees
SET job_id = 'IT_PROG', commission_pct = NULL
Remarque : La table COPY_EMP contient les mêmes données que la table EMPLOYEES.

Mettre à jour deux colonnes avec
une sous-interrogation
Mettez à jour le poste et le salaire de l'employé 113 de sorte
qu'ils correspondent à ceux de l'employé 205.
UPDATE employees
SET job_id = (SELECT job_id
FROM employees
WHERE employee_id = 205),
salary = (SELECT salary
FROM employees
WHERE employee_id = 205)

Mettre à jour deux colonnes avec une sous-interrogation

Vous pouvez mettre à jour plusieurs colonnes dans la clause SET d'une instruction
UPDATE en écrivant plusieurs sous-interrogations. La syntaxe est la suivante :
UPDATE table
SET column =
(SELECT column
FROM table
WHERE condition)
[ ,
column =
(SELECT column
FROM table
WHERE condition)]
[WHERE condition ] ;
L'exemple de la diapositive ci-dessus peut aussi être écrit comme suit :
UPDATE employees
SET (job_id, salary) = (SELECT job_id, salary
FROM employees

Mettre à jour des lignes sur la base
d'une autre table

Utilisez les sous-interrogations des instructions UPDATE pour
mettre à jour les valeurs des lignes d'une table sur la base des
valeurs d'une autre table :
UPDATE copy_emp
SET department_id = (SELECT department_id
FROM employees
WHERE job_id = (SELECT job_id
FROM employees
WHERE employee_id = 200);

Mettre à jour des lignes sur la base d'une autre table

Vous pouvez utiliser les sous-interrogations des instructions UPDATE pour mettre à jour les
valeurs d'une table. L'exemple de la diapositive ci-dessus met à jour la table COPY_EMP
sur la base des valeurs de la table EMPLOYEES. Il remplace l'ID de département de tous les
employés dotés de l'ID de poste 200 par l'ID de département actuel de l'employé 100.

Contenu du chapitre



Supprimer une ligne d'une table
DEPARTMENTS
Supprimez une ligne de la table DEPARTMENTS :

Supprimer une ligne d'une table

Le département Contracting a été supprimé de la table DEPARTMENTS (il est supposé
qu'aucune contrainte concernant la table DEPARTMENTS n'est violée), comme illustré dans
la diapositive ci-dessus.

Instruction DELETE
Vous pouvez supprimer des lignes existantes d'une table à

l'aide de l'instruction DELETE :
DELETE [FROM] table

[WHERE condition];

Syntaxe de l'instruction DELETE

Vous pouvez supprimer des lignes existantes d'une table à l'aide de l'instruction DELETE.
Dans la syntaxe :
condition Identifie les lignes à mettre à jour et se compose de noms de colonne,
d'expressions, de constantes, de sous-interrogations et d'opérateurs
de comparaison.
Remarque : Si aucune ligne n'est supprimée, le message "0 rows deleted" est renvoyé
(dans l'onglet Script Output de SQL Developer).
Pour plus d'informations, reportez-vous à la section DELETE du manuel Oracle Database
SQL Language Reference 11g, Release 1 (11.1).

Supprimer des lignes d'une table
• Si vous indiquez la clause WHERE, des lignes spécifiques

sont supprimées :
DELETE FROM departments
WHERE department_name = 'Finance';
• Si vous omettez la clause WHERE, toutes les lignes

de la table sont supprimées :

DELETE FROM copy_emp;
Supprimer des lignes d'une table

Vous pouvez supprimer des lignes spécifiques en indiquant la clause WHERE dans
l'instruction DELETE. Le premier exemple de la diapositive ci-dessus supprime le
département Accounting de la table DEPARTMENTS. Vous pouvez vérifier l'opération de
suppression en affichant les lignes supprimées à l'aide de l'instruction SELECT.
SELECT *
FROM departments
WHERE department_name = 'Finance';
Toutefois, si vous omettez la clause WHERE, toutes les lignes de la table sont supprimées.
Le deuxième exemple de la diapositive supprime toutes les lignes de la table COPY_EMP
car aucune clause WHERE n'a été indiquée.
Exemple :
Supprimez les lignes identifiées dans la clause WHERE.
DELETE FROM employees WHERE employee_id = 114;
DELETE FROM departments WHERE department_id IN (30, 40);

Supprimer des lignes sur la base
d'une autre table

Utilisez les sous-interrogations des instructions DELETE
pour supprimer des lignes d'une table sur la base des valeurs
d'une autre table :
DELETE FROM employees
WHERE department_id =
(SELECT department_id
FROM departments
WHERE department_name
LIKE '%Public%');

Supprimer des lignes sur la base d'une autre table

Vous pouvez utiliser les sous-interrogations pour supprimer des lignes d'une table sur la
base des valeurs d'une autre table. L'exemple de la diapositive ci-dessus supprime tous les
employés des départements dont le nom contient la chaîne Public. La sous-interrogation
recherche dans la table DEPARTMENTS l'ID de département sur la base du nom de
département contenant la chaîne Public. La sous-interrogation fournit ensuite l'ID de
département à l'interrogation principale, qui supprime des lignes de données de la table
EMPLOYEES sur la base de cet ID de département.

Instruction TRUNCATE
• Elle supprime toutes les lignes d'une table, en laissant

cette dernière vide sans toucher à sa structure.
• Il s'agit d'une instruction LDD (langage de définition
de données) et non d'une instruction LMD. Il est donc difficile
de l'annuler.
• Syntaxe :
TRUNCATE TABLE table_name;
• Exemple :

TRUNCATE TABLE copy_emp;
Instruction TRUNCATE
La méthode la plus efficace pour vider une table consiste à utiliser l'instruction
TRUNCATE.
Vous pouvez recourir à cette instruction pour supprimer rapidement toutes les lignes d'une
table ou d'un cluster. Il est plus rapide de supprimer des lignes avec l'instruction
TRUNCATE qu'avec l'instruction DELETE pour les raisons suivantes :
• TRUNCATE est une instruction LDD (langage de définition de données) qui ne génère
aucune donnée d'annulation (rollback). Les données d'annulation seront traitées
ultérieurement dans ce chapitre.
• Le fait de vider une table n'active pas les déclencheurs (triggers) de suppression de la
table.
Si la table est le parent d'une contrainte d'intégrité référentielle, vous ne pouvez pas la
vider. Vous devez désactiver la contrainte avant d'exécuter l'instruction TRUNCATE. La
désactivation des contraintes sera traitée dans un autre chapitre.

Contenu du chapitre



Transactions de base de données
Une transaction de base de données se compose

des éléments suivants :
• Des instructions LMD qui apportent une modification
cohérente aux données
• Une instruction LDD
• Une instruction LCD (langage de contrôle de données)

Transactions de base de données

Le serveur Oracle garantit la cohérence des données par l'intermédiaire des transactions.
Ces dernières offrent davantage de souplesse et de contrôle lors de la modification des
données. Par ailleurs, elles garantissent la cohérence des données en cas de défaillance du
système ou d'échec d'un processus utilisateur.
Les transactions se composent d'instructions LMD qui apportent une modification
cohérente aux données. Par exemple, un virement entre deux comptes doit inclure le débit
d'un compte et le crédit du même montant sur un autre compte. Ces deux actions doivent
échouer ou réussir ensemble : le crédit ne doit pas être validé (commit) si le débit
correspondant ne l'est pas.
Types de transaction
Type Description
Langage de Se compose d'instructions LMD que le serveur Oracle traite
manipulation de en tant qu'entité unique ou en tant qu'unité de travail logique.
données (LMD)
Langage de définition Se compose d'une seule instruction LDD.
de données (LDD)
Langage de contrôle de Se compose d'une seule instruction LCD.
données (LCD)

Transactions de base de données : Début et fin
• Elles commencent avec l'exécution de la première

instruction SQL LMD.
• Elles finissent lorsque l'un des événements suivants
se produit :
– Une instruction COMMIT ou ROLLBACK est exécutée.
– Une instruction LDD ou LCD est exécutée
(validation automatique).
– L'utilisateur quitte SQL Developer ou SQL*Plus.
– Le système connaît une défaillance.

Transactions de base de données : Début et fin

Quand commence et quand se termine une transaction ?
Une transaction commence lors de l'exécution de la première instruction LMD.
Elle se termine dans l'un des cas suivants :
• Une instruction COMMIT ou ROLLBACK est exécutée.
• Une instruction LDD, telle que CREATE, est exécutée.
• Une instruction LCD est exécutée.
• L'utilisateur quitte SQL Developer ou SQL*Plus.
• Un ordinateur ou le système connaît une défaillance.
Après la fin d'une transaction, l'instruction SQL exécutable suivante démarre
automatiquement la transaction suivante.
Une instruction LDD ou LCD est validée (commit) automatiquement, ce qui met fin de
façon implicite à la transaction.

Avantages des instructions COMMIT et ROLLBACK
Avec les instructions COMMIT et ROLLBACK, vous pouvez :

• garantir la cohérence des données
• prévisualiser les modifications apportées aux données
avant de les rendre définitives
• regrouper de façon logique les opérations associées

Avantages des instructions COMMIT et ROLLBACK

Les instructions COMMIT et ROLLBACK vous permettent de contrôler la validation des
modifications apportées aux données.

Instructions explicites de contrôle
des transactions
Temps COMMIT
Transaction
DELETE
SAVEPOINT A
INSERT

UPDATE
SAVEPOINT B
INSERT
ROLLBACK ROLLBACK ROLLBACK
to SAVEPOINT B to SAVEPOINT A
Instructions explicites de contrôle des transactions

Vous pouvez contrôler la logique des transactions à l'aide des instructions COMMIT,
SAVEPOINT et ROLLBACK.
Instruction Description
COMMIT Met fin à la transaction en cours en rendant définitives toutes
les modifications de données en attente.
SAVEPOINT name Marque un savepoint dans la transaction en cours.
ROLLBACK Met fin à la transaction en cours en annulant toutes les
modifications de données en attente.
ROLLBACK TO Annule la transaction en cours jusqu'au savepoint indiqué,
SAVEPOINT name annulant ainsi l'ensemble des modifications et/ou savepoints
créés après le savepoint de référence. Si vous omettez la
clause TO SAVEPOINT, l'instruction ROLLBACK annule
(rollback) l'intégralité de la transaction. Les savepoints étant
logiques, il n'existe aucun moyen de les répertorier.
Remarque : Vous ne pouvez pas procéder à une validation (COMMIT) jusqu'à une
instruction SAVEPOINT. SAVEPOINT ne fait pas partie du langage SQL normalisé par
l'ANSI.

Annuler des modifications jusqu'à un marqueur
• Créez un marqueur dans la transaction en cours à l'aide

de l'instruction SAVEPOINT.
• Procédez à une annulation jusqu'à ce marqueur à l'aide
de l'instruction ROLLBACK TO SAVEPOINT.
UPDATE...
SAVEPOINT update_done;
INSERT...
ROLLBACK TO update_done;

Annuler des modifications jusqu'à un marqueur

Vous pouvez créer un marqueur dans la transaction en cours à l'aide de l'instruction
SAVEPOINT, qui divise la transaction en sections de plus petite taille. Vous pouvez
ensuite annuler les modifications en attente jusqu'à ce marqueur à l'aide de l'instruction
ROLLBACK TO SAVEPOINT.
Notez que si vous créez un deuxième savepoint portant le même nom qu'un savepoint
antérieur, ce dernier est supprimé.

Traitement implicite des transactions
• Une validation automatique a lieu dans les cas suivants :

– Une instruction LDD est exécutée.
– Une instruction LCD est exécutée.
– Fermeture normale de SQL Developer ou de SQL*Plus,
sans exécution explicite d'instructions COMMIT ou ROLLBACK.
• Une annulation automatique se produit en cas d'arrêt
anormal de SQL Developer ou de SQL*Plus, ou de
défaillance du système.

Traitement implicite des transactions

Statut Cas
Validation automatique Exécution d'une instruction LDD ou LCD.
Déconnexion normale de SQL Developer ou de SQL*Plus,
sans exécution explicite des commandes COMMIT ou
ROLLBACK.
Annulation automatique Déconnexion anormale de SQL Developer ou de SQL*Plus,
ou défaillance du système.
Remarque : Dans SQL*Plus, la commande AUTOCOMMIT peut être activée ou désactivée.
Si elle est activée, chaque instruction LMD est validée dès son exécution. Il est alors
impossible d'annuler les modifications. Si elle est désactivée, l'instruction COMMIT peut
être exécutée de façon explicite. L'instruction COMMIT est également exécutée à la suite
d'une instruction LDD ou lorsque vous vous déconnectez de SQL*Plus. La commande SET
AUTOCOMMIT ON/OFF est ignorée dans SQL Developer. Pour que l'instruction LMD soit
validée en cas de déconnexion normale de SQL Developer, il faut que l'option Autocommit
soit activée. Pour l'activer, procédez comme suit :
• Dans le menu Tools, sélectionnez Preferences. Dans la boîte de dialogue Preferences,
développez Database et sélectionnez Worksheet Parameters.
• Dans le volet de droite, sélectionnez l'option Autocommit in SQL Worksheet. Cliquez
sur OK.

Traitement implicite des transactions (suite)

Défaillances du système
Lorsqu'une transaction est interrompue par une défaillance du système, l'ensemble de la
transaction est automatiquement annulé. Cela évite que l'erreur ne provoque des
modifications non souhaitées. Les tables retrouvent l'état dans lequel elles se trouvaient lors
de la dernière validation. De cette façon, le serveur Oracle protège l'intégrité des tables.
Dans SQL Developer, pour vous déconnecter normalement de la session, sélectionnez Exit
dans le menu File. Pour effectuer la même opération dans SQL*Plus, entrez la commande
EXIT à l'invite. La fermeture de la fenêtre est considérée comme une déconnexion
anormale.

Etat des données avant exécution de l'instruction
COMMIT ou ROLLBACK
• L'état antérieur des données peut être récupéré.
• L'utilisateur actuel peut visualiser les résultats des
opérations LMD à l'aide de l'instruction SELECT.
• Les autres utilisateurs ne peuvent pas afficher les résultats
des instructions LMD exécutées par l'utilisateur actuel.
• Les lignes affectées sont verrouillées. Les autres utilisateurs
ne peuvent donc pas modifier les données de ces lignes.

Etat des données avant exécution de l'instruction COMMIT ou ROLLBACK

Toute modification de données effectuée au cours de la transaction est temporaire jusqu'à la
validation (commit) de la transaction.
L'état des données avant exécution des instructions COMMIT ou ROLLBACK peut être
décrit comme suit :
• Les opérations de manipulation des données affectent initialement le tampon de la
base de données. L'état antérieur des données peut donc être récupéré.
• L'utilisateur actuel peut visualiser les résultats des opérations de manipulation des
données en interrogeant les tables.
• Les autres utilisateurs ne peuvent pas afficher les résultats des opérations de
manipulation des données effectuées par l'utilisateur actuel. Le serveur Oracle institue
la cohérence en lecture afin que chaque utilisateur voit les données dans l'état où elles
se trouvaient lors de la dernière validation.
• Les lignes affectées sont verrouillées. Les autres utilisateurs ne peuvent donc pas
modifier les données de ces lignes.

Etat des données après exécution
de l'instruction COMMIT
• Les modifications apportées aux données sont enregistrées
dans la base.
• L'état antérieur des données est écrasé.
• Tous les utilisateurs peuvent visualiser les résultats.
• Les verrous externes des lignes affectées sont libérés.
Ces lignes peuvent alors être manipulées par les autres
utilisateurs.
• Tous les savepoints sont effacés.

Etat des données après exécution de l'instruction COMMIT

Rendez définitives toutes les modifications en attente à l'aide de l'instruction COMMIT.
Voici ce qui se produit après l'exécution d'une instruction COMMIT :
• Les modifications apportées aux données sont écrites dans la base.
• L'état antérieur des données ne peut plus être obtenu avec des interrogations SQL
normales.
• Tous les utilisateurs peuvent visualiser les résultats de la transaction.
• Les verrous externes (locks) des lignes affectées sont libérés et ces lignes peuvent de
nouveau être modifiées par les autres utilisateurs.
• Tous les savepoints sont effacés.

Valider les données
• Apportez les modifications :

DELETE FROM employees

VALUES (290, 'Corporate Tax', NULL, 1700);
• Validez les modifications :

COMMIT;
Valider des données

Dans l'exemple de la diapositive ci-dessus, une ligne est supprimée de la table
EMPLOYEES et une nouvelle ligne est insérée dans la table DEPARTMENTS. Les
modifications sont enregistrées par l'exécution de l'instruction COMMIT.
Exemple :
Supprimez les départements 290 et 300 de la table DEPARTMENTS, et mettez à jour une
ligne de la table EMPLOYEES. Enregistrez la modification apportée aux données.
WHERE department_id IN (290, 300);
UPDATE employees
COMMIT;

Etat des données après exécution
de l'instruction ROLLBACK
Annulez toutes les modifications en attente à l'aide de
l'instruction ROLLBACK :
• Les modifications apportées aux données sont annulées.
• L'état antérieur des données est restauré.
DELETE FROM copy_emp;

ROLLBACK ;

Etat des données après exécution de l'instruction ROLLBACK

Annulez toutes les modifications en attente à l'aide de l'instruction ROLLBACK, ce qui
entraîne les opérations suivantes :
• Les modifications apportées aux données sont annulées.
• L'état antérieur des données est restauré.

Etat des données après exécution de l'instruction
ROLLBACK : Exemple
DELETE FROM test;

25,000 rows deleted.
ROLLBACK;
Rollback complete.
DELETE FROM test WHERE id = 100;

1 row deleted.
SELECT * FROM test WHERE id = 100;

No rows selected.
COMMIT;
Commit complete.
Etat des données après exécution de l'instruction ROLLBACK : Exemple

Lors d'une tentative de suppression d'un enregistrement de la table TEST, vous risquez de
vider toute la table de façon accidentelle. Toutefois, vous pouvez corriger l'erreur, puis
exécuter l'instruction appropriée avant de rendre la modification définitive.

Annulation au niveau instruction
• Si une instruction LMD unique échoue lors de l'exécution,

seule cette instruction est annulée.
• Le serveur Oracle implémente un savepoint implicite.
• Toutes les autres modifications sont conservées.
• L'utilisateur doit terminer les transactions de façon explicite
à l'aide d'une instruction COMMIT ou ROLLBACK.

Annulation au niveau instruction

Une partie d'une transaction peut être annulée par une opération d'annulation (rollback)
implicite si une erreur d'exécution est détectée. Lorsque l'exécution d'une instruction LMD
unique échoue, l'effet de cette instruction est annulé par une annulation (rollback) au niveau
instruction, mais les modifications apportées par les instructions LMD précédentes de la
transaction ne sont pas annulées. Elles peuvent être validées (commit) ou annulées
(rollback) de façon explicite par l'utilisateur.
Le serveur Oracle exécute une validation implicite avant et après chaque instruction LDD.
Ainsi, même si votre instruction LDD n'est pas exécutée avec succès, vous ne pouvez pas
annuler l'instruction précédente, car le serveur a exécuté une validation.
Terminez vos transactions de façon explicite à l'aide d'une instruction COMMIT ou
ROLLBACK.

Contenu du chapitre



Cohérence en lecture
• La cohérence en lecture garantit une vue cohérente

des données à tout moment.
• Les modifications apportées par un utilisateur n'entrent
pas en conflit avec les modifications apportées par un autre
utilisateur.
• La cohérence en lecture garantit que, pour les mêmes
données :
– Les utilisateurs qui lisent n'attendent pas que ceux
qui écrivent aient terminé.

– Les utilisateurs qui écrivent n'attendent pas que ceux
qui lisent aient terminé.
– Les utilisateurs qui écrivent doivent attendre que les autres
utilisateurs qui écrivent aient terminé.
Cohérence en lecture
Les utilisateurs accèdent à la base de données de deux façons :
• Via des opérations de lecture (instruction SELECT).
• Via des opérations d'écriture (instructions INSERT, UPDATE, DELETE).
La cohérence en lecture est nécessaire pour garantir les points suivants :
• Les utilisateurs qui lisent et écrivent des données dans la base disposent d'une vue
cohérente des données.
• Les utilisateurs qui lisent des données dans la base ne voient pas les données qui sont
en cours de modification.
• Les modifications apportées à la base de données le sont de façon cohérente.
• Les modifications apportées par un utilisateur qui écrit n'entrent pas en conflit avec les
modifications apportées par un autre utilisateur et n'entraînent pas de perturbation.
L'objectif de la cohérence en lecture est de garantir que chaque utilisateur voie les données
telles qu'elles étaient lors de la dernière validation (commit), avant qu'une opération LMD
soit lancée.
Remarque : Le même utilisateur peut ouvrir différentes sessions. Chaque session préserve
la cohérence en lecture comme décrit ci-dessus, même s'il s'agit à chaque fois du même
utilisateur.

Implémenter la cohérence en lecture
Utilisateur A
UPDATE employees Blocs

SET salary = 7000 de données
WHERE last_name = 'Grant';
Segments
d'annulation
Données
modifiées

SELECT *
FROM userA.employees; Image et non
cohérente modifiées
en lecture Avant
modification
Utilisateur B ("anciennes"
données)
Implémenter la cohérence en lecture

La cohérence en lecture est implémentée automatiquement. Elle conserve une copie
partielle de la base de données dans les segments d'annulation. L'image cohérente en
lecture est élaborée en utilisant les données validées (commit) de la table et les anciennes
données en cours de modification qui n'ont pas encore été validées à partir du segment
d'annulation.
Lorsqu'une opération d'insertion, de mise à jour ou de suppression est lancée sur la base, le
serveur Oracle enregistre une copie des données dans un segment d'annulation avant
qu'elles soient modifiées.
Tous les utilisateurs qui lisent les données, à l'exception de celui qui effectue la
modification, continuent à voir la base telle qu'elle était avant la modification. En réalité, il
s'agit du "cliché" (snapshot) des données qui figure dans le segment d'annulation.
Seul l'utilisateur qui modifie les données voit les changements apportés à la base avant leur
validation. Tous les autres utilisateurs voient le cliché du segment d'annulation. Les
utilisateurs lisent ainsi des données cohérentes qui ne sont pas en cours de modification.
Une fois que l'instruction LMD est validée, la modification apportée à la base devient
visible pour tout utilisateur qui exécute une instruction SELECT. L'espace occupé par les
anciennes données dans le segment d'annulation est libéré et peut être réutilisé.
Si la transaction est annulée (rollback), les modifications le sont également :
• La version d'origine (l'ancienne version) des données, qui figure dans le segment
d'annulation, est réécrite dans la table.
• Tous les utilisateurs voient la base telle qu'elle était avant le début de la transaction.

Contenu du chapitre

• Contrôler les transactions de base de données
à l'aide des instructions COMMIT, ROLLBACK et SAVEPOINT


Clause FOR UPDATE dans une instruction SELECT
• Dans la table EMPLOYEES, verrouillez les lignes pour

lesquelles job_id = SA_REP.
SELECT employee_id, salary, commission_pct, job_id
FROM employees
WHERE job_id = 'SA_REP'
FOR UPDATE
ORDER BY employee_id;
• Le verrou externe est libéré uniquement lorsque vous

exécutez une instruction ROLLBACK ou COMMIT.

• Si l'instruction SELECT tente de verrouiller une ligne qui est
déjà verrouillée par un autre utilisateur, la base de données
attend que la ligne soit disponible pour renvoyer les résultats
de l'instruction SELECT.
Clause FOR UPDATE dans une instruction SELECT

Lorsque vous exécutez une instruction SELECT sur la base de données pour interroger
certains enregistrements, les lignes sélectionnées ne sont pas verrouillées. Cela est
généralement dû au fait que le nombre d'enregistrements verrouillés simultanément est
(par défaut) maintenu le plus faible possible. Seuls les enregistrements modifiés mais non
encore validés sont verrouillés. Malgré tout, les autres utilisateurs peuvent lire ces
enregistrements tels qu'ils apparaissaient avant la modification (image "avant" des
données). Toutefois, dans certains cas, vous pouvez avoir besoin de verrouiller un
ensemble d'enregistrements avant leur modification dans le programme. La clause FOR
UPDATE de l'instruction SELECT proposée par Oracle permet d'effectuer cette opération.
Lorsque vous exécutez une instruction SELECT...FOR UPDATE, le système de gestion
de base de données relationnelle (SGBDR) obtient automatiquement des verrous externes
(locks) exclusifs de niveau ligne sur toutes les lignes identifiées par l'instruction SELECT,
les réservant ainsi uniquement pour vos modifications. Personne d'autre ne peut modifier
ces enregistrements jusqu'à ce que vous exécutiez une instruction ROLLBACK ou COMMIT.
Vous pouvez ajouter le mot-clé facultatif NOWAIT à la fin de la clause FOR UPDATE pour
indiquer au serveur Oracle de ne pas attendre si la table a été verrouillée par un autre
utilisateur. Dans ce cas, le programme ou l'environnement SQL Developer reprend
immédiatement le contrôle de sorte que vous puissiez effectuer d'autres tâches ou
simplement patienter un peu avant de réessayer. En l'absence de la clause NOWAIT, le
traitement reste bloqué jusqu'à la mise à disposition de la table (libération des verrous
externes par l'autre utilisateur via l'exécution d'une commande COMMIT ou ROLLBACK).

Clause FOR UPDATE : Exemples
• Dans une instruction SELECT, vous pouvez utiliser la clause

FOR UPDATE sur plusieurs tables.
SELECT e.employee_id, e.salary, e.commission_pct

FROM employees e JOIN departments d
USING (department_id)
WHERE job_id = 'ST_CLERK'
AND location_id = 1500
FOR UPDATE
ORDER BY e.employee_id;

• Des lignes des tables EMPLOYEES et DEPARTMENTS sont
verrouillées.
• Utilisez FOR UPDATE OF column_name pour qualifier la
colonne que vous avez l'intention de modifier. Seules les
lignes de cette table spécifique sont alors verrouillées.
Clause FOR UPDATE : Exemples

Dans l'exemple de la diapositive ci-dessus, l'instruction verrouille les lignes de la table
EMPLOYEES pour lesquelles JOB_ID = ST_CLERK et LOCATION_ID = 1500, ainsi que
les lignes de la table DEPARTMENTS pour lesquelles LOCATION_ID = 1500.
Vous pouvez utiliser FOR UPDATE OF column_name pour qualifier la colonne que vous
avez l'intention de modifier. La liste OF de la clause FOR UPDATE ne vous empêche pas de
modifier d'autres colonnes que celles des lignes sélectionnées. Des verrous externes sont
placés sur toutes les lignes. Si vous indiquez simplement FOR UPDATE dans l'interrogation
et n'incluez aucune colonne après le mot-clé OF, la base de données verrouille toutes les
lignes identifiées dans toutes les tables énumérées dans la clause FROM.
L'instruction suivante verrouille uniquement les lignes de la table EMPLOYEES pour
lesquelles la valeur de LOCATION_ID est 1500 pour ST_CLERK. Aucune ligne n'est
verrouillée dans la table DEPARTMENTS :
SELECT e.employee_id, e.salary, e.commission_pct
USING (department_id)
WHERE job_id = 'ST_CLERK' AND location_id = 1500
FOR UPDATE OF e.salary
ORDER BY e.employee_id;

Clause FOR UPDATE : Exemples (suite)

Dans l'exemple suivant, la base de données reçoit pour instruction d'attendre la mise à
disposition de la ligne pendant cinq secondes, puis de vous rendre le contrôle.
SELECT employee_id, salary, commission_pct, job_id
FROM employees
WHERE job_id = 'SA_REP'
FOR UPDATE WAIT 5
ORDER BY employee_id;

Synthèse
Ce chapitre vous a permis d'apprendre à utiliser les instructions

suivantes :
Fonction Description
INSERT Ajoute une nouvelle ligne à la table
UPDATE Modifie des lignes existantes de la table
DELETE Supprime des lignes existantes de la table
TRUNCATE Supprime toutes les lignes d'une table
COMMIT Rend définitives toutes les modifications en attente

SAVEPOINT Permet de procéder à une annulation (rollback) jusqu'au
marqueur savepoint
ROLLBACK Annule toutes les modifications de données en attente
Clause FOR UPDATE Verrouille les lignes identifiées par l'interrogation
dans SELECT SELECT
Synthèse
Ce chapitre vous a permis d'apprendre à manipuler les données d'une base Oracle à l'aide
des instructions INSERT, UPDATE, DELETE et TRUNCATE, et à contrôler les
modifications de données à l'aide des instructions COMMIT, SAVEPOINT et ROLLBACK. Il
vous a également appris à utiliser la clause FOR UPDATE de l'instruction SELECT pour
verrouiller des lignes afin de les réserver à votre usage exclusif.
Rappelez-vous que le serveur Oracle garantit à tout moment une vue cohérente des
données.

Présentation de l'exercice 9
Dans cet exercice, vous allez :

• insérer des lignes dans une table
• mettre à jour et supprimer des lignes dans une table
• contrôler les transactions

Dans cet exercice, vous allez ajouter des lignes à la table MY_EMPLOYEE, mettre à jour et
supprimer des données dans cette même table, et contrôler vos transactions. Pour
commencer, vous allez exécuter un script permettant de créer la table MY_EMPLOYEE.

Exercice 9
Le département des ressources humaines a besoin d'instructions SQL permettant d'insérer,
de mettre à jour et de supprimer des données relatives aux employés. Vous allez tester ces
instructions sur la table MY_EMPLOYEE avant de les livrer.
Remarque : Pour exécuter une interrogation comprenant des instructions LMD, utilisez
l'icône Run Script (ou appuyez sur [F5]). Vous pouvez ainsi voir les messages renvoyés
dans l'onglet Script Output. Pour les interrogations SELECT, continuez à utiliser l'icône
Execute Statement ou à appuyer sur [F9] pour obtenir le résultat mis en forme dans l'onglet
Results.
Insérez des données dans la table MY_EMPLOYEE.
1. Exécutez l'instruction du script lab_09_01.sql pour générer la table
MY_EMPLOYEE utilisée dans cet exercice.
2. Affichez la structure de cette table afin d'identifier les noms de colonne.

3. Créez une instruction INSERT permettant d'ajouter à la table MY_EMPLOYEE la
première ligne de données du tableau ci-après. N'énumérez pas les colonnes dans la
clause INSERT. N'entrez pas encore toutes les lignes.
ID LAST_NAME FIRST_NAME USERID SALARY
1 Patel Ralph rpatel 895
2 Dancs Betty bdancs 860
3 Biri Ben bbiri 1100
4 Newman Chad cnewman 750
5 Ropeburn Audrey aropebur 1550
4. Insérez dans la table MY_EMPLOYEE la deuxième ligne de données du tableau qui

précède. Cette fois, énumérez les colonnes de façon explicite dans la clause INSERT.

Exercice 9 (suite)
5. Vérifiez les ajouts effectués dans la table.
6. Ecrivez dans un fichier script réutilisable et dynamique une instruction INSERT

permettant de charger les lignes restantes dans la table MY_EMPLOYEE. Le script doit
afficher une invite pour toutes les colonnes (ID, LAST_NAME, FIRST_NAME, USERID
et SALARY). Enregistrez ce script sous le nom lab_09_06.sql.
7. Insérez dans la table les deux lignes suivantes du tableau de données fourni à l'étape 3 en
exécutant l'instruction INSERT du script que vous avez créé.

9. Rendez définitifs les ajouts de données.
Mettez à jour et supprimez des données dans la table MY_EMPLOYEE.

10. Remplacez le nom de l'employé 3 par Drexler.
11. Remplacez par 1 000 $ le salaire de tous les employés qui ont un salaire inférieur
à 900 $.
12. Vérifiez les modifications apportées à la table.
13. Supprimez Betty Dancs de la table MY_EMPLOYEE.


Exercice 9 (suite)
15. Validez (commit) toutes les modifications en attente.
Contrôlez les transactions de données appliquées à la table MY_EMPLOYEE.
16. Insérez dans la table la dernière ligne du tableau de données fourni à l'étape 3, à l'aide
des instructions du script créé à l'étape 6. Exécutez ces instructions.

18. Marquez un point intermédiaire dans le traitement de la transaction.
19. Supprimez toutes les lignes de la table MY_EMPLOYEE.
20. Vérifiez que la table a bien été vidée.
21. Annulez l'opération DELETE la plus récente, mais pas l'opération INSERT précédente.
22. Vérifiez que la nouvelle ligne est toujours intacte.
23. Rendez définitif l'ajout de données.

S'il vous reste du temps, effectuez l'exercice suivant :
24. Modifiez le script lab_09_06.sql de sorte que la valeur USERID soit générée
automatiquement par concaténation de la première lettre du prénom et des sept
premiers caractères du nom. La valeur USERID doit être générée en minuscules. Ainsi,
le script n'invitera pas à saisir cette valeur. Enregistrez le script sous le nom
lab_09_24.sql.
25. Exécutez le script lab_09_24.sql afin d'insérer l'enregistrement suivant :
6 Anthony Mark manthony 1230
26. Vérifiez que la nouvelle ligne a été ajoutée avec le USERID correct.

et gérer des tables

Utiliser des instructions LDD pour créer

Objectifs

• identifier les principaux objets de base de données
• visualiser la structure d'une table
• énumérer les types de données disponibles
pour les colonnes
• créer une table simple
• expliquer le processus de définition de contraintes
lors de la création d'une table

• expliquer le fonctionnement des objets de schéma
Objectifs
Ce chapitre présente les instructions LDD (langage de définition de données). Il explique
comment créer, modifier et supprimer des tables simples. Il décrit les types de données
disponibles dans le langage LDD, ainsi que le concept de schéma. Il traite de l'utilisation
des contraintes. Enfin, il explique les messages d'exception générés suite à la violation de
contraintes pendant des opérations LMD.

Contenu du chapitre
• Objets de base de données

– Règles d'appellation
• Instruction CREATE TABLE :
– Accès aux tables d'un autre utilisateur
– Option DEFAULT
• Types de données
• Présentation des contraintes NOT NULL, PRIMARY KEY,
FOREIGN KEY, CHECK

• Création d'une table à l'aide d'une sous-interrogation
• ALTER TABLE
– Tables en lecture seule
• Instruction DROP TABLE

Objets de base de données
Objet Description
Table Unité élémentaire de stockage, constituée de lignes
Vue Représente de façon logique des sous-ensembles
de données issus d'une ou de plusieurs tables
Séquence Génère des valeurs numériques
Index Améliore les performances de certaines interrogations
Synonyme Attribue un autre nom à un objet


Une base Oracle peut contenir plusieurs structures de données. Chaque structure doit être
exposée dans la conception de la base afin de pouvoir être créée au cours de la construction
de la base.
• Table : Stocke des données.
• Vue : Sous-ensemble de données issues d'une ou de plusieurs tables.
• Séquence : Génère des valeurs numériques.
• Index : Améliore les performances de certaines interrogations.
• Synonyme : Attribue un autre nom à un objet.
Tables Oracle
• Il est possible de créer des tables à tout moment, y compris pendant que des
utilisateurs exploitent la base.
• Il est inutile d'indiquer la taille d'une table. Au bout du compte, la taille est la quantité
d'espace allouée à la base de données dans son ensemble. Il est toutefois important
d'estimer la quantité d'espace qu'utilisera une table au fil du temps.
• La structure de la table peut être modifiée pendant que celle-ci est en ligne.
Remarque : Il existe d'autres objets de base de données, mais ils ne sont pas étudiés dans
le cadre de ce cours.

Règles d'appellation
Les noms de table et de colonne :

• doivent commencer par une lettre
• doivent comporter entre 1 et 30 caractères
• admettent uniquement les caractères
A–Z, a–z, 0–9, _, $ et #
• ne peuvent pas être identiques au nom
d'un autre objet appartenant au même utilisateur
• ne doivent pas être des mots réservés au serveur Oracle

Vous devez nommer les colonnes et les tables en respectant les règles standard
d'appellation des objets de base de données Oracle :
• Les noms de table et de colonne doivent commencer par une lettre et comporter entre
1 et 30 caractères.
• Ils admettent uniquement les caractères A–Z, a–z, 0–9, _ (trait de soulignement), $ et #
(caractères autorisés, mais déconseillés).
• Les noms ne doivent pas être identiques au nom d'un autre objet appartenant au même
utilisateur du serveur Oracle.
• Les noms ne doivent pas être des mots réservés au serveur Oracle.
- Vous pouvez indiquer le nom d'un objet entre guillemets, auquel cas vous devez
utiliser les guillemets chaque fois que vous faites référence à cet objet. Les
identificateurs entre guillemets peuvent être des mots réservés, mais cela n'est pas
recommandé.
Attribuez des noms descriptifs aux tables et aux autres objets de base de données.
Remarque : Pour les noms standard, il n'y a pas de distinction entre majuscules et
minuscules. Par exemple, EMPLOYEES est traité comme eMPloyees ou eMpLOYEES.
En revanche, la distinction est effectuée pour les identificateurs entre guillemets.
Pour plus d'informations, reportez-vous à la section Schema Object Names and Qualifiers
du manuel Oracle Database SQL Language Reference 11g, Release 1 (11.1).

Contenu du chapitre

– Option DEFAULT
FOREIGN KEY, CHECK

• ALTER TABLE

Instruction CREATE TABLE
• Vous devez disposer des éléments suivants :

– le privilège CREATE TABLE
– une zone de stockage
CREATE TABLE [schema.]table
(column datatype [DEFAULT expr][, ...]);
• Vous indiquez :
– le nom de la table
– le nom, le type de données et la taille des colonnes

Instruction CREATE TABLE

Pour créer des tables permettant de stocker des données, exécutez l'instruction SQL
CREATE TABLE. Cette instruction fait partie du sous-ensemble des instructions SQL
LDD, qui sont utilisées pour créer, modifier ou supprimer des structures de base de données
Oracle. Ces instructions ont un effet immédiat sur la base, mais enregistrent également des
informations dans le dictionnaire de données.
Pour créer une table, un utilisateur doit disposer du privilège CREATE TABLE ainsi que
d'une zone de stockage dans laquelle créer des objets. L'administrateur de base de données
(DBA) utilise des instructions LCD (langage de contrôle de données) pour accorder des
privilèges aux utilisateurs.
Dans la syntaxe :
schema Correspond au nom du propriétaire.
table Correspond au nom de la table.
DEFAULT expr Indique une valeur par défaut lorsqu'une valeur est omise
dans l'instruction INSERT.
column Correspond au nom de la colonne.
datatype Correspond au type de données et à la longueur de la colonne.

Référencer les tables d'un autre utilisateur
• Les tables appartenant à d'autres utilisateurs

ne figurent pas dans le schéma de l'utilisateur en cours.
• Vous devez ajouter le nom du propriétaire comme
préfixe à ces tables.

USERA USERB
SELECT * SELECT *
FROM userB.employees; FROM userA.employees;
Référencer les tables d'un autre utilisateur

Un schéma est un ensemble de structures logiques de données ou d'objets de schéma.
Un schéma appartient à un utilisateur de la base et porte le même nom que cet utilisateur.
Chaque utilisateur possède un seul schéma.
Les différents objets de schéma peuvent être créés et manipulés à l'aide d'instructions SQL :
tables, vues, synonymes, séquences, procédures stockées, index, clusters et liens de base de
données.
Pour référencer une table qui ne vous appartient pas, vous devez lui ajouter un préfixe
correspondant au nom de son propriétaire. Par exemple, si des schémas nommés USERA
et USERB comportent tous deux une table EMPLOYEES et que USERA souhaite accéder à
la table EMPLOYEES appartenant à USERB, USERA doit ajouter le nom de schéma comme
préfixe au nom de la table :
SELECT *
FROM userb.employees;
Si USERB souhaite accéder à la table EMPLOYEES appartenant à USERA, il doit de même
ajouter le nom de schéma au nom de la table :
SELECT *
FROM usera.employees;

Option DEFAULT
• Lors d'une insertion, indiquez une valeur de colonne

par défaut.
... hire_date DATE DEFAULT SYSDATE, ...
• Valeurs autorisées : Valeurs littérales, expressions

ou fonctions SQL.
• Valeurs non autorisées : Nom d'une autre colonne
ou pseudo-colonne.
• Le type de données par défaut doit correspondre à celui
de la colonne.

CREATE TABLE hire_dates
(id NUMBER(8),
hire_date DATE DEFAULT SYSDATE);
Option DEFAULT
Lorsque vous définissez une table, vous pouvez indiquer qu'une colonne doit se voir
attribuer une valeur par défaut, à l'aide de l'option DEFAULT. Cette option empêche
l'introduction de valeurs NULL dans la colonne lors de l'insertion de lignes qui ne
contiennent pas de valeur pour la colonne. La valeur par défaut peut être un littéral, une
expression ou une fonction SQL (par exemple SYSDATE ou USER), mais il ne peut pas
s'agir du nom d'une autre colonne ou d'une pseudo-colonne (par exemple NEXTVAL ou
CURRVAL). L'expression par défaut doit présenter le même type de données que la
colonne.
Considérons les exemples suivants :
INSERT INTO hire_dates values(45, NULL);
L'instruction ci-dessus insérera la valeur NULL à la place de la valeur par défaut.
INSERT INTO hire_dates(id) values(35);

L'instruction ci-dessus insérera SYSDATE pour la colonne HIRE_DATE.
Remarque : Dans SQL Developer, pour exécuter les instructions LDD, cliquez sur l'icône
Run Script ou appuyez sur [F5]. Les messages renvoyés apparaissent dans l'onglet Script
Output.

Créer des tables
• Créez la table :
CREATE TABLE dept
(deptno NUMBER(2),
dname VARCHAR2(14),
loc VARCHAR2(13),
create_date DATE DEFAULT SYSDATE);
• Vérifiez la création de la table :

DESCRIBE dept

Créer des tables

L'exemple de la diapositive ci-dessus crée la table DEPT, qui comporte quatre colonnes :
DEPTNO, DNAME, LOC et CREATE_DATE. La colonne CREATE_DATE comporte une
valeur par défaut. Si aucune valeur n'est fournie pour une instruction INSERT, la date
système est automatiquement insérée.
Pour vérifier que la table a été créée, exécutez la commande DESCRIBE.
Etant donné que l'instruction de création d'une table est une instruction LDD, une
validation (commit) automatique a lieu lors de son exécution.

Contenu du chapitre

– Option DEFAULT
FOREIGN KEY, CHECK

• ALTER TABLE

Types de données
Type de données Description

VARCHAR2(size) Données alphanumériques de longueur variable
CHAR(size) Données alphanumériques de longueur fixe
NUMBER(p,s) Données numériques de longueur variable
DATE Valeur date-heure
LONG Données alphanumériques de longueur variable (jusqu'à 2 Go)
CLOB Données alphanumériques (jusqu'à 4 Go)
RAW et LONG Données binaires raw
RAW

BLOB Données binaires (jusqu'à 4 Go)
BFILE Données binaires stockées dans un fichier externe (jusqu'à 4 Go)
ROWID Nombre en base 64 représentant l'adresse unique d'une ligne
dans sa table
Types de données
Lorsque vous identifiez une colonne pour une table, vous devez lui attribuer un type de
données. Vous avez le choix entre les types suivants :

VARCHAR2(size) Données alphanumériques de longueur variable. Le paramètre
size indique la longueur maximale. Sa valeur peut être
comprise entre 1 et 4 000.
CHAR [(size)] Données alphanumériques occupant un nombre fixe d'octets
indiqué par le paramètre size. La longueur minimale est 1 octet
(valeur par défaut), et la longueur maximale est 2 000.
NUMBER [(p,s)] Nombre présentant une précision p et une échelle s.
La précision indique le nombre total de chiffres tandis que
l'échelle indique le nombre de chiffres situés à droite du
séparateur décimal. La précision peut être comprise entre 1 et
38, tandis que l'échelle peut être comprise entre –84 et 127.
DATE Valeur date-heure arrondie à la seconde la plus proche, qui
peut être comprise entre le 1er janvier 4712 avant J-C
et le 31 décembre 9999 après J-C.
LONG Données alphanumériques de longueur variable (jusqu'à 2 Go).
CLOB Données alphanumériques (jusqu'à 4 Go).

Types de données (suite)

Type de Description
données
RAW(size) Données binaires raw de longueur size. La valeur maximale de size
est 2 000.
LONG RAW Données binaires raw de longueur variable (jusqu'à 2 Go).
BLOB Données binaires (jusqu'à 4 Go).
BFILE Données binaires stockées dans un fichier externe (jusqu'à 4 Go).
ROWID Nombre en base 64 représentant l'adresse unique d'une ligne dans
sa table.
Règles
• Une colonne LONG n'est pas copiée lorsqu'une table est créée à l'aide d'une

sous-interrogation.
• Une colonne LONG ne peut pas être incluse dans une clause GROUP BY ou ORDER
BY.
• Une table ne peut compter qu'une seule colonne LONG.
• Aucune contrainte ne peut être définie sur une colonne LONG.
• Vous pouvez utiliser une colonne CLOB plutôt qu'une colonne LONG.

Types de données date-heure
Vous pouvez utiliser plusieurs types de données date-heure :

TIMESTAMP Date avec partie décimale des secondes
INTERVAL YEAR TO Intervalle exprimé en années et en mois
MONTH
INTERVAL DAY TO Intervalle exprimé en jours, heures, minutes
SECOND et secondes

Types de données date-heure

TIMESTAMP Permet de stocker une heure sous la forme d'une date avec partie
décimale des secondes. Stocke l'année, le mois, le jour, l'heure,
les minutes et les secondes du type de données DATE, ainsi que la partie
décimale des secondes.
Il existe plusieurs variantes de ce type de données, telles que WITH
TIMEZONE, WITH LOCALTIMEZONE.
INTERVAL YEAR TO Permet de stocker une durée sous la forme d'un intervalle exprimé en
MONTH années et en mois. Permet de représenter la différence entre deux valeurs
date-heure en tenant seulement compte de l'année et du mois.
INTERVAL DAY TO Permet de stocker une durée sous la forme d'un intervalle exprimé en
SECOND jours, heures, minutes et secondes. Permet de représenter la différence
précise entre deux valeurs date-heure.

Types de données date-heure (suite)

Remarque : Ces types de données date-heure sont disponibles dans Oracle9i et dans les
versions ultérieures. Les types de données date-heure sont traités en détail dans le chapitre
"Gérer des données dans différents fuseaux horaires" du cours Oracle Database 11g :
Les fondamentaux du langage SQL (II).
Pour plus d'informations sur ces types, vous pouvez aussi consulter les sections
TIMESTAMP Datatype, INTERVAL YEAR TO MONTH Datatype et INTERVAL DAY TO
SECOND Datatype du manuel Oracle Database SQL Language Reference 11g, Release 1
(11.1).

Contenu du chapitre

– Option DEFAULT
FOREIGN KEY, CHECK

• ALTER TABLE

Inclure des contraintes
• Les contraintes appliquent des règles de niveau table.

• Elles empêchent la suppression d'une table dotée
de dépendances.
• Les types de contrainte valides sont les suivants :
– NOT NULL
– UNIQUE
– PRIMARY KEY
– FOREIGN KEY
–

CHECK
Contraintes
Le serveur Oracle utilise des contraintes pour empêcher la saisie de données non valides
dans les tables.
Vous pouvez y recourir pour effectuer les opérations suivantes :
• Appliquer les règles concernant les données d'une table chaque fois qu'une ligne est
insérée, mise à jour ou supprimée dans cette table. Pour que l'opération réussisse, la
contrainte doit être satisfaite.
• Empêcher la suppression d'une table dotée de dépendances.
• Fournir des règles aux outils Oracle tels qu'Oracle Developer.
Contraintes d'intégrité des données
C ontrainte D escription
NOT NULL Indique que la colonne ne peut pas contenir de valeurs N U LL.
UNIQUE Indique qu'une colonne ou une com binaison de colonnes doit

contenir des valeurs uniques pour toutes les lignes de la table.
PRIMARY KEY Identifie chaque ligne de la table de façon unique.
FOREIGN KEY Etablit une intégrité référentielle entre la colonne indiquée et
une colonne de la table référencée de sorte que les valeurs
d'une table correspondent à celles de l'autre table.
CHECK Indique une condition qui doit être vraie.

Règles relatives aux contraintes
• Vous pouvez nommer une contrainte ou laisser le serveur

Oracle générer un nom au format SYS_Cn.
• Vous pouvez créer une contrainte à l'un des stades
suivants :
– lors de la création de la table
– après la création de la table
• Vous pouvez définir une contrainte de niveau colonne
ou table.
• Vous pouvez visualiser une contrainte dans le dictionnaire

de données.
Règles relatives aux contraintes

Toutes les contraintes sont stockées dans le dictionnaire de données. Elles sont faciles à
référencer si vous leur attribuez un nom significatif. Le nom d'une contrainte doit être
conforme aux règles standard d'appellation des objets, à ceci près qu'il ne peut pas être
identique au nom d'un autre objet appartenant au même utilisateur. Si vous n'attribuez pas
de nom à une contrainte, le serveur Oracle en génère un au format SYS_Cn, où n est un
entier garantissant l'unicité de ce nom.
Les contraintes peuvent être définies lors de la création de la table ou après. Vous pouvez
définir une contrainte de niveau colonne ou table. D'un point de vue fonctionnel, une
contrainte de niveau table est identique à une contrainte de niveau colonne.
Pour plus d'informations, reportez-vous à la section "Constraints" du manuel Oracle

Définir des contraintes
• Syntaxe :
CREATE TABLE [schema.]table
(column datatype [DEFAULT expr]
[column_constraint],
...
[table_constraint][,...]);
• Syntaxe d'une contrainte de niveau colonne :

column [CONSTRAINT constraint_name] constraint_type,
• Syntaxe d'une contrainte de niveau table :

column,...
[CONSTRAINT constraint_name] constraint_type
(column, ...),

La diapositive ci-dessus fournit la syntaxe à utiliser pour la définition de contraintes lors de
la création d'une table. Vous pouvez créer des contraintes de niveau colonne ou de niveau
table. Les contraintes de niveau colonne sont incluses lors de la définition de la colonne.
Les contraintes de niveau table sont définies après la table. Elles doivent référencer la ou
les colonnes auxquelles elles se rapportent, entre parenthèses. Les contraintes de niveau
colonne et de niveau table se distinguent essentiellement par leur syntaxe. Elles sont
identiques d'un point de vue fonctionnel.
Les contraintes NOT NULL doivent être définies au niveau colonne.
Les contraintes qui s'appliquent à plusieurs colonnes doivent être définies au niveau table.
Dans la syntaxe :
schema Correspond au nom du propriétaire.
table Correspond au nom de la table.
DEFAULT expr Indique la valeur par défaut à utiliser lorsqu'une valeur
est omise dans l'instruction INSERT.
column Correspond au nom de la colonne.
datatype Correspond au type de données et à la longueur
de la colonne.
column_constraint Est une contrainte d'intégrité faisant partie
de la définition de la colonne.
table_constraint Est une contrainte d'intégrité faisant partie
de la définition de la table.

• Exemple de contrainte de niveau colonne :

CREATE TABLE employees(
employee_id NUMBER(6)
CONSTRAINT emp_emp_id_pk PRIMARY KEY, 1
first_name VARCHAR2(20),
...);
• Exemple de contrainte de niveau table :
employee_id NUMBER(6),

...
job_id VARCHAR2(10) NOT NULL,
2
CONSTRAINT emp_emp_id_pk
PRIMARY KEY (EMPLOYEE_ID));
Définir des contraintes (suite)

Les contraintes sont généralement créées en même temps que la table. Elles peuvent
cependant être ajoutées à une table après sa création et peuvent également être désactivées
de façon temporaire.
Les deux exemples de la diapositive ci-dessus créent une contrainte de clé primaire sur la
colonne EMPLOYEE_ID de la table EMPLOYEES.
1. Le premier exemple utilise la syntaxe de niveau colonne pour définir la contrainte.
2. Le deuxième exemple utilise la syntaxe de niveau table pour définir la contrainte.
Des détails supplémentaires sur la contrainte de clé primaire seront fournis ultérieurement
dans ce chapitre.

Contrainte NOT NULL
Elle garantit que les valeurs NULL ne sont pas autorisées

pour la colonne :

…
Contrainte NOT NULL Absence de contrainte NOT
(La clé primaire Contrainte NULL (N'importe quelle ligne
applique une NOT NULLNOT peut contenir une valeur
contrainte NOT NULL.) NULL NULL pour cette colonne.)
Contrainte NOT NULL

La contrainte NOT NULL garantit que la colonne ne contient aucune valeur NULL. Par
défaut, les colonnes non concernées par la contrainte NOT NULL peuvent contenir des
valeurs NULL. Les contraintes NOT NULL doivent être définies au niveau colonne. Dans la
table EMPLOYEES, la colonne EMPLOYEE_ID hérite d'une contrainte NOT NULL car elle
est définie en tant que clé primaire. En outre, la contrainte NOT NULL est appliquée aux
colonnes LAST_NAME, EMAIL, HIRE_DATE et JOB_ID.
Remarque : La contrainte de clé primaire sera traitée en détail ultérieurement dans ce
chapitre.

Contrainte UNIQUE
Contrainte UNIQUE
EMPLOYEES
…
INSERT INTO

Autorisé
Non autorisé :
existe déjà
Contrainte UNIQUE
Une contrainte d'intégrité de clé UNIQUE impose l'unicité de chaque valeur d'une colonne
ou d'un ensemble de colonnes (colonnes de clé). Cela veut dire qu'il ne peut pas exister de
valeurs en double pour ces colonnes dans deux lignes de la table. La colonne figurant dans
la définition de la contrainte de clé UNIQUE est appelée clé unique. Si la contrainte
UNIQUE comprend plusieurs colonnes, ce groupe de colonnes est appelé clé unique
composée.
Les contraintes UNIQUE permettent la saisie de valeurs NULL, sauf si vous définissez
également des contraintes NOT NULL pour les mêmes colonnes. En fait, les lignes peuvent
inclure des valeurs NULL pour les colonnes sans contrainte NOT NULL, car les valeurs
NULL ne sont pas considérées comme égales à quelque chose. La présence d'une valeur
NULL dans une colonne (ou dans toutes les colonnes d'une clé UNIQUE composée)
n'enfreint pas une contrainte UNIQUE.
Remarque : En raison du mécanisme de recherche des contraintes UNIQUE portant sur
plusieurs colonnes, vous ne pouvez pas avoir de valeurs identiques dans les colonnes non
NULL d'une contrainte de clé UNIQUE composée partiellement NULL.

Contrainte UNIQUE
Elle est définie au niveau table ou au niveau colonne :

last_name VARCHAR2(25) NOT NULL,
email VARCHAR2(25),
salary NUMBER(8,2),
commission_pct NUMBER(2,2),
hire_date DATE NOT NULL,
...
CONSTRAINT emp_email_uk UNIQUE(email));

Contrainte UNIQUE (suite)

Les contraintes UNIQUES peuvent être définies au niveau colonne ou au niveau table.
Vous définissez une contrainte au niveau table lorsque vous souhaitez créer une clé unique
composée. Vous devez indiquer une clé composée lorsqu'il n'existe pas d'attribut unique
permettant d'identifier une ligne de façon unique. Dans ce cas, vous pouvez créer une clé
unique composée d'au moins deux colonnes dont la combinaison permettra toujours
d'identifier les lignes de façon unique.
L'exemple de la diapositive ci-dessus applique la contrainte UNIQUE à la colonne EMAIL
de la table EMPLOYEES. Le nom de la contrainte est EMP_EMAIL_UK.
Remarque : Le serveur Oracle applique la contrainte UNIQUE en créant de façon implicite
un index unique sur la ou les colonnes de clé unique.

Contrainte PRIMARY KEY
DEPARTMENTS PRIMARY KEY
Non autorisé

INSERT INTO
(valeur NULL)
Non autorisé
(50 existe déjà)
Contrainte PRIMARY KEY

Une contrainte PRIMARY KEY crée une clé primaire pour une table. Une seule clé primaire
peut être créée pour chaque table. La contrainte PRIMARY KEY définit une colonne ou un
ensemble de colonnes identifiant de façon unique chaque ligne d'une table. Elle impose
l'unicité des valeurs de la colonne ou de la combinaison de colonnes. Par ailleurs, aucune
colonne faisant partie de la clé primaire ne peut contenir de valeur NULL.
Remarque : L'unicité fait partie de la définition d'une contrainte de clé primaire. Le
serveur Oracle l'applique en créant de façon implicite un index unique sur la ou les
colonnes de clé primaire.

Contrainte FOREIGN KEY
DEPARTMENTS
PRIMARY
KEY
…
EMPLOYEES
FOREIGN
KEY

…
INSERT INTO Non autorisé
(9 n'existe pas)
Autorisé

La contrainte FOREIGN KEY (ou contrainte d'intégrité référentielle) désigne une colonne
ou une combinaison de colonnes comme clé étrangère, et établit une relation avec une clé
primaire ou une clé unique dans la même table ou dans une autre table.
Dans l'exemple de la diapositive ci-dessus, la colonne DEPARTMENT_ID a été définie
comme clé étrangère dans la table EMPLOYEES (table enfant ou table dépendante). Elle
référence la colonne DEPARTMENT_ID de la table DEPARTMENTS (la table parent ou
table référencée).
Règles
• La valeur d'une clé étrangère doit correspondre à une valeur existante de la table
parent ou être NULL.
• Les clés étrangères sont basées sur des valeurs. Il s'agit de pointeurs purement logiques
(et non physiques).

Elle est définie au niveau table ou au niveau colonne :

last_name VARCHAR2(25) NOT NULL,
email VARCHAR2(25),
salary NUMBER(8,2),
commission_pct NUMBER(2,2),
hire_date DATE NOT NULL,
...
department_id NUMBER(4),

CONSTRAINT emp_dept_fk FOREIGN KEY (department_id)
REFERENCES departments(department_id),
CONSTRAINT emp_email_uk UNIQUE(email));
Contrainte FOREIGN KEY (suite)

Les contraintes FOREIGN KEY peuvent être définies au niveau colonne ou au niveau table.
Une clé étrangère composée doit être créée au niveau table.
L'exemple de la diapositive ci-dessus définit une contrainte FOREIGN KEY sur la colonne
DEPARTMENT_ID de la table EMPLOYEES, à l'aide de la syntaxe de niveau table. Le nom
de la contrainte est EMP_DEPT_FK.
La clé étrangère peut aussi être définie au niveau colonne, à condition que la contrainte soit
basée sur une colonne unique. La syntaxe diffère dans le sens où les mots-clés FOREIGN
KEY n'apparaissent pas. Par exemple :
CREATE TABLE employees
(...
department_id NUMBER(4) CONSTRAINT emp_deptid_fk
REFERENCES departments(department_id),
...
)

Contrainte FOREIGN KEY : Mots-clés
• FOREIGN KEY : Définit la colonne dans la table enfant,

au niveau table.
• REFERENCES : Identifie la table et la colonne
dans la table parent.
• ON DELETE CASCADE : Supprime les lignes dépendantes
dans la table enfant en cas de suppression d'une ligne
dans la table parent.
• ON DELETE SET NULL : Convertit les valeurs
de clé étrangère dépendantes en valeurs NULL.

Contrainte FOREIGN KEY : Mots-clés

La clé étrangère est définie dans la table enfant. La table contenant la colonne référencée
est la table parent. La clé étrangère est définie à l'aide d'une combinaison des mots-clés
suivants :
• FOREIGN KEY est utilisé pour définir la colonne dans la table enfant, au niveau table.
• REFERENCES identifie la table et la colonne dans la table parent.
• ON DELETE CASCADE indique qu'en cas de suppression d'une ligne dans la table
parent les lignes dépendantes de la table enfant sont aussi supprimées.
• ON DELETE SET NULL indique qu'en cas de suppression d'une ligne dans la table
parent les valeurs de clé étrangère deviennent NULL.
Le comportement par défaut, appelé règle de restriction, désactive la mise à jour ou la
suppression des données référencées.
En l'absence de l'option ON DELETE CASCADE ou ON DELETE SET NULL, une ligne de
la table parent ne peut être supprimée que si elle est référencée dans la table enfant.

Contrainte CHECK
• Elle définit une condition à laquelle chaque ligne

doit satisfaire.
• Les expressions suivantes ne sont pas autorisées :
– Références aux pseudo-colonnes CURRVAL, NEXTVAL,
LEVEL et ROWNUM
– Appels de fonctions SYSDATE, UID, USER et USERENV
– Interrogations faisant référence à d'autres valeurs
dans d'autres lignes
..., salary NUMBER(2)

CONSTRAINT emp_salary_min
CHECK (salary > 0),...
Contrainte CHECK
La contrainte CHECK définit une condition à laquelle chaque ligne doit satisfaire.
Cette condition peut utiliser les mêmes structures que les conditions d'une interrogation,
avec les exceptions suivantes :
• Références aux pseudo-colonnes CURRVAL, NEXTVAL, LEVEL et ROWNUM.
• Appels de fonctions SYSDATE, UID, USER et USERENV.
• Interrogations faisant référence à d'autres valeurs dans d'autres lignes.
Une colonne peut comporter plusieurs contraintes CHECK dans sa définition. Il est possible
de définir un nombre illimité de contraintes CHECK sur une colonne.
Les contraintes CHECK peuvent être définies au niveau colonne ou au niveau table.
(...
salary NUMBER(8,2) CONSTRAINT emp_salary_min
CHECK (salary > 0),
...

CREATE TABLE : Exemple

( employee_id NUMBER(6)
CONSTRAINT emp_employee_id PRIMARY KEY
, first_name VARCHAR2(20)
, last_name VARCHAR2(25)
CONSTRAINT emp_last_name_nn NOT NULL
, email VARCHAR2(25)
CONSTRAINT emp_email_nn NOT NULL
CONSTRAINT emp_email_uk UNIQUE
, phone_number VARCHAR2(20)
, hire_date DATE
CONSTRAINT emp_hire_date_nn NOT NULL
, job_id VARCHAR2(10)
CONSTRAINT emp_job_nn NOT NULL
, salary NUMBER(8,2)
CONSTRAINT emp_salary_ck CHECK (salary>0)

, commission_pct NUMBER(2,2)
, manager_id NUMBER(6)
CONSTRAINT emp_manager_fk REFERENCES
employees (employee_id)
, department_id NUMBER(4)
CONSTRAINT emp_dept_fk REFERENCES
departments (department_id));
CREATE TABLE : Exemple

L'exemple de la diapositive ci-dessus présente l'instruction utilisée pour créer la table
EMPLOYEES dans le schéma HR.

Violation de contraintes
UPDATE employees
WHERE department_id = 110;

Le département 55 n'existe pas.
Lorsque des contraintes appliquées à des colonnes sont enfreintes, une erreur est renvoyée.
C'est le cas, par exemple, si vous tentez de mettre à jour un enregistrement dont la valeur
est liée à une contrainte d'intégrité.
Dans l'exemple de la diapositive ci-dessus, le département 55 n'existe pas dans la table
parent DEPARTMENTS. L'erreur de violation ORA-02291 "parent key not found" est
générée.

Vous ne pouvez pas supprimer une ligne qui contient une clé
primaire utilisée comme clé étrangère dans une autre table.


Violation de contraintes (suite)

Si vous tentez de supprimer un enregistrement dont la valeur est liée à une contrainte
d'intégrité, une erreur est renvoyée.
L'exemple de la diapositive tente de supprimer le département 60 de la table
DEPARTMENTS. Cela entraîne la génération d'une erreur car cet ID de département
est utilisé comme clé étrangère dans la table EMPLOYEES. Si l'enregistrement parent
que vous tentez de supprimer a des enregistrements enfant, vous recevez l'erreur
de violation ORA-02292 "child record found".
L'instruction suivante fonctionne car le département 70 ne compte aucun employé :

Contenu du chapitre

– Option DEFAULT
FOREIGN KEY, CHECK

• ALTER TABLE

Créer une table
à l'aide d'une sous-interrogation

• Créez une table et insérez-y des lignes en associant
l'instruction CREATE TABLE et l'option AS subquery.
CREATE TABLE table
[(column, column...)]
AS subquery;
• Faites correspondre le nombre de colonnes indiquées

et le nombre de colonnes de la sous-interrogation.
• Définissez les colonnes avec des noms et des valeurs
par défaut.

Créer une table à l'aide d'une sous-interrogation

Une deuxième méthode permettant de créer une table consiste à appliquer la clause AS
subquery, qui crée la table et y insère les lignes renvoyées par la sous-interrogation.
Dans la syntaxe :
column Définit le nom de la colonne, la valeur par défaut et la contrainte
d'intégrité.
subquery Est l'instruction SELECT qui définit l'ensemble de lignes à insérer
dans la nouvelle table.
Règles
• La table est créée avec les noms de colonne indiqués, et les lignes extraites par
l'instruction SELECT sont insérées dans la table.
• La définition des colonnes peut contenir uniquement le nom de la colonne et la valeur
par défaut.
• Si des spécifications de colonnes sont précisées, le nombre de colonnes doit être égal à
celui des colonnes de la liste SELECT de la sous-interrogation.
• Si aucune spécification de colonne n'est indiquée, les noms de colonne de la table sont
les mêmes que ceux de la sous-interrogation.
• Les définitions de type de données de colonne et la contrainte NOT NULL sont
transmis à la nouvelle table. Seule la contrainte NOT NULL explicite est héritée. La
colonne PRIMARY KEY ne transmet pas la caractéristique NOT NULL à la nouvelle
colonne. Aucune autre règle de contrainte n'est transmise à la nouvelle table. Vous
pouvez toutefois ajouter des contraintes dans la définition de la colonne.

Créer une table
à l'aide d'une sous-interrogation
CREATE TABLE dept80

AS
SELECT employee_id, last_name,
salary*12 ANNSAL,
hire_date
FROM employees

DESCRIBE dept80
Créer une table à l'aide d'une sous-interrogation (suite)

L'exemple de la diapositive ci-dessus crée une table nommée DEPT80, qui contient les
détails de tous les employés travaillant dans le département 80. Notez que les données de
cette table proviennent de la table EMPLOYEES.
Vous pouvez vérifier l'existence d'une table de base de données, ainsi que la définition de
ses colonnes, à l'aide de la commande DESCRIBE.
Veillez toutefois à fournir un alias de colonne lors de la sélection d'une expression.
L'expression SALARY*12 se voit attribuer l'alias ANNSAL. Sans cet alias, l'erreur suivante
serait générée :

Contenu du chapitre

– Option DEFAULT
FOREIGN KEY, CHECK

• ALTER TABLE

Instruction ALTER TABLE
Utilisez l'instruction ALTER TABLE pour effectuer

les opérations suivantes :
• Ajouter une nouvelle colonne
• Modifier la définition d'une colonne existante
• Définir une valeur par défaut pour la nouvelle colonne
• Supprimer une colonne
• Renommer une colonne
• Mettre une table en lecture seule

Instruction ALTER TABLE

Vous pouvez avoir besoin de modifier la structure d'une table existante pour les raisons
suivantes :
• Vous avez omis une colonne.
• Vous devez modifier la définition ou le nom d'une colonne.
• Vous devez supprimer des colonnes.
• Vous souhaitez placer la table en mode lecture seule.
Utilisez dans ce cas l'instruction ALTER TABLE.

Tables en lecture seule
Pour placer une table en mode lecture seule, utilisez la syntaxe

ALTER TABLE :
• Cela empêche les modifications LDD ou LMD pendant la
maintenance de la table.
• Il est ensuite possible de revenir au mode lecture/écriture.
ALTER TABLE employees READ ONLY;
-- perform table maintenance and then

-- return table back to read/write mode

ALTER TABLE employees READ WRITE;
Tables en lecture seule

Avec Oracle Database 11g, vous pouvez indiquer READ ONLY pour placer une table en
mode lecture seule. Lorsque la table est dans ce mode, vous ne pouvez pas exécuter
d'instructions LMD affectant la table, ni d'instructions SELECT ... FOR UPDATE.
Vous pouvez exécuter des instructions LDD à condition qu'elles ne modifient aucune
donnée de la table. Lorsque la table est en mode lecture seule, les opérations sur les index
associés sont autorisées.
Pour replacer la table en mode lecture/écriture, indiquez READ/WRITE.
Remarque : Vous pouvez supprimer une table qui est en mode READ ONLY. En effet, la
commande DROP étant exécutée uniquement dans le dictionnaire de données, l'accès au
contenu de la table n'est pas requis. L'espace utilisé par la table n'est réclamé que lorsque le
tablespace repasse en mode lecture/écriture. Les modifications requises peuvent alors être
apportées aux en-têtes de segment de bloc, etc.
Pour plus d'informations sur l'instruction ALTER TABLE, reportez-vous au cours Oracle
Database 10g : Les fondamentaux du langage SQL (II).

Contenu du chapitre

– Option DEFAULT
FOREIGN KEY, CHECK

• ALTER TABLE

Supprimer une table
• Place une table dans la corbeille.

• Supprime entièrement la table et l'ensemble de ses données
si la clause PURGE est indiquée.
• Invalide les objets dépendants et supprime les privilèges
objet associés à la table.
DROP TABLE dept80;

Supprimer une table

L'instruction DROP TABLE place une table dans la corbeille, ou supprime entièrement la
table et l'ensemble de ses données de la base. Si vous n'indiquez pas la clause PURGE,
l'instruction DROP TABLE n'entraîne pas de restitution d'espace au tablespace pour d'autres
objets. L'espace reste décompté du quota alloué à l'utilisateur. La suppression d'une table
invalide les objets dépendants et supprime les privilèges objet associés à la table.
Lorsque vous supprimez une table, la base perd toutes les données de cette table, de même
que tous les index associés.
Syntaxe
DROP TABLE table [PURGE]
Dans la syntaxe, table correspond au nom de la table.
Règles
• Toutes les données sont supprimées de la table.
• Les vues et les synonymes sont conservés, mais ne sont plus valides.
• Toutes les transactions en attente sont validées (commit).
• Seul le créateur de la table ou un utilisateur disposant du privilège DROP ANY
TABLE peut supprimer une table.
Remarque : Vous pouvez utiliser l'instruction FLASHBACK TABLE pour restaurer une
table supprimée à partir de la corbeille. Cette opération est traitée en détail dans le cours
Oracle Database 11g : Les fondamentaux du langage SQL (II).

Synthèse
Ce chapitre vous a présenté l'instruction CREATE TABLE

et les contraintes. Vous avez appris à :
• identifier les principaux objets de base de données
• visualiser la structure d'une table
• énumérer les types de données disponibles
pour les colonnes
• créer une table simple
• expliquer le processus de définition de contraintes

lors de la création d'une table
• expliquer le fonctionnement des objets de schéma
Synthèse
Ce chapitre vous a permis de découvrir les instructions suivantes :
CREATE TABLE
• Elle permet de créer une table et de lui associer des contraintes.
• Vous pouvez créer une table à partir d'une autre table à l'aide d'une sous-interrogation.
DROP TABLE
• Elle permet de supprimer les lignes et la structure d'une table.
• Une fois exécutée, elle ne peut plus être annulée.


• créer de nouvelle tables
• créer une nouvelle table à l'aide de la syntaxe CREATE
TABLE AS
• vérifier l'existence de tables
• mettre une table en lecture seule
• supprimer des tables

Dans cet exercice, vous allez créer de nouvelles tables à l'aide de l'instruction CREATE
TABLE. Vous allez ensuite vérifier leur ajout à la base de données. Vous allez également
apprendre à attribuer le statut READ ONLY à une table, puis à lui attribuer de nouveau le
statut READ/WRITE.
Remarque : Pour exécuter dans SQL Developer une interrogation comprenant des
instructions LDD ou LMD, cliquez sur l'icône Run Script (ou appuyez sur [F5]). Vous
pouvez ainsi voir les messages renvoyés dans l'onglet Script Output. Pour les interrogations
SELECT, continuez à utiliser l'icône Execute Statement ou à appuyer sur [F9] pour obtenir
le résultat mis en forme dans l'onglet Results.

Exercice 10
1. Créez la table DEPT conformément aux indications du tableau ci-après. Enregistrez
l'instruction dans un script nommé lab_10_01.sql, puis exécutez ce script pour
créer la table. Vérifiez que la table a bien été créée.
Nom de la colonne ID NAME
Type de clé Clé primaire
NULL/Unique
Table de clé étrangère
Colonne de clé étrangère
Type de données NUMBER VARCHAR2
Longueur 7 25

2. Remplissez la table DEPT avec les données de la table DEPARTMENTS. Incluez
uniquement les colonnes dont vous avez besoin.
3. Créez la table EMP conformément aux indications du tableau ci-après. Enregistrez
l'instruction dans un script nommé lab_10_03.sql, puis exécutez ce script pour
créer la table. Vérifiez que la table a bien été créée.
Nom de la ID LAST_NAME FIRST_NAME DEPT_ID

colonne
Type de clé
NULL/Unique
Table de clé DEPT
étrangère
Colonne de clé ID
étrangère
Type de NUMBER VARCHAR2 VARCHAR2 NUMBER
données
Longueur 7 25 25 7

Exercice 10 (suite)
4. Créez la table EMPLOYEES2 en utilisant la structure de la table EMPLOYEES.
Incluez uniquement les colonnes EMPLOYEE_ID, FIRST_NAME, LAST_NAME,
SALARY et DEPARTMENT_ID. Intitulez les colonnes de la nouvelle table
respectivement ID, FIRST_NAME, LAST_NAME, SALARY et DEPT_ID.
5. Placez la table EMPLOYEES2 en mode lecture seule.
6. Essayez d'insérer la ligne suivante dans la table EMPLOYEES2 :
ID FIRST_NAME LAST_NAME SALARY DEPT_ID
34 Grant Marcie 5678 10
Vous obtenez le message d'erreur suivant :

7. Remettez la table EMPLOYEES2 en mode lecture-écriture. Essayez à nouveau
d'insérer la même ligne. Vous devez obtenir les messages suivants :
8. Supprimez la table EMPLOYEES2.



Créer d'autres objets de schéma

Objectifs

• créer des vues simples et des vues complexes
• extraire des données à partir de vues
• créer, gérer et utiliser des séquences
• créer et gérer des index
• créer des synonymes privés et des synonymes publics

Objectifs
Ce chapitre traite des vues, des séquences, des synonymes et des index. Il décrit les
principes de base de la création et de l'utilisation des vues, des séquences et des index.

Contenu du chapitre
• Présentation des vues :

– Créer et modifier une vue, et en extraire des données
– Effectuer des opérations LMD sur une vue
– Supprimer une vue
• Présentation des séquences :
– Créer, utiliser et modifier une séquence
– Mettre des valeurs de séquence en mémoire cache
– Utiliser les pseudo-colonnes NEXTVAL et CURRVAL

• Présentation des index :
– Créer et supprimer des index
• Présentation des synonymes :
– Créer et supprimer des synonymes

Objet Description

Index Améliore les performances de certaines
interrogations d'extraction de données

Synonyme Attribue un autre nom aux objets

Une base de données ne se compose pas uniquement de tables mais comporte plusieurs
autres objets. Ce chapitre présente les vues, les séquences, les index et les synonymes.
Les vues permettent de présenter certaines données des tables et de masquer les autres.
De nombreuses applications nécessitent l'utilisation de numéros uniques en tant que valeurs
de clé primaire. Pour cela, vous pouvez inclure du code dans l'application ou utiliser une
séquence pour générer des numéros uniques.
Si vous souhaitez améliorer les performances des interrogations d'extraction de données,
vous devez envisager la création d'un index. Les index permettent également d'imposer
l'unicité sur une colonne ou un ensemble de colonnes.
Vous pouvez attribuer d'autres noms aux objets à l'aide de synonymes.

Vue : Présentation
Table EMPLOYEES

Vue : Présentation
Vous pouvez afficher des sous-ensembles ou des combinaisons logiques de données en
créant des vues des tables. Une vue est une table logique basée sur une table ou sur une
autre vue. Elle ne contient aucune donnée propre, mais s'apparente à une fenêtre par
l'intermédiaire de laquelle les données des tables peuvent être consultées ou modifiées. Les
tables sur lesquelles une vue est basée sont appelées tables de base. Une vue est stockée en
tant qu'instruction SELECT dans le dictionnaire de données.

Avantages des vues
Simplifier les
Limiter l'accès interrogations
aux données complexes

Assurer Présenter
l'indépendance différentes vues des
des données mêmes données
Avantages des vues

• Les vues limitent l'accès aux données car elles affichent uniquement des colonnes
spécifiques d'une table.
• Elles permettent d'extraire les résultats d'interrogations complexes en exécutant des
interrogations simples. Par exemple, un utilisateur peut y recourir pour afficher les
informations de plusieurs tables sans savoir comment écrire une instruction de
jointure.
• Indépendantes des données, les vues conviennent aux utilisateurs et aux applications
ad hoc. Une même vue peut en effet être utilisée pour extraire des données de plusieurs
tables.
• Les vues permettent à des groupes d'utilisateurs d'accéder aux données en fonction de
critères particuliers.
Pour plus d'informations, reportez-vous à la section "CREATE VIEW" du manuel Oracle

Vues simples et vues complexes
Caractéristique Vues simples Vues complexes

Nombre de tables Une Une ou plusieurs
Contiennent des Non Oui
fonctions
Contiennent des groupes Non Oui
de données
Opérations LMD par Oui Pas toujours
l'intermédiaire d'une vue

Vues simples et vues complexes

Les vues sont classées en deux catégories : les vues simples et les vues complexes.
La principale différence se situe au niveau des opérations LMD (INSERT, UPDATE et
DELETE).
• Une vue simple :
- utilise les données d'une seule table,
- ne contient aucune fonction ni aucun groupe de données,
- permet d'effectuer des opérations LMD.
• Une vue complexe :
- utilise les données de plusieurs tables,
- contient des fonctions ou des groupes de données,
- ne permet pas toujours d'effectuer des opérations LMD.

Créer une vue
• Imbriquez une sous-interrogation dans l'instruction CREATE

VIEW :
CREATE [OR REPLACE] [FORCE|NOFORCE] VIEW view

[(alias[, alias]...)]
AS subquery
[WITH CHECK OPTION [CONSTRAINT constraint]]
[WITH READ ONLY [CONSTRAINT constraint]];
• La sous-interrogation peut contenir une syntaxe SELECT

complexe.
Créer une vue

Vous pouvez créer une vue en imbriquant une sous-interrogation dans l'instruction
CREATE VIEW.
Dans la syntaxe :
OR REPLACE Recrée la vue si elle existe déjà.
FORCE Crée la vue, que les tables de base existent ou non.
NOFORCE Ne crée la vue que si les tables de base existent
(il s'agit de l'option par défaut).
view Est le nom de la vue.
alias Indique le nom des expressions sélectionnées par l'interrogation
de la vue. (Le nombre d'alias doit correspondre au nombre
d'expressions sélectionnées par la vue.)
subquery Est une instruction SELECT complète. (Vous pouvez utiliser
des alias pour les colonnes de la liste SELECT.)
WITH CHECK OPTION Indique que seules les lignes accessibles par la vue peuvent
être insérées ou mises à jour.
constraint Est le nom attribué à la contrainte CHECK OPTION.
WITH READ ONLY Garantit qu'aucune opération LMD ne peut être effectuée
sur la vue.
Remarque : Dans SQL Developer, pour exécuter des instructions LDD (langage de
définition de données), cliquez sur l'icône Run Script ou appuyez sur [F5]. Les messages
renvoyés apparaissent dans l'onglet Script Output.

Créer une vue
• Créez la vue EMPVU80, qui contient les détails relatifs aux

employés du département 80 :
CREATE VIEW empvu80
AS SELECT employee_id, last_name, salary
FROM employees
• Décrivez la structure de la vue à l'aide de la commande

DESCRIBE de iSQL*Plus :

DESCRIBE empvu80
Créer une vue (suite)

L'exemple de la diapositive crée une vue contenant le numéro, le nom et le salaire de
chaque employé du département 80.
Vous pouvez afficher la structure de la vue à l'aide de la commande DESCRIBE.
Règles
• La sous-interrogation qui définit une vue peut contenir une syntaxe SELECT
complexe, incluant des jointures, des groupes et des sous-interrogations.
• Si vous ne précisez pas de nom de contrainte pour une vue créée avec l'option WITH
CHECK OPTION, le système attribue à la contrainte un nom par défaut de la forme
SYS_Cn.
• Vous pouvez utiliser l'option OR REPLACE pour changer la définition d'une vue. Cela
vous évite de supprimer la vue, de la recréer, puis d'accorder à nouveau les privilèges
objet.

Créer une vue
• Créez une vue en utilisant des alias de colonne

dans la sous-interrogation :
CREATE VIEW salvu50
AS SELECT employee_id ID_NUMBER, last_name NAME,
salary*12 ANN_SALARY
FROM employees
• Sélectionnez les colonnes de cette vue à l'aide des alias

fournis.
Créer une vue (suite)

Vous pouvez contrôler les noms de colonne en incluant des alias de colonne dans la
sous-interrogation.
L'exemple de la diapositive ci-dessus crée une vue contenant le numéro d'employé
(EMPLOYEE_ID) avec l'alias ID_NUMBER, le nom (LAST_NAME) avec l'alias NAME et le
salaire annuel (SALARY) avec l'alias ANN_SALARY pour chaque employé du
département 50.
Vous pouvez également utiliser des alias après l'instruction CREATE et avant la sous-
interrogation SELECT. Le nombre d'alias doit correspondre au nombre d'expressions
sélectionnées dans la sous-interrogation.
CREATE OR REPLACE VIEW salvu50 (ID_NUMBER, NAME, ANN_SALARY)
AS SELECT employee_id, last_name, salary*12
FROM employees

Extraire des données d'une vue
SELECT *
FROM salvu50;


Vous pouvez extraire des données d'une vue, tout comme à partir de n'importe quelle table.
Vous pouvez afficher le contenu de la vue entière, ou simplement des lignes et des
colonnes spécifiques.

Modifier une vue
• Modifiez la vue EMPVU80 à l'aide d'une clause CREATE OR

REPLACE VIEW. Ajoutez un alias pour chaque nom de
colonne :
CREATE OR REPLACE VIEW empvu80
(id_number, name, sal, department_id)
AS SELECT employee_id, first_name || ' '
|| last_name, salary, department_id
FROM employees

• Les alias de colonne de la clause CREATE OR REPLACE
VIEW sont listés dans le même ordre que les colonnes
de la sous-interrogation.
Modifier une vue

L'option OR REPLACE permet de créer une vue même s'il en existe déjà une portant ce
nom. La version la plus ancienne est alors remplacée pour son propriétaire. Cela signifie
qu'il est possible de modifier une vue sans avoir à la supprimer, puis à la recréer et à
accorder de nouveau les privilèges objet.
Remarque : Lors de l'attribution d'alias de colonne dans la clause CREATE OR REPLACE
VIEW, rappelez-vous que les alias sont listés dans le même ordre que les colonnes de la
sous-interrogation.

Créer une vue complexe
Créez une vue complexe contenant des fonctions de groupe

pour afficher des valeurs provenant de deux tables :
CREATE OR REPLACE VIEW dept_sum_vu
(name, minsal, maxsal, avgsal)
AS SELECT d.department_name, MIN(e.salary),
MAX(e.salary),AVG(e.salary)
ON (e.department_id = d.department_id)
GROUP BY d.department_name;

Créer une vue complexe

L'exemple de la diapositive ci-dessus crée une vue complexe comportant le nom et les
salaires minimum, maximum et moyen de chaque département. Notez que des alias ont été
indiqués pour cette vue. Cette condition est obligatoire si une colonne de la vue est dérivée
d'une fonction ou d'une expression.
Vous pouvez afficher la structure de la vue à l'aide de la commande DESCRIBE. Affichez
le contenu de la vue en exécutant une instruction SELECT.
SELECT *
FROM dept_sum_vu;

Règles relatives à l'exécution
d'opérations LMD sur une vue

• Vous pouvez généralement exécuter
des opérations LMD sur des vues simples.
• Vous ne pouvez pas supprimer une ligne si la vue contient
l'un des éléments suivants :
– des fonctions de groupe
– une clause GROUP BY
– le mot-clé DISTINCT
– le mot-clé ROWNUM de pseudo-colonne

Règles relatives à l'exécution d'opérations LMD sur une vue

Vous pouvez exécuter des opérations LMD sur des données par l'intermédiaire d'une vue si
ces opérations respectent certaines règles.
Vous pouvez supprimer une ligne d'une vue, sauf si celle-ci contient l'un des éléments
suivants :
• des fonctions de groupe,
• une clause GROUP BY,
• le mot-clé DISTINCT,
• le mot-clé ROWNUM de pseudo-colonne.


Vous ne pouvez pas modifier les données
d'une vue si celle-ci contient l'un des éléments suivants :
• des fonctions de groupe
• une clause GROUP BY
• le mot-clé DISTINCT
• le mot-clé ROWNUM de pseudo-colonne
• des colonnes définies par des expressions

Règles relatives à l'exécution d'opérations LMD sur une vue (suite)

Vous pouvez modifier des données par l'intermédiaire d'une vue, sauf si cette vue contient
l'un des éléments répertoriés dans la diapositive précédente ou des colonnes définies par
des expressions (par exemple, SALARY * 12).


Vous ne pouvez pas ajouter de données par l'intermédiaire
d'une vue si celle-ci inclut l'un des éléments suivants :
• des fonctions de groupe
• une clause GROUP BY
• le mot-clé DISTINCT
• le mot-clé ROWNUM de pseudo-colonne
• des colonnes définies par des expressions
• des colonnes NOT NULL dans les tables de base qui ne sont

pas sélectionnées par la vue
Règles relatives à l'exécution d'opérations LMD sur une vue (suite)

Vous pouvez ajouter des données par l'intermédiaire d'une vue, sauf si cette vue contient
l'un des éléments répertoriés dans la diapositive ci-dessus. Vous ne pouvez pas ajouter de
données à une vue qui contient des colonnes NOT NULL sans valeurs par défaut dans la
table de base. Toutes les valeurs requises doivent être présentes dans la vue. Rappelez-vous
que vous ajoutez les valeurs directement dans la table sous-jacente par l'intermédiaire de la
vue.
Pour plus d'informations, reportez-vous à la section "CREATE VIEW" du manuel Oracle

Utiliser la clause WITH CHECK OPTION
• La clause WITH CHECK OPTION permet de garantir

que les opérations LMD effectuées sur la vue concernent
uniquement les lignes sélectionnées par celle-ci :
AS SELECT *
FROM employees
WHERE department_id = 20
WITH CHECK OPTION CONSTRAINT empvu20_ck ;

• Toute tentative d'insertion (INSERT) d'une ligne dont la
valeur department_id est différente de 20 ou de mise à
jour (UPDATE) de l'ID de département d'une ligne dans la
vue échoue car il s'agit d'une violation de la contrainte WITH
CHECK OPTION.
Utiliser la clause WITH CHECK OPTION

Il est possible d'effectuer des vérifications d'intégrité référentielle par l'intermédiaire de
vues. Vous pouvez également appliquer des contraintes au niveau de la base de données.
Les vues peuvent être utilisées pour préserver l'intégrité des données, mais cette utilisation
est très limitée.
La clause WITH CHECK OPTION indique que les opérations INSERT et UPDATE
effectuées par l'intermédiaire de la vue ne peuvent pas créer de lignes que la vue ne peut
pas sélectionner. Ceci permet d'appliquer des contraintes d'intégrité et des vérifications de
validation sur les données à insérer ou à mettre à jour. Si un utilisateur tente de lancer des
opérations LMD sur des lignes que la vue n'a pas sélectionnées, une erreur s'affiche, avec le
nom de la contrainte s'il a été indiqué.
UPDATE empvu20
entraîne :
Remarque : Aucune ligne n'est mise à jour car, si l'ID de département en cours était
remplacé par l'ID 10, la vue n'afficherait plus les employés concernés. Par conséquent, avec
la clause WITH CHECK OPTION, la vue ne peut afficher que les employés du
département 20 et l'ID de département de ces employés ne peut pas être modifié par
l'intermédiaire de la vue.

Empêcher les opérations LMD
• Vous pouvez empêcher toute opération LMD en ajoutant

l'option WITH READ ONLY à la définition de la vue.
• Toute tentative de lancement d'une opération LMD sur une
ligne de la vue provoque le renvoi d'une erreur par le serveur
Oracle.


Vous pouvez empêcher l'exécution d'opérations LMD sur une vue en créant cette dernière
avec l'option WITH READ ONLY. L'exemple de la diapositive suivante modifie la vue
EMPVU10 de façon à empêcher l'exécution d'opérations LMD sur celle-ci.


(employee_number, employee_name, job_title)
AS SELECT employee_id, last_name, job_id
FROM employees
WITH READ ONLY ;

Empêcher les opérations LMD (suite)

Toute tentative de suppression d'une ligne dans une vue définie avec une contrainte de
lecture seule provoque une erreur :
DELETE FROM empvu10
WHERE employee_number = 200;
De manière identique, toute tentative d'insertion ou de modification d'une ligne à l'aide
d'une vue définie avec une contrainte de lecture seule se traduit par la même erreur.

Supprimer une vue
La suppression d'une vue n'entraîne aucune perte de données,

car une vue est basée sur les tables sous-jacentes de la base
de données.
DROP VIEW view;
DROP VIEW empvu80;

Supprimer une vue

Utilisez l'instruction DROP VIEW pour supprimer une vue. Cette instruction supprime la
définition de la vue dans la base de données. Toutefois, la suppression d'une vue n'a aucune
incidence sur les tables sur lesquelles la vue est basée. En revanche, les vues ou autres
applications basées sur la vue supprimée ne sont plus valides. Une vue ne peut être
supprimée que par son créateur ou par un utilisateur doté du privilège DROP ANY VIEW.
Dans la syntaxe :
view Est le nom de la vue.

Présentation de l'exercice 11 : Première partie

• créer une vue simple
• créer une vue complexe
• créer une vue avec une contrainte CHECK
• modifier les données de la vue
• supprimer des vues

Présentation de l'exercice 11 : Première partie

La première partie de l'exercice de ce chapitre concerne la création, l'utilisation et la
suppression de vues. Traitez les points 1 à 6 à la fin du chapitre.

Contenu du chapitre

– Créer et modifier une vue, et en extraire des données


Séquences
Objet Description

interrogations

Séquences
Une séquence est un objet de base de données qui crée des valeurs entières. Vous pouvez
créer des séquences, puis les utiliser pour générer des numéros.

Séquences
Une séquence :
• peut automatiquement générer des numéros uniques
• est un objet partageable
• peut être utilisée pour créer une valeur de clé primaire
• remplace du code applicatif
• permet un accès plus rapide à ses valeurs lorsqu'elle
est mise en mémoire cache

2 4 6 8 10
1 3 5 7 9
Séquences (suite)
Une séquence est un objet de base de données créé par un utilisateur, qui peut être partagé
par plusieurs utilisateurs pour générer des nombres entiers.
Vous pouvez définir une séquence pour générer des valeurs uniques, ou pour recycler des
numéros afin de les réutiliser.
Les séquences sont généralement utilisées pour générer des valeurs de clé primaire,
lesquelles doivent être uniques pour chaque ligne. Une séquence est générée et incrémentée
(ou décrémentée) par un sous-programme Oracle interne. Cet objet permet de gagner du
temps, en réduisant la quantité de code applicatif nécessaire à l'écriture d'un sous-
programme de génération de séquence.
Les numéros de séquence sont stockés et générés indépendamment des tables. Ainsi, la
même séquence peut être utilisée pour plusieurs tables.

Instruction CREATE SEQUENCE : Syntaxe
Définissez une séquence afin de générer automatiquement

des numéros séquentiels :
CREATE SEQUENCE sequence
[INCREMENT BY n]
[START WITH n]
[{MAXVALUE n | NOMAXVALUE}]
[{MINVALUE n | NOMINVALUE}]
[{CYCLE | NOCYCLE}]
[{CACHE n | NOCACHE}];

Instruction CREATE SEQUENCE : Syntaxe

Générez automatiquement des numéros séquentiels à l'aide de l'instruction CREATE
SEQUENCE.
Dans la syntaxe :
sequence Est le nom du générateur de numéros de séquence.
INCREMENT BY n Indique l'intervalle entre les numéros de la séquence,
n étant un nombre entier. (Si cette clause est omise,
les numéros sont incrémentés de 1.)
START WITH n Indique le premier numéro de séquence à générer.
(Si cette clause est omise, la séquence commence par 1.)
MAXVALUE n Indique la valeur maximale pouvant être générée
par la séquence.
NOMAXVALUE Indique une valeur maximale de 10^27 pour une séquence
croissante et de –1 pour une séquence décroissante.
(Il s'agit de l'option par défaut.)
MINVALUE n Indique la valeur minimale de la séquence.
NOMINVALUE Indique une valeur maximale de 1 pour une séquence
croissante et de –(10^26) pour une séquence décroissante.
(Il s'agit de l'option par défaut.)

Créer une séquence
• Créez une séquence nommée DEPT_DEPTID_SEQ à utiliser

pour la clé primaire de la table DEPARTMENTS.
• N'utilisez pas l'option CYCLE.
CREATE SEQUENCE dept_deptid_seq

INCREMENT BY 10
START WITH 120
MAXVALUE 9999
NOCACHE
NOCYCLE;

Créer une séquence (suite)

CYCLE | NOCYCLE Indique si la séquence continue de générer des valeurs
une fois la valeur maximale ou minimale atteinte.
(NOCYCLE est l'option par défaut.)
CACHE n | NOCACHE Indique le nombre de valeurs préallouées et conservées
en mémoire par le serveur Oracle. (Par défaut,
le serveur Oracle conserve 20 valeurs dans la mémoire
cache.)
L'exemple de la diapositive crée une séquence nommée DEPT_DEPTID_SEQ à utiliser
pour la colonne DEPARTMENT_ID de la table DEPARTMENTS. La séquence démarre à
120, ne permet pas la mise en mémoire cache et n'utilise pas l'option CYCLE.
N'utilisez pas l'option CYCLE si la séquence est utilisée pour générer des valeurs de clé
primaire, sauf si vous disposez d'un mécanisme fiable qui supprime les anciennes lignes
plus rapidement que les valeurs de la séquence ne se recyclent.
Pour plus d'informations, reportez-vous à la section "CREATE SEQUENCE" du manuel
Oracle Database SQL Language Reference 11g, Release 1 (11.1).
Remarque : La séquence n'est pas liée à une table. Généralement, il convient de nommer
la séquence en fonction de l'utilisation pour laquelle elle est prévue. Toutefois, la séquence
peut être utilisée n'importe où, quel que soit son nom.

Pseudo-colonnes NEXTVAL et CURRVAL
• NEXTVAL renvoie la valeur de séquence disponible suivante.

Elle renvoie une valeur unique chaque fois qu'elle est
référencée, même pour des utilisateurs différents.
• CURRVAL obtient la valeur de séquence actuelle.
• Pour que CURRVAL contienne une valeur, NEXTVAL doit être
référencée au préalable pour la même séquence.

Pseudo-colonnes NEXTVAL et CURRVAL

Dès lors qu'une séquence est créée, elle génère des numéros de séquence pouvant être
utilisés dans les tables. Vous référencez les valeurs de la séquence à l'aide des
pseudo-colonnes NEXTVAL et CURRVAL.
La pseudo-colonne NEXTVAL est utilisée pour extraire les numéros successifs d'une
séquence déterminée. Vous devez qualifier NEXTVAL avec le nom de la séquence. Lorsque
vous référencez sequence.NEXTVAL, un nouveau numéro de séquence est généré et le
numéro de séquence actuel est placé dans CURRVAL.
La pseudo-colonne CURRVAL permet de faire référence au numéro de séquence que
l'utilisateur actuel vient de générer. Pour cela, NEXTVAL doit être utilisée au préalable pour
générer un numéro de séquence dans la session de l'utilisateur actuel. Vous devez qualifier
CURRVAL avec le nom de la séquence. Lorsque vous référencez sequence.CURRVAL,
la dernière valeur renvoyée au processus de l'utilisateur s'affiche.

Pseudo-colonnes NEXTVAL et CURRVAL (suite)

Règles d'utilisation de NEXTVAL et CURRVAL
Vous pouvez utiliser NEXTVAL et CURRVAL dans les contextes suivants :
• Liste SELECT d'une instruction SELECT ne faisant pas partie
d'une sous-interrogation.
• Liste SELECT faisant partie d'une sous-interrogation dans une instruction INSERT.
• Clause VALUES d'une instruction INSERT.
• Clause SET d'une instruction UPDATE.
En revanche, vous ne pouvez pas utiliser NEXTVAL et CURRVAL dans les contextes
suivants :
• Liste SELECT d'une vue.
• Instruction SELECT avec le mot-clé DISTINCT.
• Instruction SELECT avec les clauses GROUP BY, HAVING ou ORDER BY.
• Sous-interrogation faisant partie d'une instruction SELECT, DELETE ou UPDATE.

• Expression DEFAULT d'une instruction CREATE TABLE ou ALTER TABLE.
Pour plus d'informations, reportez-vous aux sections "Pseudocolumns" et "CREATE
SEQUENCE" du manuel Oracle Database SQL Language Reference 11g, Release 1 (11.1).

Utiliser une séquence
• Insérez un nouveau département nommé Support à

l'emplacement dont l'ID = 2500 :
INSERT INTO departments(department_id,
department_name, location_id)
VALUES (dept_deptid_seq.NEXTVAL,
'Support', 2500);
• Affichez la valeur actuelle de la séquence

DEPT_DEPTID_SEQ :

SELECT dept_deptid_seq.CURRVAL
FROM dual;
Utiliser une séquence

L'exemple de la diapositive ci-dessus insère un nouveau département dans la table
DEPARTMENTS. Il utilise la séquence DEPT_DEPTID_SEQ pour générer un nouvel ID de
département comme suit.
Vous pouvez afficher la valeur actuelle de la séquence à l'aide de
sequence_name.CURRVAL, comme illustré dans le deuxième exemple de la diapositive
ci-dessus. Le résultat de l'interrogation est le suivant :
A présent, supposons que vous souhaitiez embaucher des employés pour le nouveau
département. L'instruction INSERT à exécuter pour les nouveaux employés peut inclure le
code suivant :
INSERT INTO employees (employee_id, department_id, ...)
VALUES (employees_seq.NEXTVAL, dept_deptid_seq .CURRVAL, ...);
Remarque : Dans l'exemple précédent, il est supposé qu'une séquence nommée
EMPLOYEES_SEQ a été créée pour générer de nouveaux numéros d'employé.

Mettre en mémoire cache les valeurs
d'une séquence
• La mise en mémoire cache des valeurs d'une séquence
permet un accès plus rapide à ces valeurs.
• La présence de trous dans une séquence peut être due à :
– une annulation
– une défaillance du système
– l'utilisation de cette séquence dans une autre table

Mettre en mémoire cache les valeurs d'une séquence

Vous pouvez mettre les valeurs d'une séquence en mémoire cache afin de permettre un
accès plus rapide à ces valeurs. Le cache est alimenté la première fois que vous référencez
la séquence. Lors de chaque interrogation, la valeur suivante de la séquence est extraite du
cache. Lorsque la dernière valeur de la séquence est utilisée, l'interrogation suivante place
une nouvelle série de valeurs en mémoire cache.
Trous dans une séquence
Les générateurs de séquence produisent des numéros qui se suivent, mais cette action est
effectuée indépendamment des opérations de validation (commit) ou d'annulation
(rollback). Ainsi, si vous annulez une instruction contenant une séquence, le numéro
correspondant est perdu.
La défaillance du système peut également provoquer des trous dans une séquence. Si des
valeurs de la séquence se trouvent en mémoire cache, elles sont perdues.
Etant donné que les séquences ne sont pas directement liées aux tables, la même séquence
peut être utilisée pour plusieurs tables. Toutefois, dans ce cas, chaque table peut présenter
des numéros de séquence discontinus.

Modifier une séquence
Vous pouvez changer la valeur de l'incrément, la valeur

maximale, la valeur minimale, l'option de bouclage ou l'option
de mise en mémoire cache :
ALTER SEQUENCE dept_deptid_seq

INCREMENT BY 20
MAXVALUE 999999
NOCACHE
NOCYCLE;

Modifier une séquence

Lorsque vous atteignez la limite MAXVALUE de la séquence, aucune nouvelle valeur n'est
allouée et une erreur signale le dépassement. Si vous souhaitez continuer à utiliser la
séquence, vous pouvez la modifier à l'aide de l'instruction ALTER SEQUENCE.
Syntaxe
ALTER SEQUENCE sequence
[INCREMENT BY n]
[{MAXVALUE n | NOMAXVALUE}]
[{MINVALUE n | NOMINVALUE}]
[{CYCLE | NOCYCLE}]
[{CACHE n | NOCACHE}];
Dans la syntaxe, sequence correspond au nom du générateur de numéros de séquence.
Pour plus d'informations, reportez-vous à la section "ALTER SEQUENCE" du manuel

Règles de modification d'une séquence
• Vous devez être propriétaire de la séquence ou être doté

du privilège ALTER pour cette séquence.
• Seuls les numéros de séquence ultérieurs sont affectés
par la modification.
• La séquence doit être supprimée et recréée si vous
souhaitez la démarrer à partir d'un autre numéro.
• Une validation est effectuée.
• Pour supprimer une séquence, utilisez l'instruction DROP :

DROP SEQUENCE dept_deptid_seq;
Règles de modification d'une séquence

• Pour pouvoir modifier une séquence, vous devez être son propriétaire ou être doté du
privilège ALTER pour cette séquence. Pour pouvoir la supprimer, vous devez être son
propriétaire ou disposer du privilège DROP ANY SEQUENCE.
• Seuls les numéros de séquence ultérieurs sont affectés par l'instruction ALTER
SEQUENCE.
• L'option START WITH ne peut pas être modifiée à l'aide de l'instruction ALTER
SEQUENCE. La séquence doit être supprimée et recréée si vous souhaitez la
redémarrer à partir d'un autre numéro.
• Une validation est effectuée. Par exemple, il n'est pas possible d'imposer une nouvelle
valeur MAXVALUE inférieure au numéro de séquence actuel.
ALTER SEQUENCE dept_deptid_seq
INCREMENT BY 20
MAXVALUE 90
NOCACHE
NOCYCLE;
• Vous obtenez l'erreur :

Contenu du chapitre

– Créer, modifier et extraire des données dans une vue


Index
Objet Description

interrogations

Index
Les index sont des objets de base de données que vous pouvez créer pour améliorer les
performances de certaines interrogations. Des index peuvent aussi être créés
automatiquement par le serveur lorsque vous créez une contrainte PRIMARY KEY ou
UNIQUE.

Index
Un index :
• est un objet de schéma
• peut être utilisé par le serveur Oracle pour accélérer
l'extraction de lignes à l'aide d'un pointeur
• permet de réduire les E/S disque en fournissant
une méthode d'accès permettant de localiser rapidement
les données
• est indépendant de la table qu'il indexe

• est utilisé et géré automatiquement par le serveur Oracle
Index (suite)
Dans le serveur Oracle, un index est un objet de schéma permettant d'accélérer l'extraction
de lignes à l'aide d'un pointeur. Les index peuvent être créés de manière explicite ou
automatique. Si la colonne ne comporte pas d'index, un balayage complet de table (full
table scan) est effectué.
Un index permet un accès direct et rapide aux lignes d'une table. Il réduit les entrées-sorties
(E/S) disque grâce à un chemin indexé permettant de localiser rapidement les données. Un
index est utilisé et géré automatiquement par le serveur Oracle. Une fois l'index créé,
aucune activité directe n'est requise de la part de l'utilisateur.
Les index sont logiquement et physiquement indépendants de la table qu'ils indexent. Cela
signifie qu'ils peuvent être créés ou supprimés à tout moment, sans aucune incidence sur les
tables de base ou sur les autres index.
Remarque : Lorsque vous supprimez une table, les index correspondants sont également
supprimés.
Pour plus d'informations, reportez-vous à la section "Schema Objects: Indexes" du manuel
Oracle Database Concepts 11g, Release 1 (11.1).

Modes de création d'un index
• Automatiquement : Un index unique est créé

automatiquement lorsque vous définissez une contrainte
PRIMARY KEY ou UNIQUE dans la définition d'une table.
• Manuellement : Les utilisateurs peuvent créer des index non

uniques sur des colonnes afin d'accélérer l'accès aux lignes.

Modes de création d'un index

Vous pouvez créer deux types d'index.
Index unique : Le serveur Oracle crée automatiquement un index lorsque vous définissez
une contrainte PRIMARY KEY ou UNIQUE sur une colonne d'une table. Le nom de l'index
est le nom attribué à la contrainte.
Index non unique : Il s'agit d'un index qui peut être créé par l'utilisateur. Par exemple,
vous pouvez créer un index sur une colonne FOREIGN KEY pour une jointure définie dans
une interrogation afin d'accélérer l'extraction.
Remarque : Vous pouvez créer un index unique manuellement, mais il est plutôt
recommandé de le créer implicitement par le biais de la définition d'une contrainte
UNIQUE.

Créer un index
• Créez un index sur une ou plusieurs colonnes :

CREATE [UNIQUE][BITMAP]INDEX index
ON table (column[, column]...);
• Réduisez le temps d'accès de l'interrogation à la colonne

LAST_NAME de la table EMPLOYEES :
CREATE INDEX emp_last_name_idx
ON employees(last_name);

Créer un index
Créez un index sur une ou plusieurs colonnes à l'aide de l'instruction CREATE INDEX.
Dans la syntaxe :
• index Est le nom de l'index.
• table Est le nom de la table.
• column Est le nom de la colonne à indexer dans la table.
Précisez UNIQUE pour indiquer que la valeur de la colonne (ou des colonnes) sur laquelle
est basé l'index doit être unique. Précisez BITMAP pour indiquer qu'il faut créer un index
avec un bitmap pour chaque clé distincte au lieu d'indexer chaque ligne séparément. Les
index bitmap stockent en tant que bitmap les rowid associés à une valeur de clé.
Pour plus d'informations, reportez-vous à la section "CREATE INDEX" du manuel Oracle

Règles de création d'un index
Créez un index dans les cas suivants :

Une colonne contient une plage étendue de valeurs.
Une colonne contient un grand nombre de valeurs NULL.
Une ou plusieurs colonnes sont fréquemment utilisées dans une
clause WHERE ou dans une condition de jointure.
La table est volumineuse ou il est prévu que la plupart des
interrogations extraient moins de 2 à 4 % des lignes de la table.
Ne créez pas d'index dans les cas suivants :
Les colonnes ne sont pas souvent utilisées comme condition
dans l'interrogation.

La table est de petite taille ou il est prévu que la plupart des
interrogations extraient plus de 2 à 4 % des lignes de la table.
La table est mise à jour fréquemment.
Les colonnes indexées sont référencées dans le cadre d'une expression.
Règles de création d'un index

Plus ne signifie pas toujours mieux
L'exécution des interrogations n'est pas accélérée si vous multipliez les index sur une table.
En effet, chaque opération LMD validée sur une table comportant des index implique la
mise à jour de ces derniers. Plus le nombre d'index associés à une table est important, plus
le serveur Oracle est sollicité pour mettre à jour tous les index après une opération LMD.
Quand créer un index
Ainsi, vous ne devez créer des index que dans les cas suivants :
• La colonne contient une plage étendue de valeurs.
• La colonne contient un grand nombre de valeurs NULL.
• Une ou plusieurs colonnes sont fréquemment utilisées ensemble dans une clause
WHERE ou une condition de jointure.
• La table est volumineuse et il est prévu que la plupart des interrogations extraient
moins de 2 à 4 % des lignes.
Rappelez-vous que si vous souhaitez imposer l'unicité, vous devez définir une contrainte
UNIQUE dans la définition de la table. Un index unique est alors créé automatiquement.

Supprimer un index
• Supprimez un index du dictionnaire de données à l'aide

de la commande DROP INDEX :
DROP INDEX index;
• Supprimez l'index emp_last_name_idx du dictionnaire

de données :
DROP INDEX emp_last_name_idx;

• Pour supprimer un index, vous devez en être le propriétaire
ou disposer du privilège DROP ANY INDEX.
Supprimer un index
Vous ne pouvez pas modifier un index directement. Vous devez le supprimer, puis le
recréer.
Pour supprimer la définition d'un index dans le dictionnaire de données, exécutez
l'instruction DROP INDEX. Pour supprimer un index, vous devez en être le propriétaire ou
disposer du privilège DROP ANY INDEX.
Dans la syntaxe, index correspond au nom de l'index.
Remarque : Si vous supprimez une table, les index et les contraintes sont
automatiquement supprimés, mais les vues et les séquences sont conservées.

Contenu du chapitre

– Créer, modifier et extraire des données dans une vue


Synonymes
Objet Description

interrogations

Synonymes
Les synonymes sont des objets de base de données qui permettent d'appeler une table par
un autre nom. Vous pouvez les utiliser pour définir les noms de votre choix.

Créer un synonyme pour un objet
Simplifiez l'accès aux objets en créant un synonyme

(autre nom pour un objet). Grâce aux synonymes, vous
pouvez :
• créer une référence plus simple à une table appartenant
à un autre utilisateur
• raccourcir les noms d'objet trop longs
CREATE [PUBLIC] SYNONYM synonym
FOR object;

Créer un synonyme pour un objet

Pour faire référence à une table appartenant à un autre utilisateur, vous devez ajouter au
nom de la table un préfixe constitué du nom de l'utilisateur qui l'a créée, suivi d'un point.
La création d'un synonyme évite d'avoir à qualifier le nom de l'objet avec le schéma, qu'il
s'agisse d'une table, d'une vue, d'une séquence, d'une procédure ou d'autres objets. Cette
méthode peut s'avérer particulièrement utile avec les noms d'objet longs tels que les noms
de vue.
Dans la syntaxe :
PUBLIC Crée un synonyme accessible à tous les utilisateurs.
synonym Est le nom du synonyme à créer.
object Identifie l'objet pour lequel le synonyme est créé.
Règles
• L'objet ne peut pas être contenu dans un package.
• Tout synonyme privé doit être différent du nom des autres objets appartenant au même
utilisateur.
Pour plus d'informations, reportez-vous à la section "CREATE SYNONYM" du manuel

Créer et supprimer des synonymes
• Définissez un nom abrégé pour la vue DEPT_SUM_VU :

CREATE SYNONYM d_sum
FOR dept_sum_vu;
• Supprimez un synonyme :
DROP SYNONYM d_sum;

Créer et supprimer des synonymes

Créer un synonyme
L'exemple de la diapositive ci-dessus crée un synonyme pour la vue DEPT_SUM_VU, afin
qu'elle puisse être référencée plus facilement.
L'administrateur de base de données peut créer un synonyme public accessible à tous les
utilisateurs. L'exemple suivant crée un synonyme public nommé DEPT pour la table
DEPARTMENTS d'Alice :
CREATE PUBLIC SYNONYM dept

FOR alice.departments;
Supprimer un synonyme
Pour supprimer un synonyme, utilisez l'instruction DROP SYNONYM. Seul l'administrateur
de la base de données peut supprimer un synonyme public.
DROP PUBLIC SYNONYM dept;
Pour plus d'informations, reportez-vous à la section "DROP SYNONYM" du manuel Oracle

Synthèse
Ce chapitre vous a permis d'apprendre à :

• créer, utiliser et supprimer des vues
• générer automatiquement des numéros de séquence à l'aide
d'un générateur de numéros de séquence
• créer des index pour accélérer l'extraction de données
• utiliser des synonymes pour attribuer d'autres noms à des
objets

Synthèse
Ce chapitre vous a présenté les vues, les séquences, les index et les synonymes.

Présentation de l'exercice 11 : Deuxième partie

• créer des séquences
• utiliser des séquences
• créer des index non uniques
• créer des synonymes

Présentation de l'exercice 11 : Deuxième partie

La deuxième partie de l'exercice de ce chapitre concerne la création et l'utilisation d'une
séquence, d'un index et d'un synonyme.
Elle correspond aux points 7 à 10.

Exercice 11
Première partie
1. Le département des ressources humaines souhaite masquer certaines des données de
la table EMPLOYEES. Il souhaite obtenir une vue nommée EMPLOYEES_VU,
comprenant les ID et les noms d'employé ainsi que les ID de département de la table
EMPLOYEES. L'en-tête EMPLOYEE doit être attribué à la colonne contenant les noms
d'employé.
2. Vérifiez que la vue fonctionne. Affichez le contenu de la vue EMPLOYEES_VU.

…
3. A l'aide de la vue EMPLOYEES_VU, écrivez pour le département des ressources

humaines une interrogation permettant d'afficher les noms d'employé et les ID de
département correspondants.

Exercice 11 (suite)
4. Le département 50 a besoin d'accéder aux données concernant ses employés. Créez une
vue nommée DEPT50 contenant l'ID d'employé, le nom et l'ID de département de tous
les employés du département 50. Vous devez intituler les colonnes de la vue EMPNO,
EMPLOYEE et DEPTNO. Pour des raisons de sécurité, n'autorisez pas le transfert d'un
employé vers un autre département par l'intermédiaire de la vue.
5. Affichez la structure et le contenu de la vue DEPT50.

6. Testez la vue. Tentez de transférer Matos vers le département 80.

Exercice 11 (suite)
Deuxième partie
7. Vous avez besoin d'une séquence pouvant être utilisée avec la colonne PRIMARY KEY de la
table DEPT. La séquence doit commencer à 200 et présenter une valeur maximum de 1 000.
La séquence doit croître par incréments de 10. Nommez-la DEPT_ID_SEQ.
8. Pour tester la séquence, écrivez un script permettant d'insérer deux lignes dans la table DEPT.
Nommez le script lab_11_08.sql. Veillez à utiliser la séquence que vous avez créée pour
la colonne ID. Ajoutez deux départements : Education et Administration. Vérifiez vos ajouts.
Exécutez les commandes enregistrées dans le script.
9. Créez un index non unique sur la colonne NAME de la table DEPT.
10. Créez un synonyme pour la table EMPLOYEES. Nommez-le EMP.

____________________
____________________
Solutions des exercices
A

Solutions de l'exercice I : Introduction
Les solutions des exercices du chapitre Introduction sont détaillées ci-après.
Exécuter la démonstration d'Oracle SQL Developer : Créer une connexion de base

de données
1. Accédez à la démonstration Créer une connexion de base de données à l'adresse :

http://st-curriculum.oracle.com/tutorial/SQLDeveloper/html/module2/mod02_cp_newdbconn.htm
Démarrer Oracle SQL Developer
2. Démarrez Oracle SQL Developer à l'aide de l'icône correspondante sur le bureau.
1. Cliquez deux fois sur l'icône sqldeveloper du bureau.
Remarque : Lorsque vous lancez SQL Developer pour la première fois, vous devez

indiquer le chemin du fichier java.exe. Dans le cadre du cours, cette opération a déjà
été effectuée pour vous. Dans tous les cas, si vous y êtes invité, indiquez le chemin
suivant :
D:\app\Administrator\product\11.1.0\client_1\jdevstudio\jdk\bin
Créer une connexion de base de données SQL Developer
3. Pour créer une connexion de base de données, cliquez avec le bouton droit de la souris sur
Connections dans le navigateur de connexions (Connections Navigator). Dans le menu,
sélectionnez New Connection. La boîte de dialogue New/Select Database Connection
apparaît.
4. Créez une connexion de base de données à l'aide des informations suivantes :
a. Connection Name : myconnection
b. Username : oraxx, où xx est le numéro de votre PC (Demandez au formateur de vous

affecter un compte ora dans la plage ora1-ora20.)
c. Password : oraxx
d. Hostname : Entrez le nom d'hôte de l'ordinateur sur lequel est exécuté votre serveur de
base de données.
e. Port : 1521
f. SID : ORCL
g. Cochez la case Save Password.
Oracle Database 11g : Les fondamentaux du langage SQL (I) A - 2

Solutions de l'exercice I : Introduction (suite)
Tester et utiliser la connexion de base de données pour Oracle SQL Developer

5. Testez la nouvelle connexion.
1. Cliquez sur le bouton Test dans la fenêtre New/Select Database Connection.
6. Si le statut est Success, connectez-vous à la base de données à l'aide de cette nouvelle
connexion.
1. Si le statut est Success, cliquez sur le bouton Connect.
Naviguer au sein des tables dans le navigateur de connexions
7. Dans le navigateur de connexions, visualisez les objets à votre disposition sous le noeud
Tables. Vérifiez que les tables suivantes sont présentes :
COUNTRIES

DEPARTMENTS
EMPLOYEES
JOB_GRADES
JOB_HISTORY
JOBS
LOCATIONS
REGIONS
1. Développez la connexion myconnection en cliquant sur le signe plus situé

en regard.
2. Développez l'icône Tables en cliquant sur le signe plus situé en regard.
8. Naviguez dans la structure de la table EMPLOYEES.
1. Pour afficher la structure de la table EMPLOYEES, cliquez sur EMPLOYEES.

Par défaut, la structure de la table est affichée dans l'onglet actif, Columns.
9. Visualisez les données de la table DEPARTMENTS.
1. Cliquez sur la table DEPARTMENTS.
2. Cliquez sur l'onglet Data. Les données de la table sont affichées.

Solutions de l'exercice I : Introduction (suite)
Ouvrir une feuille de calcul SQL Worksheet
10. Ouvrez une nouvelle feuille de calcul SQL Worksheet. Examinez les icônes de raccourci
disponibles pour cette feuille de calcul.
1. Pour ouvrir une nouvelle feuille de calcul, sélectionnez SQL Worksheet dans le
menu Tools.
2. Vous pouvez aussi cliquer avec le bouton droit de la souris sur myconnection
et sélectionner Open SQL Worksheet.
3. Affichez les icônes de raccourci dans la feuille SQL Worksheet. Recherchez plus
précisément les icônes Execute Statement et Run Script.

Solutions de l'exercice 1 : Extraire des données à l'aide de l'instruction SQL
SELECT
Première partie
Testez vos connaissances :
1. L'instruction SELECT suivante est exécutée avec succès :

SELECT last_name, job_id, salary AS Sal
FROM employees;
Vrai/Faux
2. L'instruction SELECT suivante est exécutée avec succès :

SELECT *
FROM job_grades;

Vrai/Faux
3. L'instruction suivante présente quatre erreurs de codage. Pouvez-vous les identifier ?

SELECT employee_id, last_name
sal x 12 ANNUAL SALARY
FROM employees;
• La table EMPLOYEES ne contient pas de colonne nommée sal. La colonne

est intitulée SALARY.
• L'opérateur de multiplication est * et non x (ligne 2).
• L'alias ANNUAL SALARY ne peut pas inclure d'espaces. L'alias devrait être
ANNUAL_SALARY ou être placé entre guillemets.
• Il manque une virgule après la colonne LAST_NAME.
Deuxième partie
Avant de commencer les exercices, notez les points suivants :

Enregistrez tous vos fichiers d'exercice à l'emplacement suivant :
D:\labs\SQL1\labs.
Entrez vos instructions SQL dans une feuille de calcul SQL Worksheet. Pour
enregistrer un script dans SQL Developer, sélectionnez Save As dans le menu File,
ou cliquez avec le bouton droit de la souris dans la feuille de calcul et sélectionnez
Save file pour enregistrer votre instruction SQL sous la forme d'un script nommé
lab_<lessonno>_<stepno>.sql. Pour modifier un script existant,
sélectionnez File > Open pour l'ouvrir, modifiez-le, puis enregistrez-le sous un autre
nom à l'aide de l'option Save As.
Pour exécuter l'interrogation, cliquez sur l'icône Execute Statement (ou appuyez
sur [F9]) dans la feuille de calcul SQL Worksheet. Pour les instructions LMD et LDD,
cliquez sur l'icône Run Script (ou appuyez sur [F5]).
Après avoir exécuté un script enregistré, vous ne pouvez pas lancer l'interrogation
suivante dans la même feuille de calcul. Ouvrez une nouvelle feuille.
SELECT (suite)
Vous avez été embauché en tant que programmeur SQL par la société Acme Corporation.
Votre première tâche consiste à créer des états à partir des données des tables du département
des ressources humaines.
4. Vous devez d'abord déterminer la structure et le contenu de la table DEPARTMENTS.
a. Pour déterminer la structure de la table DEPARTMENTS :

b. Pour afficher les données de la table DEPARTMENTS :

SELECT *

FROM departments;
5. Vous devez déterminer la structure de la table EMPLOYEES.

DESCRIBE employees
Le département des ressources humaines souhaite une interrogation affichant le nom,

l'ID de poste, la date d'embauche et l'ID d'employé de chaque employé, l'ID
d'employé apparaissant en premier. Associez l'alias STARTDATE à la colonne
HIRE_DATE. Enregistrez votre instruction SQL dans un fichier nommé
lab_01_05.sql afin de pouvoir fournir ce fichier au département des ressources
humaines.
SELECT employee_id, last_name, job_id, hire_date StartDate
FROM employees;
6. Testez l'interrogation enregistrée dans le fichier lab_01_05.sql afin de vérifier

qu'elle s'exécute correctement.
SELECT employee_id, last_name, job_id, hire_date StartDate
FROM employees;
7. Le département des ressources humaines a besoin d'une interrogation affichant tous les ID
de poste uniques de la table EMPLOYEES.
SELECT DISTINCT job_id
FROM employees;

SELECT (suite)
Troisième partie
S'il vous reste du temps, effectuez les exercices suivants :
8. Le département des ressources humaines souhaite des en-têtes de colonne plus descriptifs
pour son état sur les employés. Copiez l'instruction enregistrée dans lab_01_05.sql
dans une nouvelle feuille de calcul SQL Worksheet. Nommez les en-têtes de colonne
respectivement Emp #, Employee, Job et Hire Date. Exécutez à nouveau votre
interrogation.
SELECT employee_id "Emp #", last_name "Employee",
job_id "Job", hire_date "Hire Date"
FROM employees;
9. Le département des ressources humaines a demandé un état listant tous les employés avec

leur ID de poste. Affichez le nom concaténé avec l'ID de poste (en séparant les deux par
une virgule et un espace) et intitulez la colonne Employee and Title.
SELECT last_name||', '||job_id "Employee and Title"
FROM employees;
Pour mettre en pratique vos connaissances de façon plus approfondie, effectuez l'exercice
suivant :
10. Pour vous familiariser avec le contenu de la table EMPLOYEES, créez une interrogation
affichant toutes les données de cette table. Séparez les colonnes de résultat par une
virgule. Intitulez la colonne THE_OUTPUT.
SELECT employee_id || ',' || first_name || ',' || last_name
|| ',' || email || ',' || phone_number || ','|| job_id
|| ',' || manager_id || ',' || hire_date || ','
|| salary || ',' || commission_pct || ',' || department_id
THE_OUTPUT
FROM employees;

Solutions de l'exercice 2 : Restreindre et trier les données
Le département des ressources humaines a besoin de votre aide pour créer des interrogations.
1. Pour des raisons budgétaires, ce département a besoin d'un état affichant le nom et le
salaire des employés qui gagnent plus de 12 000 $. Enregistrez votre instruction SQL
dans le fichier lab_02_01.sql. Exécutez votre interrogation.
SELECT last_name, salary
FROM employees
WHERE salary > 12000;
2. Ouvrez une nouvelle feuille de calcul SQL Worksheet. Créez un état affichant le nom et
le numéro de département correspondant à l'ID d'employé 176.
FROM employees

3. Le département des ressources humaines a besoin de connaître les employés dont le
salaire est élevé et ceux dont le salaire est faible. Modifiez le fichier lab_02_01.sql
pour afficher le nom et le salaire des employés dont le salaire ne figure pas dans la plage
de 5 000 $ à 12 000 $. Enregistrez votre instruction SQL dans le fichier
lab_02_03.sql.
FROM employees
WHERE salary NOT BETWEEN 5000 AND 12000;
4. Créez un état affichant le nom, l'ID de poste et la date d'embauche des employés nommés
Matos et Taylor. Triez les données par ordre croissant en fonction de la date d'embauche.
SELECT last_name, job_id, hire_date
FROM employees
WHERE last_name IN ('Matos', 'Taylor')
ORDER BY hire_date;
5. Affichez le nom et le numéro de département de tous les employés du département 20 ou

50 par ordre alphabétique croissant, en fonction du nom.
FROM employees
WHERE department_id IN (20, 50)
ORDER BY last_name ASC;

Solutions de l'exercice 2 : Restreindre et trier les données (suite)
6. Modifiez le fichier lab_02_03.sql pour afficher le nom et le salaire des employés qui
gagnent entre 5 000 $ et 12 000 $, et travaillent dans le département 20 ou 50. Intitulez
respectivement les colonnes Employee et Monthly Salary. Enregistrez le fichier
lab_02_03.sql sous le nom lab_02_06.sql. Exécutez l'instruction figurant dans
lab_02_06.sql.
SELECT last_name "Employee", salary "Monthly Salary"
FROM employees
WHERE salary BETWEEN 5000 AND 12000
AND department_id IN (20, 50);
7. Le département des ressources humaines a besoin d'un état affichant le nom et la date
d'embauche de tous les employés embauchés en 1994.
SELECT last_name, hire_date
FROM employees
WHERE hire_date LIKE '%94';

8. Créez un état affichant le nom et l'intitulé de poste de tous les employés qui n'ont pas de
manager.
SELECT last_name, job_id
FROM employees
WHERE manager_id IS NULL;
9. Créez un état affichant le nom, le salaire et la commission de tous les employés qui
perçoivent des commissions. Triez les données par ordre décroissant en fonction du
salaire et des commissions. Utilisez la position numérique de la colonne dans la clause
ORDER BY.
SELECT last_name, salary, commission_pct
FROM employees
WHERE commission_pct IS NOT NULL
ORDER BY 2 DESC, 3 DESC;
10. Les membres du département des ressources humaines souhaitent davantage de souplesse
dans les interrogations que vous écrivez. Ils voudraient un état affichant le nom et le
salaire des employés qui gagnent plus qu'un montant saisi par l'utilisateur en réponse à
une invite. (Vous pouvez utiliser l'interrogation créée dans l'exercice 1 et la modifier.)
Enregistrez cette interrogation dans le fichier lab_02_10.sql.
a. Lorsque vous êtes invité à saisir une valeur, indiquez 12000. Cliquez sur OK.
FROM employees
WHERE salary > &sal_amt;

Solutions de l'exercice 2 : Restreindre et trier les données (suite)
11. Le département des ressources humaines souhaite exécuter des états sur la base d'un
manager. Créez une interrogation invitant l'utilisateur à indiquer un ID de manager, et
générant l'ID d'employé, le nom, le salaire et le département des employés de ce manager.
Le département des ressources humaines souhaite pouvoir trier l'état en fonction d'une
colonne sélectionnée. Vous pouvez tester les données avec les valeurs suivantes :
manager_id = 103, tri sur la base de last_name
manager_id = 201, tri sur la base de salary
manager_id = 124, tri sur la base de employee_id

SELECT employee_id, last_name, salary, department_id
FROM employees
WHERE manager_id = &mgr_num

ORDER BY &order_col;
12. Affichez le nom de tous les employés dont le nom comprend la lettre "a" en troisième
position.
SELECT last_name
FROM employees
WHERE last_name LIKE '__a%';
13. Affichez le nom de tous les employés dont le nom comporte un "a" et un "e".
SELECT last_name
FROM employees
WHERE last_name LIKE '%a%'
AND last_name LIKE '%e%';
Pour mettre en pratique vos connaissances de façon plus approfondie, effectuez les exercices
suivants :
14. Affichez le nom, le poste et le salaire de tous les employés dont le poste est vendeur ou
commis aux stocks, et dont le salaire n'est pas égal à 2 500 $, 3 500 $ ou 7 000 $.
SELECT last_name, job_id, salary
FROM employees
WHERE job_id IN ('SA_REP', 'ST_CLERK')
AND salary NOT IN (2500, 3500, 7000);
15. Modifiez lab_02_06.sql pour afficher le nom, le salaire et la commission de tous les
employés dont la commission est de 20 %. Enregistrez le fichier lab_02_06.sql sous
le nom lab_02_15.sql. Exécutez l'instruction figurant dans lab_02_15.sql.
SELECT last_name "Employee", salary "Monthly Salary",
commission_pct
FROM employees
WHERE commission_pct = .20;

Solutions de l'exercice 3 : Utiliser des fonctions monolignes pour
personnaliser les résultats
1. Ecrivez une interrogation permettant d'afficher la date système. Intitulez la colonne

Date.
Remarque : Si votre base de données est distante et située dans un autre fuseau horaire,
le résultat sera la date correspondant au système d'exploitation sur lequel réside la base de
données.
SELECT sysdate "Date"

FROM dual;
2. Le département des ressources humaines a besoin d'un état permettant d'afficher le

numéro d'employé, le nom, le salaire et le salaire augmenté de 15,5 % (exprimé sous la

forme d'un nombre entier) pour chaque employé. Nommez la colonne New Salary.
Enregistrez l'instruction SQL dans le fichier lab_03_02.sql.
SELECT employee_id, last_name, salary,
ROUND(salary * 1.155, 0) "New Salary"
FROM employees;
3. Exécutez l'interrogation figurant dans le fichier lab_03_02.sql.

ROUND(salary * 1.155, 0) "New Salary"
FROM employees;
4. Modifiez l'interrogation lab_03_02.sql pour ajouter une colonne permettant de

soustraire l'ancien salaire du nouveau. Nommez la colonne Increase. Enregistrez le
contenu du fichier sous le nom lab_03_04.sql. Exécutez l'interrogation modifiée.
ROUND(salary * 1.155, 0) "New Salary",
ROUND(salary * 1.155, 0) - salary "Increase"
FROM employees;
5. Ecrivez une interrogation permettant d'afficher le nom (la première lettre en majuscule et
toutes les autres lettres en minuscules) et la longueur du nom de tous les employés dont le
nom commence par les lettres "J", "A" ou "M". Attribuez à chaque colonne un libellé
approprié. Triez les résultats en fonction du nom des employés.
SELECT INITCAP(last_name) "Name",
LENGTH(last_name) "Length"
FROM employees
WHERE last_name LIKE 'J%'
OR last_name LIKE 'M%'
OR last_name LIKE 'A%'
ORDER BY last_name ;

Solutions de l'exercice 3 : Utiliser des fonctions monolignes pour
personnaliser les résultats (suite)
Réécrivez l'interrogation de sorte que l'utilisateur soit invité à saisir la lettre par laquelle
le nom doit commencer. Par exemple, si l'utilisateur saisit H (en majuscule) à l'invite, le
résultat doit afficher tous les employés dont le nom commence par la lettre "H".
FROM employees
WHERE last_name LIKE '&start_letter%'
ORDER BY last_name;
Modifiez l'interrogation de sorte que la casse de la lettre saisie n'affecte pas le résultat. La
lettre saisie doit être convertie en majuscule avant traitement par l'interrogation SELECT.

FROM employees
WHERE last_name LIKE UPPER('&start_letter%' )
ORDER BY last_name;
6. Le département des ressources humaines souhaite connaître l'ancienneté de chaque

employé. Pour chacun d'eux, affichez le nom et calculez le nombre de mois entre
aujourd'hui et la date d'embauche de l'employé. Intitulez la colonne MONTHS_WORKED.
Triez les résultats sur la base du nombre de mois d'ancienneté. Arrondissez le nombre de
mois au nombre entier supérieur le plus proche.
Remarque : Cette interrogation dépendant de sa date d'exécution, les valeurs de la

colonne MONTHS_WORKED seront différentes dans votre cas.
SELECT last_name, ROUND(MONTHS_BETWEEN(
SYSDATE, hire_date)) MONTHS_WORKED
FROM employees
ORDER BY months_worked;
7. Créez une interrogation permettant d'afficher le nom et le salaire de tous les employés.
Formatez le salaire de sorte qu'il contienne 15 caractères et soit complété à gauche par le
symbole $. Intitulez la colonne SALARY.
SELECT last_name,
LPAD(salary, 15, '$') SALARY
FROM employees;

Solutions de l'exercice 3 : Utiliser des fonctions monolignes
pour personnaliser les résultats (suite)
8. Créez une interrogation permettant d'afficher les huit premiers caractères du nom des
employés, ainsi que le montant de leur salaire avec des astérisques. Chaque astérisque
représente un millier de dollars. Triez les données par salaire décroissant. Intitulez la
colonne EMPLOYEES_AND_THEIR_SALARIES.
SELECT rpad(last_name, 8)||' '||
rpad(' ', salary/1000+1, '*')
EMPLOYEES_AND_THEIR_SALARIES
FROM employees
ORDER BY salary DESC;
9. Créez une interrogation permettant d'afficher le nom et l'ancienneté en semaines de tous

les employés du département 90. Nommez TENURE la colonne contenant le nombre de
semaines. Tronquez le nombre de semaines de sorte qu'il n'y ait aucun chiffre après la

virgule. Affichez les enregistrements par ordre décroissant sur la base de la colonne
TENURE.
a. Remarque : La valeur TENURE diffère selon la date d'exécution de l'interrogation.
SELECT last_name, trunc((SYSDATE-hire_date)/7) AS TENURE

FROM employees
ORDER BY TENURE DESC

Solutions de l'exercice 4 : Utiliser des fonctions de conversion
et des expressions conditionnelles
1. Créez un état qui produit les éléments suivants pour chaque employé :
<employee last name> earns <salary> monthly but wants <3
times salary.>. Intitulez la colonne Dream Salaries.
SELECT last_name || ' earns '
|| TO_CHAR(salary, 'fm$99,999.00')
|| ' monthly but wants '
|| TO_CHAR(salary * 3, 'fm$99,999.00')
|| '.' "Dream Salaries"
FROM employees;
2. Pour chaque employé, affichez le nom, la date d'embauche et la date de révision du

salaire, soit le premier lundi après six mois d'ancienneté. Intitulez la colonne REVIEW.
Affichez les dates sous la forme "Monday, the Thirty-First of July, 2000".

SELECT last_name, hire_date,
TO_CHAR(NEXT_DAY(ADD_MONTHS(hire_date, 6),'MONDAY'),
'fmDay, "the" Ddspth "of" Month, YYYY') REVIEW
FROM employees;
3. Affichez le nom, la date d'embauche et le jour de la semaine où l'employé a commencé.

Intitulez la colonne DAY. Triez les résultats en fonction du jour de la semaine, en
commençant par le lundi (Monday).
SELECT last_name, hire_date,
TO_CHAR(hire_date, 'DAY') DAY
FROM employees
ORDER BY TO_CHAR(hire_date - 1, 'd');
4. Créez une interrogation qui affiche le nom et le montant de la commission de chaque

employé. Si un employé ne perçoit pas de commission, indiquez "No Commission".
Intitulez la colonne COMM.
SELECT last_name,
NVL(TO_CHAR(commission_pct), 'No Commission') COMM
FROM employees;

Solutions de l'exercice 4 : Utiliser des fonctions de conversion
et des expressions conditionnelles (suite)
5. A l'aide de la fonction DECODE, écrivez une interrogation qui affiche le niveau de tous les
employés sur la base de la valeur de la colonne JOB_ID, à l'aide des données suivantes :
Poste Niveau
AD_PRES A
ST_MAN B
IT_PROG C
SA_REP D
ST_CLERK E
Autre 0
SELECT job_id, decode (job_id,

'ST_CLERK', 'E',
'SA_REP', 'D',
'IT_PROG', 'C',
'ST_MAN', 'B',
'AD_PRES', 'A',
'0')GRADE
FROM employees;
6. Réécrivez l'instruction de l'exercice précédent à l'aide de la syntaxe CASE.

SELECT job_id, CASE job_id
WHEN 'ST_CLERK' THEN 'E'
WHEN 'SA_REP' THEN 'D'
WHEN 'IT_PROG' THEN 'C'
WHEN 'ST_MAN' THEN 'B'
WHEN 'AD_PRES' THEN 'A'
ELSE '0' END GRADE
FROM employees;

Solutions de l'exercice 5 : Créer un état avec des données agrégées à l'aide
des fonctions de groupe
Indiquez la validité des trois affirmations ci-après. Entourez la réponse correcte.

1. Les fonctions de groupe opèrent sur plusieurs lignes et produisent un résultat par groupe.
Vrai/Faux
2. Les fonctions de groupe prennent en compte les valeurs NULL dans les calculs.
Vrai/Faux
3. La clause WHERE restreint les lignes avant inclusion dans un calcul de groupe.
Vrai/Faux
Le département des ressources humaines a besoin des états suivants :
4. Déterminez le salaire le plus élevé, le salaire le plus bas, le salaire cumulé et le salaire
moyen pour tous les employés. Intitulez respectivement les colonnes Maximum,

Minimum, Sum et Average. Arrondissez les résultats à l'entier le plus proche.
Enregistrez l'instruction SQL sous le nom lab_05_04.sql. Exécutez l'interrogation.
SELECT ROUND(MAX(salary),0) "Maximum",
ROUND(MIN(salary),0) "Minimum",
ROUND(SUM(salary),0) "Sum",
ROUND(AVG(salary),0) "Average"
FROM employees;
5. Modifiez l'interrogation enregistrée dans le fichier lab_05_04.sql afin d'afficher le

salaire minimum, le salaire maximum, le salaire cumulé et le salaire moyen pour chaque
type de poste. Enregistrez lab_05_04.sql sous le nom lab_05_05.sql. Exécutez
l'instruction figurant dans lab_05_05.sql.
SELECT job_id, ROUND(MAX(salary),0) "Maximum",
ROUND(MIN(salary),0) "Minimum",
ROUND(SUM(salary),0) "Sum",
ROUND(AVG(salary),0) "Average"
FROM employees
GROUP BY job_id;
6. Ecrivez une interrogation permettant d'afficher le nombre de personnes occupant le même

poste.
SELECT job_id, COUNT(*)
FROM employees
GROUP BY job_id;
Généralisez l'interrogation de sorte que l'utilisateur du département des ressources

humaines soit invité à indiquer un intitulé de poste. Enregistrez le script sous le nom de
fichier lab_05_06.sql. Exécutez l'interrogation. A l'invite, saisissez IT_PROG et
cliquez sur OK.
SELECT job_id, COUNT(*)
FROM employees
WHERE job_id = '&job_title'
GROUP BY job_id;

des fonctions de groupe (suite)
7. Déterminez le nombre de managers sans les répertorier. Intitulez la colonne Number of

Managers. Indice : Utilisez la colonne MANAGER_ID pour déterminer le nombre de
managers.
SELECT COUNT(DISTINCT manager_id) "Number of Managers"
FROM employees;
8. Trouvez la différence entre le salaire le plus élevé et le salaire le plus bas. Intitulez la
colonne DIFFERENCE.
SELECT MAX(salary) - MIN(salary) DIFFERENCE
FROM employees;

9. Créez un état permettant d'afficher le numéro de manager et le salaire de l'employé le
moins payé sous les ordres de ce manager. Excluez toute personne pour laquelle le
manager n'est pas connu. Excluez les groupes dans lesquels le salaire minimum est de
6 000 $ ou moins. Triez les résultats par ordre décroissant sur la base du salaire.
SELECT manager_id, MIN(salary)
FROM employees
WHERE manager_id IS NOT NULL
GROUP BY manager_id
HAVING MIN(salary) > 6000
ORDER BY MIN(salary) DESC;
suivants :
10. Créez une interrogation permettant d'afficher le nombre total d'employés et, pour ce total,
le nombre d'employés embauchés en 1995, 1996, 1997 et 1998. Créez les en-têtes de
colonne appropriés.
SELECT COUNT(*) total,
SUM(DECODE(TO_CHAR(hire_date, 'YYYY'),1995,1,0))"1995",
SUM(DECODE(TO_CHAR(hire_date, 'YYYY'),1998,1,0))"1998"
FROM employees;

des fonctions de groupe (suite)
11. Créez une interrogation de matrice permettant d'afficher le poste, le salaire correspondant
à ce poste sur la base du numéro de département et le salaire total correspondant à ce
poste, pour les départements 20, 50, 80 et 90, en intitulant chaque colonne de façon
appropriée.
SELECT job_id "Job",
SUM(DECODE(department_id , 20, salary)) "Dept 20",
SUM(salary) "Total"
FROM employees
GROUP BY job_id;

Solutions de l'exercice 6 : Afficher des données provenant de plusieurs tables
1. Ecrivez pour le département des ressources humaines une interrogation produisant

l'adresse de tous les départements. Utilisez les tables LOCATIONS et COUNTRIES.
Affichez dans les résultats l'ID de lieu, la rue, la ville, le département et le pays. Utilisez
une jointure naturelle (NATURAL JOIN) pour produire les résultats.
SELECT location_id, street_address, city, state_province, country_name
FROM locations
NATURAL JOIN countries;
2. Le département des ressources humaines a besoin d'un état de tous les employés. Ecrivez
une interrogation permettant d'afficher le nom, ainsi que le numéro et le nom de
département pour tous les employés.
SELECT last_name, department_id, department_name
FROM employees
JOIN departments

USING (department_id);
3. Le département des ressources humaines a besoin d'un état des employés de Toronto.
Affichez le nom, le poste, ainsi que le numéro et le nom de département, pour tous les
employés qui travaillent à Toronto.
SELECT e.last_name, e.job_id, e.department_id, d.department_name
JOIN locations l
ON (d.location_id = l.location_id)
WHERE LOWER(l.city) = 'toronto';
4. Créez un état permettant d'afficher le nom et l'ID des employés, ainsi que le nom et l'ID
de leur manager. Intitulez respectivement les colonnes Employee, Emp#, Manager et
Mgr#. Enregistrez l'instruction SQL sous le nom lab_06_04.sql. Exécutez
l'interrogation.
SELECT w.last_name "Employee", w.employee_id "EMP#",
m.last_name "Manager", m.employee_id "Mgr#"
FROM employees w join employees m
ON (w.manager_id = m.employee_id);
5. Modifiez lab_06_04.sql pour afficher tous les employés, y compris 'employé King
qui n'a pas de manager. Triez les résultats sur la base du numéro d'employé. Enregistrez
l'instruction SQL dans le fichier lab_06_05.sql. Exécutez l'instruction figurant dans
lab_06_05.sql.
FROM employees w
LEFT OUTER JOIN employees m
ON (w.manager_id = m.employee_id)
ORDER BY 2;

Solutions de l'exercice 6 : Afficher des données provenant de plusieurs tables
(suite)
6. Créez pour le département des ressources humaines un état affichant le nom et l'ID de
département de tous les employés qui travaillent dans le même département qu'un
employé donné. Attribuez à chaque colonne un libellé approprié. Enregistrez le script
dans le fichier lab_06_06.sql. Exécutez l'interrogation.
SELECT e.department_id department, e.last_name employee,
c.last_name colleague
FROM employees e JOIN employees c
ON (e.department_id = c.department_id)
WHERE e.employee_id <> c.employee_id
ORDER BY e.department_id, e.last_name, c.last_name;
7. Le département des ressources humaines a besoin d'un état sur les niveaux de poste et les
salaires. Pour vous familiariser avec la table JOB_GRADES, affichez d'abord sa structure.

Créez ensuite une interrogation affichant le nom, le poste, le nom de département, le
salaire et le niveau de tous les employés.
DESC JOB_GRADES
SELECT e.last_name, e.job_id, d.department_name,

e.salary, j.grade_level
JOIN job_grades j
ON (e.salary BETWEEN j.lowest_sal AND j.highest_sal);
suivants :
8. Le département des ressources humaines souhaite déterminer le nom de tous les employés
embauchés après Davies. Créez une interrogation permettant d'afficher le nom et la date
d'embauche de tous les employés embauchés après l'employé Davies.
SELECT e.last_name, e.hire_date
FROM employees e JOIN employees davies
ON (davies.last_name = 'Davies')
WHERE davies.hire_date < e.hire_date;
9. Le département des ressources humaines a besoin de connaître le nom et la date

d'embauche de tous les employés embauchés avant leur manager, ainsi que le nom et la
date d'embauche de ce dernier. Enregistrez le script dans le fichier lab_06_09.sql.
SELECT w.last_name, w.hire_date, m.last_name, m.hire_date
FROM employees w JOIN employees m
ON (w.manager_id = m.employee_id)
WHERE w.hire_date < m.hire_date;

Solutions de l'exercice 7 : Utiliser des sous-interrogations pour résoudre
des interrogations
1. Le département des ressources humaines a besoin d'une interrogation qui invite

l'utilisateur à indiquer un nom d'employé. L'interrogation affiche alors le nom et la date
d'embauche de tous les employés travaillant dans le même département que l'employé
indiqué (en excluant ce dernier). Par exemple, si l'utilisateur saisit Zlotkey, cherchez
tous les employés qui travaillent avec Zlotkey (en excluant Zlotkey).
UNDEFINE Enter_name
SELECT last_name, hire_date

FROM employees
WHERE department_id = (SELECT department_id
FROM employees
WHERE last_name = '&&Enter_name')
AND last_name <> '&Enter_name';

2. Créez un état qui affiche le numéro d'employé, le nom et le salaire de tous les employés
qui gagnent plus que le salaire moyen. Triez les résultats par ordre croissant sur la base du
salaire.
SELECT employee_id, last_name, salary
FROM employees
WHERE salary > (SELECT AVG(salary)
FROM employees)
ORDER BY salary;
3. Ecrivez une interrogation qui affiche le numéro d'employé et le nom de tous les employés
qui travaillent dans un département comprenant un employé dont le nom contient la lettre
"u". Enregistrez l'instruction SQL sous le nom lab_07_03.sql. Exécutez votre
interrogation.
SELECT employee_id, last_name
FROM employees
WHERE department_id IN (SELECT department_id
FROM employees
WHERE last_name like '%u%');
4. Le département des ressources humaines a besoin d'un état qui affiche le nom, le numéro de
département et l'ID de poste de tous les employés dont l'ID de lieu de département est 1700.
SELECT last_name, department_id, job_id
FROM employees
FROM departments
WHERE location_id = 1700);
Modifiez l'interrogation de sorte que l'utilisateur soit invité à indiquer un ID de lieu.

Enregistrez-la dans le fichier lab_07_04.sql.
SELECT last_name, department_id, job_id
FROM employees
FROM departments
WHERE location_id = &Enter_location);

Solutions de l'exercice 7 : Utiliser des sous-interrogations pour résoudre
des interrogations (suite)
5. Créez pour les ressources humaines un état affichant le nom et le salaire de tous les
employés dont le manager est King.
FROM employees
WHERE manager_id = (SELECT employee_id
FROM employees
WHERE last_name = 'King');
6. Créez pour les ressources humaines un état affichant l'ID de département, le nom et l'ID
de poste de tous les employés du département Executive.
SELECT department_id, last_name, job_id
FROM employees

FROM departments
WHERE department_name = 'Executive');
7. Modifiez l'interrogation lab_07_03.sql pour afficher le numéro d'employé, le nom et

le salaire de tous les employés qui gagnent plus que le salaire moyen et qui travaillent
dans un département comprenant un employé dont le nom contient la lettre "u".
Enregistrez lab_07_03.sql sous le nom lab_07_07.sql. Exécutez l'instruction
figurant dans lab_07_07.sql.
SELECT employee_id, last_name, salary
FROM employees
FROM employees
WHERE last_name like '%u%')
AND salary > (SELECT AVG(salary)
FROM employees);

Solutions de l'exercice 8 : Utiliser des opérateurs ensemblistes
1. Le département des ressources humaines a besoin de la liste des ID des départements qui
ne contiennent pas l'ID de poste ST_CLERK. Utilisez les opérateurs ensemblistes pour
créer cet état.
SELECT department_id
FROM departments
MINUS
SELECT department_id
FROM employees
WHERE job_id = 'ST_CLERK';
2. Le département des ressources humaines a besoin de la liste des pays dans lesquels il
n'existe aucun département. Affichez l'ID et le nom des pays. Utilisez les opérateurs
ensemblistes pour créer cet état.
SELECT country_id,country_name

FROM countries
MINUS
SELECT l.country_id,c.country_name
FROM locations l JOIN countries c
ON (l.country_id = c.country_id)
JOIN departments d
ON d.location_id=l.location_id;
3. Produisez la liste des postes des départements 10, 50 et 20, dans cet ordre. Affichez l'ID
de poste et l'ID de département à l'aide des opérateurs ensemblistes.
SELECT distinct job_id, department_id
FROM employees
UNION ALL
SELECT DISTINCT job_id, department_id
FROM employees
UNION ALL
SELECT DISTINCT job_id, department_id
FROM employees

Solutions de l'exercice 8 : Utiliser des opérateurs ensemblistes (suite)
4. Créez un état répertoriant l'ID d'employé et l'ID de poste des employés dont l'intitulé de
poste actuel est identique à l'intitulé de poste initial lors de leur embauche par l'entreprise.
(Ces employés ont changé de poste, puis sont revenus à leur poste d'origine.)
SELECT employee_id,job_id
FROM employees
INTERSECT
SELECT employee_id,job_id
FROM job_history;
5. Le département des ressources humaines a besoin d'un état avec les spécifications
suivantes :
• Nom et ID de département de tous les employés de la table EMPLOYEES, qu'ils
appartiennent ou non à un département

• ID et nom de tous les départements de la table DEPARTMENTS, qu'ils comptent des
employés ou non
Pour ce faire, écrivez une interrogation composée.

SELECT last_name,department_id,TO_CHAR(null)
FROM employees
UNION
SELECT TO_CHAR(null),department_id,department_name
FROM departments;

Solutions de l'exercice 9 : Manipuler des données
Le département des ressources humaines a besoin d'instructions SQL permettant d'insérer, de

mettre à jour et de supprimer des données relatives aux employés. Vous allez tester ces
instructions sur la table MY_EMPLOYEE avant de les livrer.
Remarque : Pour exécuter une interrogation comprenant des instructions LMD, utilisez
l'icône Run Script (ou appuyez sur [F5]). Vous pouvez ainsi voir les messages renvoyés dans
l'onglet Script Output. Pour les interrogations SELECT, continuez à utiliser l'icône Execute
Statement ou à appuyer sur [F9] pour obtenir le résultat mis en forme dans l'onglet Results.
Insérez des données dans la table MY_EMPLOYEE.
1. Exécutez l'instruction du script lab_09_01.sql pour construire la table

MY_EMPLOYEE utilisée dans cet exercice.
a. Dans le menu File, sélectionnez Open. Dans la boîte de dialogue Open, accédez au

dossier D:\labs\sql1\labs, puis cliquez deux fois sur lab_09_01.sql.
b. Une fois l'instruction ouverte dans une feuille SQL Worksheet, cliquez sur l'icône
Run Script pour exécuter le script. Vous obtenez le message Create Table
succeeeded dans l'onglet Script Output.
2. Affichez la structure de cette table afin d'identifier les noms de colonne.

DESCRIBE my_employee
3. Créez une instruction INSERT permettant d'ajouter à la table MY_EMPLOYEE la

première ligne de données du tableau ci-après. N'énumérez pas les colonnes dans la
clause INSERT.
1 Patel Ralph rpatel 895
2 Dancs Betty bdancs 860
3 Biri Ben bbiri 1100
4 Newman Chad cnewman 750
5 Ropeburn Audrey aropebur 1550
INSERT INTO my_employee

VALUES (1, 'Patel', 'Ralph', 'rpatel', 895);

Solutions de l'exercice 9 : Manipuler des données (suite)
4. Insérez dans la table MY_EMPLOYEE la deuxième ligne de données du tableau qui

précède. Cette fois, énumérez les colonnes de façon explicite dans la clause INSERT.
INSERT INTO my_employee (id, last_name, first_name,
userid, salary)
VALUES (2, 'Dancs', 'Betty', 'bdancs', 860);

SELECT *
FROM my_employee;
6. Ecrivez dans un fichier script réutilisable et dynamique une instruction INSERT

permettant de charger les lignes restantes dans la table MY_EMPLOYEE. Le script doit
appeler toutes les colonnes (ID, LAST_NAME, FIRST_NAME, USERID et SALARY).

Enregistrez ce script sous le nom lab_09_06.sql.
VALUES (&p_id, '&p_last_name', '&p_first_name',
'&p_userid', &p_salary);
7. Insérez dans la table les deux lignes suivantes du tableau de données fourni à l'étape 3 en
exécutant l'instruction INSERT du script que vous avez créé.

SELECT *
FROM my_employee;
9. Rendez définitifs les ajouts de données.

COMMIT;

Mettez à jour et supprimez des données dans la table MY_EMPLOYEE.
10. Remplacez le nom de l'employé 3 par Drexler.

UPDATE my_employee
SET last_name = 'Drexler'
WHERE id = 3;
11. Remplacez par 1 000 $ le salaire de tous les employés qui ont un salaire inférieur à 900 $.
UPDATE my_employee
SET salary = 1000
WHERE salary < 900;

SELECT *
FROM my_employee;
13. Supprimez Betty Dancs de la table MY_EMPLOYEE.

DELETE
FROM my_employee
WHERE last_name = 'Dancs';

SELECT *
FROM my_employee;
15. Validez (commit) toutes les modifications en attente.

COMMIT;
Contrôlez les transactions de données appliquées à la table MY_EMPLOYEE.
16. Insérez dans la table la dernière ligne du tableau de données fourni à l'étape 3, à l'aide des
instructions du script créé à l'étape 6. Exécutez ces instructions.


SELECT *
FROM my_employee;
18. Marquez un point intermédiaire dans le traitement de la transaction.

SAVEPOINT step_17;
19. Supprimez toutes les lignes de la table MY_EMPLOYEE.

DELETE
FROM my_employee;
20. Vérifiez que la table a bien été vidée.

SELECT *
FROM my_employee;
21. Annulez l'opération DELETE la plus récente, mais pas l'opération INSERT précédente.
ROLLBACK TO step_17;
22. Vérifiez que la nouvelle ligne est toujours intacte.

SELECT *
FROM my_employee;
23. Rendez définitif l'ajout de données.

COMMIT;
24. Modifiez le script lab_09_06.sql de sorte que la valeur USERID soit générée
automatiquement par concaténation de la première lettre du prénom et des sept premiers
caractères du nom. La valeur USERID doit être générée en minuscules. Ainsi, le script
n'invitera pas à saisir cette valeur. Enregistrez le script sous le nom lab_09_24.sql.
SET ECHO OFF
SET VERIFY OFF
VALUES (&p_id, '&&p_last_name', '&&p_first_name',
lower(substr('&p_first_name', 1, 1) ||
substr('&p_last_name', 1, 7)), &p_salary);
SET VERIFY ON
SET ECHO ON
UNDEFINE p_first_name
UNDEFINE p_last_name

25. Exécutez le script lab_09_24.sql afin d'insérer l'enregistrement suivant :

6 Anthony Mark manthony 1230
26. Vérifiez que la nouvelle ligne a été ajoutée avec le USERID correct.
SELECT *
FROM my_employee
WHERE ID='6';

Solutions de l'exercice 10 : Utiliser des instructions LDD pour créer et gérer
des tables
Remarque : Pour exécuter une interrogation comprenant des instructions LDD et LMD,
cliquez sur l'icône Run Script (ou appuyez sur [F5]). Vous pouvez ainsi voir les messages
renvoyés dans l'onglet Script Output. Pour les interrogations SELECT, continuez à utiliser
l'icône Execute Statement ou à appuyer sur [F9] pour obtenir le résultat mis en forme dans
l'onglet Results.
1. Créez la table DEPT conformément aux indications du tableau ci-après. Enregistrez

l'instruction dans un script nommé lab_10_01.sql, puis exécutez ce script pour créer
la table. Vérifiez que la table a bien été créée.
CREATE TABLE dept
(id NUMBER(7)CONSTRAINT department_id_pk PRIMARY KEY,
name VARCHAR2(25));

a. Pour vérifier que la table a été créée et pour afficher sa structure, exécutez la
commande suivante :
DESCRIBE dept
2. Remplissez la table DEPT avec les données de la table DEPARTMENTS. Incluez

uniquement les colonnes dont vous avez besoin.
INSERT INTO dept
SELECT department_id, department_name
FROM departments;
3. Créez la table EMP conformément aux indications du tableau ci-après. Enregistrez

l'instruction dans un script nommé lab_10_03.sql, puis exécutez ce script pour créer
la table. Vérifiez que la table a bien été créée.
CREATE TABLE emp
(id NUMBER(7),
last_name VARCHAR2(25),
dept_id NUMBER(7)
CONSTRAINT emp_dept_id_FK REFERENCES dept (id)
);
a. Pour vérifier que la table a été créée et pour afficher sa structure, exécutez la
commande suivante :
DESCRIBE emp
4. Créez la table EMPLOYEES2 en utilisant la structure de la table EMPLOYEES. Incluez

uniquement les colonnes EMPLOYEE_ID, FIRST_NAME, LAST_NAME, SALARY et
DEPARTMENT_ID. Intitulez les colonnes de la nouvelle table respectivement ID,
FIRST_NAME, LAST_NAME, SALARY et DEPT_ID.
CREATE TABLE employees2 AS
SELECT employee_id id, first_name, last_name, salary,
department_id dept_id
FROM employees;

Solutions de l'exercice 10 : Utiliser des instructions LDD pour créer et gérer
des tables (suite)
5. Placez la table EMPLOYEES2 en mode lecture seule.

ALTER TABLE employees2 READ ONLY
6. Essayez d'insérer la ligne ci-après dans la table EMPLOYEES2.
a. Vous obtiendrez le message d'erreur "Update operation not allowed on table".

Vous ne pourrez insérer aucune ligne dans la table car celle-ci est en mode
lecture seule.
INSERT INTO employees2
VALUES (34, 'Grant','Marcie',5678,10)
7. Remettez la table EMPLOYEES2 en mode lecture-écriture. Essayez à nouveau d'insérer la

même ligne.

a. La table ayant maintenant le statut READ WRITE, vous êtes autorisé à y
insérer une ligne.
ALTER TABLE employees2 READ WRITE
INSERT INTO employees2

VALUES (34, 'Grant','Marcie',5678,10)
8. Supprimez la table EMPLOYEES2.
a. Remarque : Vous pouvez supprimer une table qui est en mode READ ONLY.
Pour le vérifier, attribuez à nouveau le statut READ ONLY à la table, puis
exécutez la commande DROP TABLE. La table EMPLOYEES2 est supprimée.
DROP TABLE employees2;

Solutions de l'exercice 11 : Créer d'autres objets de schéma
Première partie
1. Le département des ressources humaines souhaite masquer certaines des données de la

table EMPLOYEES. Il souhaite obtenir une vue nommée EMPLOYEES_VU, comprenant
les ID et les noms d'employé ainsi que les ID de département de la table EMPLOYEES.
L'en-tête EMPLOYEE doit être attribué à la colonne contenant les noms d'employé.
CREATE OR REPLACE VIEW employees_vu AS
SELECT employee_id, last_name employee, department_id
FROM employees;
2. Vérifiez que la vue fonctionne. Affichez le contenu de la vue EMPLOYEES_VU.

SELECT *
FROM employees_vu;

3. A l'aide de la vue EMPLOYEES_VU, écrivez pour le département des ressources
humaines une interrogation permettant d'afficher les noms d'employé et les ID de
département correspondants.
SELECT employee, department_id
FROM employees_vu;
4. Le département 50 a besoin d'accéder aux données concernant ses employés. Créez une
vue nommée DEPT50 contenant l'ID d'employé, le nom et l'ID de département de tous les
employés du département 50. Vous devez intituler les colonnes de la vue EMPNO,
EMPLOYEE et DEPTNO. Pour des raisons de sécurité, n'autorisez pas le transfert d'un
employé vers un autre département par l'intermédiaire de la vue.
CREATE VIEW dept50 AS
SELECT employee_id empno, last_name employee,

department_id deptno
FROM employees
WITH CHECK OPTION CONSTRAINT emp_dept_50;
5. Affichez la structure et le contenu de la vue DEPT50.

DESCRIBE dept50
SELECT *
FROM dept50;
6. Testez la vue. Tentez de transférer Matos vers le département 80.

UPDATE dept50
SET deptno = 80
WHERE employee = 'Matos';
L'erreur est due au fait que la vue DEPT50 a été créée avec la contrainte WITH CHECK
OPTION. La colonne DEPTNO de la vue est ainsi protégée contre toute modification.

Solutions de l'exercice 11 : Créer d'autres objets de schéma (suite)
Deuxième partie
7. Vous avez besoin d'une séquence pouvant être utilisée avec la colonne PRIMARY KEY
de la table DEPT. La séquence doit commencer à 200 et présenter une valeur maximum
de 1 000. Elle doit croître par incréments de 10. Intitulez la séquence DEPT_ID_SEQ.
CREATE SEQUENCE dept_id_seq

START WITH 200
INCREMENT BY 10
MAXVALUE 1000;
8. Pour tester la séquence, écrivez un script permettant d'insérer deux lignes dans la table
DEPT. Nommez le script lab_11_08.sql. Veillez à utiliser la séquence que vous avez
créée pour la colonne ID. Ajoutez deux départements : Education et Administration.
Vérifiez vos ajouts. Exécutez les commandes dans le script.

INSERT INTO dept
VALUES (dept_id_seq.nextval, 'Education');
INSERT INTO dept

VALUES (dept_id_seq.nextval, 'Administration');
9. Créez un index non unique sur la colonne NAME de la table DEPT.

CREATE INDEX dept_name_idx ON dept (name);
10. Créez un synonyme pour la table EMPLOYEES. Nommez-le EMP.

CREATE SYNONYM emp FOR EMPLOYEES;

Solutions de l'exercice C : Syntaxe de jointure Oracle

Affichez dans les résultats l'ID de lieu, la rue, la ville, le département et le pays.
Exécutez l'interrogation.
SELECT location_id, street_address, city, state_province, country_name
FROM locations, countries
WHERE locations.country_id = countries.country_id;
2. Le département des ressources humaines a besoin d'un état de tous les employés. Ecrivez
une interrogation permettant d'afficher le nom, ainsi que le numéro et le nom de
département pour tous les employés. Exécutez l'interrogation.
SELECT e.last_name, e.department_id, d.department_name
FROM employees e, departments d
WHERE e.department_id = d.department_id;

Affichez le nom, le poste, ainsi que le numéro et le nom de department, pour tous les
SELECT e.last_name, e.job_id, e.department_id, d.department_name
FROM employees e, departments d , locations l
WHERE e.department_id = d.department_id
AND d.location_id = l.location_id
AND LOWER(l.city) = 'toronto';
4. Créez un état permettant d'afficher le nom et l'ID des employés, ainsi que le nom et l'ID
de leur manager. Intitulez respectivement les colonnes Employee, Emp#, Manager et
Mgr#. Enregistrez l'instruction SQL sous le nom lab_c_04.sql.
FROM employees w, employees m
WHERE w.manager_id = m.employee_id;
5. Modifiez lab_c_04.sql pour afficher tous les employés, y compris l'employé King
qui n'a pas de manager. Triez les résultats sur la base du numéro d'employé. Enregistrez
l'instruction SQL sous le nom lab_c_05.sql. Exécutez l'interrogation figurant dans
lab_c_05.sql.
FROM employees w, employees m
WHERE w.manager_id = m.employee_id (+);

Solutions de l'exercice C : Syntaxe de jointure Oracle (suite)
sous le nom lab_c_06.sql.
SELECT e1.department_id department, e1.last_name employee,
e2.last_name colleague
FROM employees e1, employees e2
WHERE e1.department_id = e2.department_id
AND e1.employee_id <> e2.employee_id
ORDER BY e1.department_id, e1.last_name, e2.last_name;
salaires. Pour vous familiariser avec la table JOB_GRADES, affichez d'abord sa structure.
Créez ensuite une interrogation affichant le nom, le poste, le nom de département, le

salaire et le niveau de tous les employés.
DESC JOB_GRADES
SELECT e.last_name, e.job_id, d.department_name,

e.salary, j.grade_level
FROM employees e, departments d, job_grades j
AND e.salary BETWEEN j.lowest_sal AND j.highest_sal;
suivants :
8. Le département des ressources humaines souhaite déterminer le nom de tous les employés
embauchés après Davies. Créez une interrogation permettant d'afficher le nom et la date
d'embauche de tous les employés embauchés après l'employé Davies.
SELECT e.last_name, e.hire_date
FROM employees e , employees davies
WHERE davies.last_name = 'Davies'
AND davies.hire_date < e.hire_date;

d'embauche de tous les employés embauchés avant leur manager, ainsi que le nom et la
date d'embauche de ce dernier. Enregistrez le script sous le nom lab_c_09.sql.
SELECT w.last_name, w.hire_date, m.last_name, m.hire_date
FROM employees w , employees m
WHERE w.manager_id = m.employee_id
AND w.hire_date < m.hire_date;



Description des tables

Description du schéma
Description globale
Les exemples de schémas Oracle Database utilisés dans le cadre du cours correspondent à
une entreprise qui gère les commandes de différents produits à un niveau international.
L'entreprise compte trois départements :
• Human Resources : Assure le suivi des informations concernant les employés et les
sites de l'entreprise.
• Order Entry : Gère les stocks des produits de l'entreprise, ainsi que les ventes à
travers différents canaux de distribution.
• Sales History : Assure le suivi des statistiques commerciales afin de faciliter la prise
de décisions.
Chacun de ces départements est représenté par un schéma. Dans le cadre du cours, vous
avez accès à tous les objets de tous les schémas. Toutefois, les exemples, les
démonstrations et les exercices utilisent essentiellement le schéma Human Resources

(HR).
Tous les scripts nécessaires à la création des exemples de schéma résident dans le dossier
$ORACLE_HOME/demo/schema/.
Schéma Human Resources (HR)
Il s'agit du schéma utilisé dans ce cours. Dans le schéma Human Resource (HR),
l'enregistrement de chaque employé comprend un numéro d'identification unique, une
adresse e-mail, un numéro d'identification de poste, un salaire et un manager. Certains
employés perçoivent des commissions en plus de leur salaire.
L'entreprise assure également le suivi des informations relatives aux différents postes.
A chaque poste sont associés un numéro d'identification, un intitulé et une fourchette de
salaires (minimum et maximum). Certains employés sont dans l'entreprise depuis
longtemps et ont occupé différents postes. Lorsqu'un employé quitte l'entreprise, les
informations suivantes sont enregistrées : durée pendant laquelle l'employé a travaillé dans
l'entreprise, poste occupé (numéro d'identification) et département.
Etant donné que l'entreprise comprend plusieurs sites à travers le monde, elle assure le suivi
des lieux géographiques où sont implantés ses entrepôts et ses départements. Chaque
employé est affecté à un département, lequel est identifié par un numéro unique ou un nom
abrégé. Chaque département est associé à un lieu géographique et chaque lieu
géographique est identifié par une adresse complète comprenant le nom et le numéro de la
voie, le code postal, la ville, l'état ou le département, ainsi que le code du pays.
Pour les pays où sont situés les départements et les entrepôts, l'entreprise enregistre des
détails tels que le nom du pays, le symbole et le nom de la devise,et la région géographique
dans laquelle est situé le pays.
Oracle Database 11g : Les fondamentaux du langage SQL (I) B - 2

Diagramme entité/relation HR
DEPARTMENTS LOCATIONS
department_name street_address
manager_id postal_code
location_id city
state_province
country_id
JOB_HISTORY
employee_id
end_date EMPLOYEES
job_id first_name
department_id last_name
email COUNTRIES
phone_number country_name

hire_date region_id
job_id
salary
JOBS commission_pct
job_id manager_id
job_title department_id
min_salary REGIONS
max_salary region_name

DESCRIBE countries
SELECT * FROM countries;

Description de la table Human Resources (HR)

SELECT * FROM departments;


. . .
DESCRIBE employees
SELECT * FROM employees;


DESCRIBE job_history
SELECT * FROM job_history


DESCRIBE jobs
SELECT * FROM jobs


DESCRIBE locations
SELECT * FROM locations


DESCRIBE regions
SELECT * FROM regions



Syntaxe de jointure Oracle

Objectifs
A la fin de cette annexe, vous pourrez :

• écrire des instructions SELECT pour accéder aux données
de plusieurs tables à l'aide d'équijointures
et de non-équijointures
• joindre une table à elle-même à l'aide d'une auto-jointure
• afficher les données qui ne répondent généralement
pas à une condition de jointure à l'aide de jointures externes
• générer le produit cartésien de toutes les lignes
de plusieurs tables

Objectifs
Dans ce chapitre, vous allez apprendre à obtenir des données à partir de plusieurs tables.
Une jointure permet d'afficher les informations de plusieurs tables. Vous pouvez donc
joindre plusieurs tables pour en afficher les informations.
Remarque : Pour plus d'informations sur les jointures, reportez-vous à la section "SQL
Queries and Subqueries: Joins" du manuel Oracle Database SQL Language Reference 11g,
Release 1 (11.1).
Oracle Database 11g : Les fondamentaux du langage SQL (I) C - 2

Obtenir des données à partir de plusieurs tables
EMPLOYEES DEPARTMENTS

…
Obtenir des données à partir de plusieurs tables

Il est parfois nécessaire d'utiliser des données provenant de plusieurs tables. Dans l'exemple
de la diapositive ci-dessus, l'état affiche des données provenant de deux tables distinctes :
• Les ID d'employé se trouvent dans la table EMPLOYEES.
• Les ID de département figurent dans les tables EMPLOYEES et DEPARTMENTS.
• Les noms de département se trouvent dans la table DEPARTMENTS.
Pour produire l'état, vous devez lier les tables EMPLOYEES et DEPARTMENTS, et accéder
aux données de chacune d'elles.

Produit cartésien
• Un produit cartésien est formé quand :

– une condition de jointure est omise
– une condition de jointure n'est pas valide
– toutes les lignes de la première table sont jointes
à toutes les lignes de la deuxième
• Pour éviter la formation d'un produit cartésien, incluez
toujours une condition de jointure valide dans une clause
WHERE.

Produit cartésien
Lorsqu'une condition de jointure n'est pas valide ou est complètement omise, un produit
cartésien est formé et toutes les combinaisons de lignes sont affichées. En d'autres termes,
toutes les lignes de la première table sont jointes à toutes les lignes de la deuxième.
Le produit cartésien génère souvent un grand nombre de lignes et le résultat est rarement
utile. Vous devez donc toujours inclure une condition de jointure valide sauf dans le cas
spécifique où vous avez besoin de combiner toutes les lignes de toutes les tables.
Toutefois, les produits cartésiens sont utiles pour certains tests lorsque vous avez besoin de
générer un grand nombre de lignes pour simuler une certaine quantité de données.

Générer un produit cartésien
EMPLOYEES (20 lignes) DEPARTMENTS (8 lignes)
Produit cartésien :

20 x 8 = 160 lignes
Générer un produit cartésien

Un produit cartésien est généré lorsqu'aucune condition de jointure n'est indiquée.
L'exemple de la diapositive ci-dessus affiche le nom d'employé et le nom de département à
partir des tables EMPLOYEES et DEPARTMENTS. Aucune condition de jointure n'ayant été
indiquée, toutes les lignes (20 lignes) de la table EMPLOYEES sont jointes à toutes les
lignes (8 lignes) de la table DEPARTMENTS, ce qui génère 160 lignes de résultat.
SELECT last_name, department_name dept_name
FROM employees, departments;

Types de jointure propriétaires Oracle
• Equijointure
• Non-équijointure
• Jointure externe
• Auto-jointure

Types de jointure
Pour joindre des tables, vous pouvez utiliser la syntaxe de jointure Oracle.
Remarque : Avant la version Oracle9i, la syntaxe de jointure était propriétaire. Du point
de vue des performances, la syntaxe de jointure conforme à la norme SQL:1999 n'est pas
supérieure à la syntaxe propriétaire d'Oracle.
Oracle ne dispose pas de syntaxe équivalente pour la prise en charge totale de la jointure
FULL OUTER JOIN de la syntaxe SQL:1999.

Joindre des tables à l'aide
de la syntaxe Oracle
Utilisez une jointure pour effectuer une interrogation
de données à partir de plusieurs tables :
SELECT table1.column, table2.column

FROM table1, table2
WHERE table1.column1 = table2.column2;
• Ecrivez la condition de jointure dans la clause WHERE.

• Ajoutez au nom de la colonne un préfixe constitué

du nom de la table lorsque le même nom de colonne
apparaît dans plusieurs tables.
Joindre des tables à l'aide de la syntaxe Oracle

Lorsque des données de plusieurs tables de la base sont requises, une condition de jointure
est utilisée. Les lignes d'une table peuvent être jointes aux lignes d'une autre table en
fonction de valeurs communes présentes dans les colonnes correspondantes (généralement
les colonnes de clé primaire et étrangère).
Pour afficher les données de plusieurs tables associées, écrivez une condition de jointure
simple dans la clause WHERE.
Dans la syntaxe :
table1.column Indique la table et la colonne à partir desquelles les données
sont extraites.
table1.column1 = Est la condition qui joint (ou associe) les tables entre elles.
table2.column2
Règles
• Lorsque vous écrivez une instruction SELECT pour joindre des tables, faites précéder
le nom de la colonne du nom de la table à des fins de clarté et pour améliorer l'accès à
la base de données.
• Si le même nom de colonne apparaît dans plusieurs tables, ajoutez au nom de la
colonne un préfixe constitué du nom de la table.
• Pour joindre n tables entre elles, vous devez utiliser un minimum de n-1 conditions
de jointure. Par exemple, pour joindre quatre tables, un minimum de trois jointures est
nécessaire. Cette règle ne s'applique pas si votre table comporte une clé primaire
concaténée, auquel cas plusieurs colonnes sont requises pour identifier chaque ligne de
façon unique.

Qualifier les noms de colonne ambigus
• Utilisez des préfixes de table pour qualifier le nom

des colonnes qui se trouvent dans plusieurs tables.
• Utilisez des préfixes de table pour améliorer les
performances.
• Remplacez les préfixes de nom de table complets
par des alias de table.
• Les alias de table permettent d'attribuer
des noms plus courts aux tables :
– Code SQL plus compact, utilisation de moins de mémoire

• Utilisez des alias de colonne pour distinguer les colonnes
portant des noms identiques mais résidant dans des tables
différentes.
Qualifier les noms de colonne ambigus

Lors de la jointure de plusieurs tables, vous devez qualifier les noms de colonne avec le nom
de la table pour éviter toute ambiguïté. Sans les préfixes de table, la colonne
DEPARTMENT_ID de la liste SELECT peut aussi bien appartenir à la table DEPARTMENTS
qu'à la table EMPLOYEES. Il est donc nécessaire d'ajouter le préfixe de table pour exécuter
l'interrogation. Si les deux tables n'ont aucun nom de colonne en commun, il n'est pas
nécessaire de qualifier les colonnes. Cependant, l'utilisation d'un préfixe de table améliore les
performances, car vous indiquez exactement au serveur Oracle où trouver les colonnes.
Le fait de qualifier les noms de colonne à l'aide de noms de table peut prendre beaucoup de
temps, en particulier si les noms de table sont longs. Vous pouvez donc dans ce cas
remplacer les noms de table par des alias de table. De la même façon qu'un alias de colonne
attribue un autre nom à une colonne, un alias de table attribue un autre nom à une table. Les
alias de table contribuent à raccourcir le code SQL, ce qui utilise moins de mémoire.
Le nom complet de la table est indiqué, suivi d'un espace et de l'alias de la table. Par
exemple, la table EMPLOYEES peut se voir attribuer l'alias e et la table DEPARTMENTS
l'alias d.
Règles
• Les alias de table peuvent comporter jusqu'à 30 caractères, mais il est préférable qu'ils
soient courts.
• Si un alias de table est utilisé pour un nom de table particulier dans la clause FROM, il
doit remplacer le nom de la table dans toute l'instruction SELECT.
• Les alias de table doivent être significatifs.
• Un alias de table n'est valide que pour l'instruction SELECT en cours.
Equijointures
EMPLOYEES DEPARTMENTS

Clé primaire
Clé étrangère
Equijointures
Pour déterminer le nom du département d'un employé, vous comparez la valeur figurant
dans la colonne DEPARTMENT_ID de la table EMPLOYEES avec les valeurs
DEPARTMENT_ID de la table DEPARTMENTS. La relation entre les tables EMPLOYEES
et DEPARTMENTS est une équijointure, ce qui signifie que les valeurs figurant dans la
colonne DEPARTMENT_ID doivent être identiques dans les deux tables. Ce type de
jointure implique souvent des clés primaires et étrangères.
Remarque : Les équijointures sont aussi appelées jointures simples ou jointures internes.

Extraire des enregistrements à l'aide
d'équijointures
SELECT e.employee_id, e.last_name, e.department_id,

d.department_id, d.location_id
WHERE e.department_id = d.department_id;

…
Extraire des enregistrements à l'aide d'équijointures

Dans l'exemple de la diapositive ci-dessus :
• La clause SELECT indique le nom des colonnes à extraire :
- Nom d'employé, ID d'employé et ID de département, qui sont des colonnes de la
table EMPLOYEES.
- ID de département, nom de département et ID de lieu, qui sont des colonnes de la
table DEPARTMENTS.
• La clause FROM indique les deux tables auxquelles la base de données doit
accéder :
- Table EMPLOYEES
- Table DEPARTMENTS
• La clause WHERE indique la façon dont les tables doivent être jointes :
e.department_id = d.department_id
Etant donné que la colonne DEPARTMENT_ID est commune aux deux tables, il est
nécessaire de lui adjoindre l'alias de la table comme préfixe afin d'éviter toute ambiguïté. Il
n'est pas nécessaire de qualifier par un alias de table les autres colonnes qui ne sont pas
présentes dans les deux tables, mais cela est recommandé pour des raisons de
performances.
Remarque : SQL Developer ajoute le suffixe "_1" pour faire la différence entre les deux
colonnes DEPARTMENT_ID.

Extraire des enregistrements à l'aide
d'équijointures : Exemple
SELECT d.department_id, d.department_name,

d.location_id, l.city
FROM departments d, locations l
WHERE d.location_id = l.location_id;

Extraire des enregistrements à l'aide d'équijointures : Exemple

Dans l'exemple de la diapositive ci-dessus, la table LOCATIONS est jointe à la table
DEPARTMENTS par la colonne LOCATION_ID, qui est la seule colonne figurant dans les
deux tables. Des alias de table sont utilisés pour qualifier les colonnes et éviter toute
ambiguïté.

Conditions de recherche supplémentaires
à l'aide de l'opérateur AND
SELECT d.department_id, d.department_name, l.city

FROM departments d, locations l
WHERE d.location_id = l.location_id
AND d.department_id IN (20, 50);

Conditions de recherche supplémentaires à l'aide de l'opérateur AND

Outre la jointure, la clause WHERE peut comprendre des critères permettant de restreindre
les lignes en prenant en compte une ou plusieurs tables de la jointure. L'exemple de la
diapositive ci-dessus limite le résultat aux lignes dont l'ID de département est égal à 20 ou à
50.
Par exemple, pour afficher l'ID de département et le nom de département de l'employé
Matos, vous avez besoin d'une condition supplémentaire dans la clause WHERE.
SELECT e.last_name, e.department_id,
d.department_name
AND last_name = 'Matos';

Joindre plus de deux tables
EMPLOYEES DEPARTMENTS LOCATIONS

…
Pour joindre n tables entre elles, vous devez
utiliser un minimum de n–1 conditions de
jointure. Par exemple, pour joindre trois tables,
un minimum de deux jointures est nécessaire.
Joindre plus de deux tables

Il s'avère parfois nécessaire de joindre plus de deux tables. Par exemple, pour afficher le
nom, le nom de département et la ville pour chaque employé, vous devez joindre les tables
EMPLOYEES, DEPARTMENTS et LOCATIONS.
SELECT e.last_name, d.department_name, l.city
FROM employees e, departments d, locations l
AND d.location_id = l.location_id;

Non-équijointures
EMPLOYEES JOB_GRADES
La table JOB_GRADES définit la plage

… de valeurs LOWEST_SAL et HIGHEST_SAL
pour chaque valeur GRADE_LEVEL.
La colonne GRADE_LEVEL peut donc être
utilisée pour attribuer un niveau à
chaque employé.
Non-équijointures
Une non-équijointure est une condition de jointure contenant autre chose qu'un opérateur
d'égalité.
La relation entre les tables EMPLOYEES et JOB_GRADES est un exemple de non-
équijointure. La plage de valeurs de la colonne SALARY de la table EMPLOYEES est
comprise entre les valeurs des colonnes LOWEST_SAL et HIGHEST_SAL de la table
JOB_GRADES. Chaque employé peut donc se voir attribuer un niveau en fonction de son
salaire. La relation est obtenue à l'aide d'un opérateur autre que l'opérateur d'égalité (=).

Extraire des enregistrements
à l'aide de non-équijointures
SELECT e.last_name, e.salary, j.grade_level

FROM employees e, job_grades j
WHERE e.salary
BETWEEN j.lowest_sal AND j.highest_sal;

…
Extraire des enregistrements à l'aide de non-équijointures

L'exemple de la diapositive ci-dessus crée une non-équijointure afin d'évaluer le niveau de
salaire d'un employé. Le salaire doit être compris entre la valeur inférieure et la valeur
supérieure de n'importe quelle plage de salaires.
Il est important de remarquer que chaque employé apparaît une seule fois lors de
l'exécution de cette interrogation. Aucun employé ne figure en double dans la liste.
Ce, pour deux raisons :
• Aucune ligne de la table des niveaux de poste ne contient des niveaux qui se
chevauchent. Cela signifie que la valeur du salaire d'un employé ne peut se trouver
qu'entre la valeur inférieure et la valeur supérieure d'une ligne de la table des niveaux
de salaire.
• Le salaire de tous les employés se situe dans les limites de cette table. Cela signifie
qu'aucun employé ne gagne moins que la valeur la plus faible de la colonne
LOWEST_SAL ou plus que la valeur la plus élevée de la colonne HIGHEST_SAL.
Remarque : D'autres conditions (telles que <= et >=) peuvent être utilisées, mais
BETWEEN est la plus simple. Veillez à bien préciser la valeur inférieure en premier et la
valeur supérieure en dernier lors de l'utilisation de la condition BETWEEN. Le serveur
Oracle convertit la condition BETWEEN en une paire de conditions AND. La condition
BETWEEN ne présente aucun avantage en termes de performances. Elle sert uniquement à
simplifier la formulation logique.
Dans l'exemple de la diapositive, les alias de table ont été utilisés pour des raisons de
performances et non en raison d'une possible ambiguïté.

Renvoyer des enregistrements
sans correspondance directe à l'aide

de jointures externes
DEPARTMENTS EMPLOYEES

…
Le département 190 ne comporte

aucun employé.
Renvoyer des enregistrements sans correspondance directe à l'aide de

jointures externes
Si une ligne ne satisfait pas à une condition de jointure, elle n'apparaît pas dans le résultat
de l'interrogation. Par exemple, dans la condition d'équijointure des tables EMPLOYEES et
DEPARTMENTS, l'ID de département 190 n'apparaît pas car aucun employé doté de cet ID
de département n'est enregistré dans la table EMPLOYEES. Par ailleurs, il existe un
employé dont la valeur de DEPARTMENT_ID est NULL. Cette ligne n'apparaît donc pas
dans le résultat d'interrogation d'une équijointure. Pour renvoyer l'enregistrement de
département qui n'est associé à aucun employé ou l'enregistrement d'employé qui
n'appartient à aucun département, vous pouvez utiliser la jointure externe.

Jointures externes : Syntaxe
• Vous pouvez utiliser une jointure externe pour afficher les

lignes qui ne répondent pas à la condition de jointure.
• L'opérateur de jointure externe est le signe plus (+).

FROM table1, table2
WHERE table1.column(+) = table2.column;

FROM table1, table2
WHERE table1.column = table2.column(+);
Jointures externes : Syntaxe

Les lignes manquantes peuvent être renvoyées si un opérateur de jointure externe est utilisé
dans la condition de jointure. L'opérateur est un signe plus entre parenthèses (+) placé à
côté de la jointure dont les informations sont manquantes. Cet opérateur crée une ou
plusieurs lignes NULL, auxquelles peuvent être jointes une ou plusieurs lignes de la table
ne comportant aucune information manquante.
Dans la syntaxe :
table1.column = Est la condition qui joint (ou associe) les tables entre elles.
table2.column (+) Est le symbole de jointure externe, qui peut être placé d'un côté
ou de l'autre de la condition de la clause WHERE, mais pas des
deux côtés. (Le symbole de jointure externe doit suivre le nom
de la colonne dans la table dont les lignes sont manquantes.)

Utiliser des jointures externes

WHERE e.department_id(+) = d.department_id ;

…
Utiliser des jointures externes

L'exemple de la diapositive ci-dessus affiche le nom de chaque employé, suivi de l'ID et du
nom du département correspondant. Le département Contracting ne compte aucun
employé. La valeur vide apparaît dans le résultat.
Restrictions de la jointure externe
• L'opérateur de jointure externe ne peut apparaître que d'un seul côté de l'expression, à
savoir celui où les informations sont manquantes. Il renvoie les lignes d'une table qui
ne présentent aucune correspondance directe dans l'autre table.
• Une condition impliquant une jointure externe ne peut pas utiliser l'opérateur IN ou
être liée à une autre condition par l'opérateur OR.
Remarque : La syntaxe de jointure Oracle ne présente aucun équivalent pour la jointure
FULL OUTER JOIN de la syntaxe de jointure compatible avec la norme SQL:1999.

Jointure externe : Autre exemple

WHERE e.department_id = d.department_id(+) ;

Jointure externe : Autre exemple

L'interrogation de l'exemple ci-dessus extrait toutes les lignes de la table EMPLOYEES,
même s'il n'y a aucune correspondance dans la table DEPARTMENTS.

Joindre une table à elle-même
EMPLOYEES (WORKER) EMPLOYEES (MANAGER)

… …
La colonne MANAGER_ID de la table WORKER est égale

à la colonne EMPLOYEE_ID de la table MANAGER.
Joindre une table à elle-même

Il est parfois nécessaire de joindre une table à elle-même. Pour trouver le nom du manager
de chaque employé, vous devez joindre la table EMPLOYEES à elle-même ou effectuer une
auto-jointure. Par exemple, pour trouver le nom du manager de Lorentz, vous
devez effectuer les opérations suivantes :
• Trouver Lorentz dans la table EMPLOYEES en examinant la colonne LAST_NAME.
• Trouver le numéro de manager correspondant à Lorentz en examinant la colonne
MANAGER_ID. Le manager de Lorentz porte le numéro 103.
• Trouver le nom du manager associé à la valeur 103 de EMPLOYEE_ID en examinant
la colonne LAST_NAME. Hunold est associé au numéro d'employé 103. Il s'agit donc
du manager de Lorentz.
Dans ce processus, vous examinez deux fois la table. Vous l'examinez une première fois
pour trouver Lorentz dans la colonne LAST_NAME et la valeur 103 dans la colonne
MANAGER_ID. Vous l'examinez une deuxième fois pour chercher dans la colonne
EMPLOYEE_ID la valeur 103 et dans la colonne LAST_NAME la valeur Hunold.

Auto-jointure : Exemple
SELECT worker.last_name || ' works for '

|| manager.last_name
FROM employees worker, employees manager
WHERE worker.manager_id = manager.employee_id ;

…
Auto-jointure : Exemple
L'exemple de la diapositive ci-dessus joint la table EMPLOYEES à elle-même. Pour simuler
deux tables dans la clause FROM, il existe deux alias, à savoir worker et manager, pour la
même table EMPLOYEES.
Dans cet exemple, la clause WHERE contient la jointure qui signifie "où le numéro du
manager d'un employé correspond au numéro d'employé du manager".

Synthèse
Cette annexe vous a appris à utiliser des jointures pour afficher

des données provenant de plusieurs tables à l'aide de la
syntaxe propriétaire d'Oracle.

Synthèse
Il existe plusieurs façons de joindre des tables.
Types de jointure
• Produits cartésiens
• Equijointures
• Non-équijointures
• Jointures externes
• Auto-jointures
Produit cartésien
Un produit cartésien entraîne l'affichage de toutes les combinaisons de lignes. Il est généré
lorsque la clause WHERE est omise.
Alias de table
• Les alias de table accélèrent l'accès à la base de données.
• Les alias de table peuvent contribuer à raccourcir le code SQL, ce qui permet
d'économiser la mémoire.

Présentation de l'exercice C

• joindre des tables à l'aide d'une équijointure
• effectuer des jointures externes et des auto-jointures
• ajouter des conditions

Présentation de l'exercice C
Dans cet exercice, vous allez expérimenter l'extraction de données à partir de plusieurs
tables à l'aide de la syntaxe de jointure Oracle.

Exercice C
Affichez dans les résultats l'ID de lieu, la rue, la ville, le département et le pays.
Exécutez l'interrogation.
2. Le département des ressources humaines a besoin d'un état de tous les employés.

Ecrivez une interrogation permettant d'afficher le nom, ainsi que le numéro et le nom
de département pour tous les employés. Exécutez l'interrogation.

Exercice C (suite)
Affichez le nom, le poste, ainsi que le numéro et le nom de département, pour tous les
4. Créez un état permettant d'afficher le nom et l'ID des employés, ainsi que le nom et
l'ID de leur manager. Intitulez respectivement les colonnes Employee, Emp#,
Manager et Mgr#. Enregistrez l'instruction SQL sous le nom lab_c_04.sql.

…

Exercice C (suite)
5. Modifiez lab_c_04.sql pour afficher tous les employés, y compris l'employé
King qui n'a pas de manager. Triez les résultats sur la base du numéro d'employé.
Enregistrez l'instruction SQL sous le nom lab_c_05.sql. Exécutez l'interrogation
figurant dans lab_c_05.sql.

…
sous le nom lab_c_06.sql.
…
Exercice C (suite)
salaires. Pour vous familiariser avec la table JOB_GRADES, affichez d'abord sa
structure. Créez ensuite une interrogation affichant le nom, le poste, le nom de
département, le salaire et le niveau de tous les employés.

…

Exercice C (suite)
Pour mettre en pratique vos connaissances de façon plus approfondie, effectuez les
exercices suivants :
8. Le département des ressources humaines souhaite déterminer le nom de tous les
employés embauchés après Davies. Créez une interrogation permettant d'afficher le
nom et la date d'embauche de tous les employés embauchés après l'employé Davies.

d'embauche de tous les employés embauchés avant leur manager, ainsi que le nom et
la date d'embauche de ce dernier. Enregistrez le script sous le nom lab_c_09.sql.

Utiliser SQL*Plus

Objectifs

• vous connecter à SQL*Plus
• modifier des commandes SQL
• mettre en forme un résultat à l'aide de commandes
SQL*Plus
• interagir avec des fichiers script

Objectifs
Cette annexe montre comment créer des instructions SELECT réutilisables plusieurs fois.
Elle explique également comment utiliser les commandes SQL*Plus pour exécuter des
instructions SQL. Enfin, elle présente la mise en forme d'une sortie à l'aide de commandes
SQL*Plus, l'édition de commandes SQL et l'enregistrement de scripts dans SQL*Plus.
Oracle Database 11g : Les fondamentaux du langage SQL (I) D - 2

Interaction entre SQL et SQL*Plus
Instructions SQL
Serveur
SQL*Plus
Résultats d'interrogation
Tampon

Scripts SQL
SQL et SQL*Plus
SQL est un langage de commande qui permet de communiquer avec le serveur Oracle à
partir de n'importe quel outil ou application. Oracle SQL contient de nombreuses
extensions. Lorsque vous entrez une instruction SQL, elle est stockée dans une région de la
mémoire appelée tampon SQL (SQL Buffer) jusqu'à ce que vous entriez une nouvelle
instruction SQL. SQL*Plus est un outil Oracle qui reconnaît les instructions SQL et les
soumet à Oracle9i Server en vue de leur exécution. Il possède son propre langage de
commande.
Caractéristiques du langage SQL
• Il peut être utilisé par de nombreux utilisateurs, y compris ceux qui ne possèdent que
peu ou pas d'expérience en programmation.
• Ce n'est pas un langage procédural.
• Il réduit le temps nécessaire à la création et à la gestion des systèmes.
• Il s'agit d'un langage proche de l'anglais.
Caractéristiques de l'environnement SQL*Plus
• Il accepte la saisie ad hoc d'instructions.
• Il accepte en entrée des instructions SQL stockées dans un fichier.
• Il fournit un éditeur de ligne permettant la modification d'instructions SQL.
• Il contrôle les paramètres d'environnement.
• Il met en forme les résultats des interrogations de manière à générer des états de base.
• Il permet d'accéder à des bases de données locales et distantes.

Différences entre les instructions SQL
et les commandes SQL*Plus

SQL SQL*Plus
• Il s'agit d'un langage. • Il s'agit d'un environnement.
• Il est conforme à la norme • Il s'agit d'un outil propriétaire
ANSI. d'Oracle.
• Les mots-clés ne peuvent • Les mots-clés peuvent être
pas être abrégés. abrégés.
• Les instructions manipulent • Les commandes ne
des données et des permettent pas de
définitions de table manipulation de valeurs

dans la base de données. dans la base de données.
Instructions Tampon Commandes Tampon

SQL SQL SQL*Plus SQL*Plus
SQL et SQL*Plus (suite)

Le tableau suivant compare SQL et SQL*Plus :
SQL SQL*Plus
Il s'agit d'un langage permettant de Il reconnaît les instructions SQL et les
communiquer avec le serveur Oracle pour envoie au serveur.
accéder aux données.
Il est basé sur la norme SQL définie par Il s'agit de l'interface propriétaire d'Oracle
l'ANSI (American National Standards qui permet l'exécution d'instructions SQL.
Institute).
Il manipule les données et les définitions de Il ne permet pas la manipulation de valeurs
table dans la base de données. dans la base de données.
Les instructions SQL sont placées dans le Les commandes sont saisies une ligne à la
tampon SQL sur une ou plusieurs lignes. fois et ne sont pas stockées dans le tampon
SQL.
Il n'offre pas de caractère de suite. Le tiret (–) est utilisé en tant que caractère de
suite si la commande excède une ligne.
Les mots-clés ne peuvent pas être abrégés. Les mots-clés peuvent être abrégés.
Il utilise un caractère de fin pour exécuter Il ne requiert pas de caractère de fin pour
les commandes immédiatement. exécuter les commandes immédiatement.
Il utilise des fonctions pour la mise en forme Il utilise des commandes pour la mise en
des données. forme des données.

Présentation de l'environnement SQL*Plus
• Se connecter à SQL*Plus
• Afficher la structure d'une table
• Editer des instructions SQL
• Exécuter du code SQL à partir de SQL*Plus
• Sauvegarder des instructions SQL dans des fichiers
et ajouter des instructions SQL à la fin de ces fichiers
• Exécuter des fichiers sauvegardés
• Charger les commandes d'un fichier dans le tampon

à des fins d'édition
SQL*Plus
SQL*Plus est un environnement dans lequel vous pouvez effectuer les opérations suivantes :
• Exécuter des instructions SQL pour extraire, modifier, ajouter ou supprimer des données
dans la base.
• Mettre en forme les résultats des interrogations, effectuer des calculs sur ces résultats,
les stocker et générer des états.
• Créer des fichiers script afin d'enregistrer des instructions SQL pour une utilisation
ultérieure.
Les commandes SQL* Plus se répartissent dans les catégories principales suivantes :
Catégorie Fonction
Environnement Définition du comportement général des instructions SQL pour la
session.
Mise en forme Mise en forme des résultats des interrogations.
Manipulation de Sauvegarde, chargement et exécution de fichiers script.
fichiers
Exécution Envoi des instructions SQL du tampon SQL au serveur Oracle.
Edition Modification des instructions SQL dans le tampon.
Interaction Création de variables et transmission à des instructions SQL,
affichage des valeurs des variables et affichage des messages à
l'écran.
Divers Connexion à la base de données, manipulation de
l'environnement SQL*Plus et affichage des définitions de
colonne.
Se connecter à SQL*Plus
sqlplus [username[/password[@database]]]

2
Se connecter à SQL*Plus
Le mode d'appel de SQL*Plus dépend du type de système d'exploration ou
d'environnement Windows utilisé.
Pour vous connecter à partir d'un environnement Windows :
1. Sélectionnez Start > Programs > Oracle > Application Development > SQL*Plus.
2. Entrez le nom utilisateur, le mot de passe et le nom de base de données.
Pour vous connecter à partir d'un environnement de ligne de commande :
1. Connectez-vous à votre ordinateur.
2. Entrez la commande sqlplus comme indiqué dans la diapositive ci-dessus.
Dans la syntaxe :
username Votre nom utilisateur de base de données
password Votre mot de passe de base de données (il est visible dans ce cas)
@database Chaîne de connexion de base de données
Remarque : Pour préserver la confidentialité de votre mot de passe, ne le saisissez pas à
l'invite du système d'exploitation. Entrez uniquement votre nom utilisateur. Entrez votre
mot de passe à l'invite de saisie du mot de passe.

Modifier les paramètres de l'environnement
SQL*Plus

Modifier les paramètres de l'environnement SQL*Plus

Si vous le souhaitez, vous pouvez modifier la présentation de l'environnement SQL*Plus à
l'aide de la boîte de dialogue SQL*Plus Properties.
Dans la fenêtre SQL*Plus, cliquez dans la barre de titre à l'aide du bouton droit de la souris
et, dans le menu contextuel qui apparaît, sélectionnez Properties. Vous pouvez alors utiliser
l'onglet Colors de la boîte de dialogue SQL*Plus Properties pour définir l'arrière-plan
(Screen Background) et le texte (Screen Text).

Afficher la structure d'une table
Utilisez la commande SQL*Plus DESCRIBE pour afficher

la structure d'une table :
DESC[RIBE] tablename


Dans SQL*Plus, vous pouvez afficher la structure d'une table à l'aide de la commande
DESCRIBE. Cette commande affiche les noms des colonnes et les types de données
correspondants, et indique si une colonne doit contenir des données.
Dans la syntaxe :
tablename Nom d'une table, d'une vue ou d'un synonyme existant
et accessible à l'utilisateur.
Pour obtenir la description de la table DEPARTMENTS, utilisez la commande suivante :
SQL> DESCRIBE DEPARTMENTS

Name Null? Type
----------------------- -------- ---------------
DEPARTMENT_ID NOT NULL NUMBER(4)

DEPARTMENT_NAME NOT NULL VARCHAR2(30)
MANAGER_ID NUMBER(6)
LOCATION_ID NUMBER(4)

Name Null? Type

----------------------- -------- ------------
DEPARTMENT_ID NOT NULL NUMBER(4)
DEPARTMENT_NAME NOT NULL VARCHAR2(30)

MANAGER_ID NUMBER(6)
LOCATION_ID NUMBER(4)
Afficher la structure d'une table (suite)

L'exemple de la diapositive affiche les informations relatives à la structure de la table
DEPARTMENTS. Dans le résultat :
Null? : Indique si une colonne est obligatoire (la valeur NOT NULL indique qu'une
colonne doit contenir des données).
Type : Affiche le type de données d'une colonne.

Commandes SQL*Plus d'édition
• A[PPEND] text
• C[HANGE] / old / new
• C[HANGE] / text /
• CL[EAR] BUFF[ER]
• DEL
• DEL n
• DEL m n


Les commandes SQL*Plus doivent être saisies une ligne à la fois et ne sont pas stockées
dans le tampon SQL.
Com m ande Description
A[PPEND] text Ajoute du texte à la fin de la ligne en cours.
C[HANGE] / old / new Remplace le texte old par le texte new dans la ligne
en cours.
C[HANGE] / text / Supprime text de la ligne en cours.
CL[EAR] BUFF[ER] Supprime toutes les lignes du tampon SQL.
DEL Supprime la ligne en cours.
DEL n Supprime la ligne n.
DEL m n Supprime les lignes m à n (incluses).
Indications
• Si vous appuyez sur [Entrée] avant de terminer une commande, SQL*Plus affiche un
numéro de ligne.
• Vous indiquez la fin de la saisie dans le tampon SQL en entrant l'un des caractères de
fin (point-virgule ou barre oblique) ou en appuyant deux fois sur [Entrée]. L'invite
SQL apparaît alors.

• I[NPUT]
• I[NPUT] text
• L[IST]
• L[IST] n
• L[IST] m n
• R[UN]
• n
• n text

• 0 text
Commandes SQL*Plus d'édition (suite)

Commande Description
I[NPUT] Insère un nombre de lignes indéfini.
I[NPUT] text Insère une ligne contenant text.
L[IST] Liste toutes les lignes du tampon SQL.
L[IST] n Liste la ligne n.
L[IST] m n Liste la fourchette de lignes m à n (incluses).
R[UN] Affiche et exécute l'instruction SQL en cours dans le tampon.
n Indique la ligne devant être la ligne en cours.
n text Remplace la ligne n par text.
0 text Insère une ligne avant la ligne 1.
Remarque : En regard d'une invite SQL, vous ne pouvez entrer qu'une seule commande
SQL*Plus. Les commandes SQL*Plus ne sont pas stockées dans le tampon. Pour continuer
une commande SQL*Plus sur la ligne suivante, terminez la première ligne par un tiret (-).

Utiliser LIST, n et APPEND
LIST
1 SELECT last_name
2* FROM employees
1
1* SELECT last_name
A , job_id

1* SELECT last_name, job_id
LIST
1 SELECT last_name, job_id
2* FROM employees
Utiliser LIST, n et APPEND

• Utilisez la commande L[IST] pour afficher le contenu du tampon SQL. L'astérisque
(*) en regard de la ligne 2, dans le tampon, indique que cette ligne est la ligne en
cours. Toutes les modifications effectuées s'appliquent à la ligne en cours.
• Modifiez le numéro de la ligne en cours en entrant le numéro (n) de la ligne que vous
souhaitez éditer. La nouvelle ligne en cours est affichée.
• Utilisez la commande A[PPEND] pour ajouter du texte à la ligne en cours. La
nouvelle ligne éditée est affichée. Vérifiez le nouveau contenu du tampon à l'aide de la
commande LIST.
Remarque : De nombreuses commandes SQL*Plus, y compris LIST et APPEND, peuvent
être abrégées à leur initiale. LIST peut être abrégée en L. APPEND peut être abrégée en A.

Utiliser la commande CHANGE
LIST
1* SELECT * from employees
c/employees/departments
1* SELECT * from departments

LIST
1* SELECT * from departments
Utiliser la commande CHANGE

• Utilisez la commande L[IST] pour afficher le contenu du tampon.
• Utilisez la commande C[HANGE] pour modifier le contenu de la ligne en cours dans
le tampon SQL. Dans ce cas, remplacez la table employees par la table
departments. La nouvelle ligne en cours est affichée.
• Utilisez la commande L[IST] pour vérifier le nouveau contenu du tampon.

Commandes SQL*Plus de manipulation
de fichiers
• SAVE filename
• GET filename
• START filename
• @ filename
• EDIT filename
• SPOOL filename
• EXIT

Commandes SQL*Plus de manipulation de fichiers

Les instructions SQL communiquent avec le serveur Oracle. Les commandes SQL*Plus
permettent de contrôler l'environnement, de mettre en forme le résultat des interrogations et
de gérer les fichiers. Vous pouvez utiliser les commandes décrites dans le tableau suivant :
Commande Description
SAV[E] filename [.ext] Sauvegarde le contenu en cours du tampon SQL dans un
[REP[LACE]APP[END]] fichier. Utilisez APPEND pour effectuer un ajout à un fichier
existant. Utilisez REPLACE pour remplacer le contenu d'un
fichier existant. L'extension par défaut est .sql.
GET filename [.ext] Ecrit dans le tampon SQL le contenu d'un fichier
précédemment sauvegardé. L'extension par défaut du nom
de fichier est .sql.
STA[RT] filename [.ext] Exécute un fichier de commandes précédemment
sauvegardé.
@ filename Exécute un fichier de commandes précédemment
sauvegardé (identique à START).
ED[IT] Appelle l'éditeur et sauvegarde le contenu du tampon dans
un fichier nommé afiedt.buf
ED[IT] [filename[.ext]] Appelle l'éditeur pour permettre de modifier le contenu d'un
fichier sauvegardé.
SPO[OL] [filename[.ext]| Stocke les résultats des interrogations dans un fichier.
OFF|OUT] L'option OFF ferme le fichier spool. L'option OUT ferme le
fichier spool et transmet son contenu à l'imprimante.
EXIT Permet de quitter SQL*Plus.

Utiliser les commandes SAVE, START et EDIT
LIST
1 SELECT last_name, manager_id, department_id
2* FROM employees
SAVE my_query
Created file my_query
START my_query

LAST_NAME MANAGER_ID DEPARTMENT_ID
------------------------- ---------- -------------
King 90
Kochhar 100 90
...
107 rows selected.

SAVE
Utilisez la commande SAVE pour sauvegarder le contenu en cours du tampon dans un
fichier. Vous pouvez ainsi stocker les scripts fréquemment utilisés, en vue d'une utilisation
ultérieure.
START
Utilisez la commande START pour exécuter un script dans SQL*Plus. Pour cela, vous
pouvez également utiliser le symbole @.
@my_query

EDIT my_query

Utiliser les commandes SAVE, START et EDIT (suite)

EDIT
Utilisez la commande EDIT pour modifier un script existant. Vous accédez alors à un
éditeur contenant le fichier script. Lorsque vous avez effectué les modifications souhaitées,
quittez l'éditeur pour revenir à la ligne de commande SQL*Plus.
Remarque : "/" est un délimiteur signifiant la fin d'une instruction. Lorsque SQL*Plus le
rencontre dans un fichier, il exécute l'instruction qui le précède. Le délimiteur doit être le
premier caractère d'une nouvelle ligne immédiatement après l'instruction.

Utiliser la commande SERVEROUTPUT
• Utilisez la commande SET SERVEROUT[PUT] pour indiquer

si la sortie des procédures stockées ou des blocs PL/SQL
doit être affichée dans SQL*Plus.
• La limite relative à la longueur de la ligne DBMS_OUTPUT
est passée de 255 octets à 32 767 octets.
• Il n'y a plus de limite pour la taille par défaut.
• Les ressources ne sont pas préallouées quand
SERVEROUTPUT est défini.
• Etant donné que cela n'affecte pas les performances,

utilisez UNLIMITED, sauf si vous souhaitez économiser
la mémoire physique.
SET SERVEROUT[PUT] {ON | OFF} [SIZE {n | UNL[IMITED]}]

[FOR[MAT] {WRA[PPED] | WOR[D_WRAPPED] | TRU[NCATED]}]
Utiliser la commande SERVEROUTPUT

La plupart des programmes PL/SQL effectuent des entrées et des sorties via des
instructions SQL pour stocker des données dans des tables de base de données ou pour
interroger ces tables. Toutes les autres entrées-sorties PL/SQL sont générées via des API
qui interagissent avec d'autres programmes. Par exemple, le package DBMS_OUTPUT
contient des procédures telles que PUT_LINE. L'affichage du résultat hors de PL/SQL
requiert un autre programme tel que SQL*Plus qui permet de lire et d'afficher les données
transmises à DBMS_OUTPUT.
SQL*Plus n'affiche les données DBMS_OUTPUT que si vous exécutez préalablement la
commande SQL*Plus SET SERVEROUTPUT ON comme suit :
SET SERVEROUTPUT ON
Remarque
• SIZE définit le nombre d'octets de la sortie pouvant être placés dans le tampon sur le
serveur Oracle Database. La valeur par défaut est UNLIMITED. Le nombre indiqué ne
peut pas être inférieur à 2 000 ni supérieur à 1 000 000.
• Pour plus d'informations sur SERVEROUTPUT, reportez-vous au manuel Oracle
Database PL/SQL User's Guide and Reference 11g.

Utiliser la commande SQL*Plus SPOOL
SPO[OL] [file_name[.ext] [CRE[ATE] | REP[LACE] | APP[END]] |

OFF | OUT]
Option Description
file_name[.ext] Stocke la sortie dans le fichier spool indiqué.
CRE[ATE] Crée un fichier avec le nom indiqué.
REP[LACE] Remplace le contenu d'un fichier existant. Si le fichier

n'existe pas, il est créé.

APP[END] Ajoute le contenu du tampon à la fin du fichier que vous
indiquez.
OFF Arrête le stockage dans le fichier spool.
OUT Arrête le stockage dans le fichier spool et envoie le fichier

à l'imprimante standard (par défaut) de votre ordinateur.
Utiliser la commande SQL*Plus SPOOL

La commande SPOOL permet de stocker les résultats des interrogations dans un fichier.
Elle permet également d'envoyer ce fichier à une imprimante. Cette commande a été
améliorée. Précédemment, elle permettait uniquement de créer (ou de remplacer) un
fichier. A présent, il est aussi possible d'effectuer un ajout à la fin d'un fichier. L'option par
défaut est REPLACE.
Pour placer la sortie générée par les commandes d'un script dans un fichier spool sans
l'afficher à l'écran, utilisez SET TERMOUT OFF. Cette option n'affecte pas la sortie des
commandes exécutées de manière interactive.
Vous devez utiliser des guillemets autour des noms de fichier contenant des espaces. Pour
créer un fichier HTML valide à l'aide des commandes SPOOL APPEND, vous devez
utiliser PROMPT ou une commande similaire afin de créer l'en-tête et le pied de page
HTML. La commande SPOOL APPEND n'analyse pas les balises HTML. Pour désactiver
les paramètres CREATE, APPEND et SAVE, affectez à l'option SET
SQLPLUSCOMPAT[IBILITY] un numéro de version inférieur ou égal à 9.2.

Utiliser la commande AUTOTRACE
• Affiche un état après l'exécution réussie d'instructions LMD

SQL telles que SELECT, INSERT, UPDATE ou DELETE.
• L'état peut à présent inclure les statistiques d'exécution
et le chemin d'exécution de l'interrogation.
SET AUTOT[RACE] {ON | OFF | TRACE[ONLY]} [EXP[LAIN]]

[STAT[ISTICS]]

SET AUTOTRACE ON
-- The AUTOTRACE report includes both the optimizer
-- execution path and the SQL statement execution
-- statistics
Utiliser la commande AUTOTRACE

L'option EXPLAIN montre le chemin d'exécution de l'interrogation en exécutant la
commande EXPLAIN PLAN. L'option STATISTICS affiche les statistiques relatives aux
instructions SQL. La mise en forme de l'état AUTOTRACE peut varier en fonction de la
version et de la configuration du serveur auquel vous êtes connecté. Le package
DBMS_XPLAN fournit une méthode simple d'affichage du résultat de la commande
EXPLAIN PLAN dans plusieurs formats prédéfinis.
Remarque
• Pour plus d'informations sur les packages et les sous-programmes, consultez le manuel
Oracle Database PL/SQL Packages and Types Reference 11g.
• Pour plus d'informations sur la commande EXPLAIN PLAN, consultez le manuel
Oracle Database SQL Reference 11g.
• Pour plus d'informations sur les plans d'exécution et les statistiques, consultez le
manuel Oracle Database Performance Tuning Guide 11g.

Synthèse
Cette annexe a traité des sujets suivants :

• Exécuter des instructions SQL
• Editer des instructions SQL
• Mettre en forme la sortie
• Interagir avec des fichiers script

Synthèse
SQL*Plus est un environnement d'exécution qui permet d'envoyer des commandes SQL au
serveur de base de données, ou encore d'éditer et de sauvegarder des commandes SQL.
Vous pouvez exécuter des commandes à partir de l'invite SQL ou d'un fichier script.


de l'interface graphique SQL Developer
Effectuer des opérations LMD et LDD à l'aide

Objectifs

• effectuer des opérations LDD (langage de définition
de données) à l'aide des options de menu SQL Developer
• effectuer des opérations LMD (langage de manipulation
de données) à l'aide des options de menu SQL Developer

Objectifs
Cette annexe présente l'outil graphique SQL Developer. Elle explique comment utiliser
l'interface graphique SQL Developer pour les tâches de développement de base de données.
Cette annexe complète le chapitre "Introduction". Il est supposé que vous avez créé une
connexion de base de données et que vous êtes prêt à naviguer au sein des objets dans
l'interface SQL Developer.
Oracle Database 11g : Les fondamentaux du langage SQL (I) E - 2

Consulter les objets de base de données
• Créez une connexion de base de données.

• Utilisez le navigateur de connexions pour :
– naviguer dans la liste des objets d'un schéma
de base de données
– vérifier d'un coup d'oeil la définition d'un objet

Consulter les objets de base de données

Après avoir créé une connexion de base de données, vous pouvez utiliser le navigateur de
connexions (Connections Navigator) pour parcourir la liste des objets d'un schéma de la
base (tables, vues, index, packages, procédures, déclencheurs, types, etc.).
Le volet de gauche permet de rechercher et de sélectionner des objets (navigation), tandis
que celui de droite affiche des informations sur les objets sélectionnés. Il est possible de
personnaliser de nombreux aspects de la présentation de SQL Developer en définissant des
préférences.
Vous pouvez afficher la définition des objets dans plusieurs onglets présentant les
informations extraites du dictionnaire de données. Par exemple, si vous sélectionnez une
table dans le navigateur, les informations telles que les colonnes, les contraintes, les
privilèges, les statistiques et les déclencheurs sont présentées dans des onglets distincts, ce
qui facilite leur lecture.
Pour afficher la définition de la table EMPLOYEES comme dans la diapositive ci-dessus,
procédez de la manière suivante :
1. Développez le noeud Connections dans le navigateur de connexions (onglet
Connections).
2. Développez Tables.
3. Cliquez sur EMPLOYEES. L'onglet Columns est sélectionné par défaut. Il contient la
description des colonnes de la table. Dans l'onglet Data, vous pouvez visualiser les
données de la table, ajouter de nouvelles lignes, mettre à jour les données et valider
(commit) ces modifications dans la base.

Créer un objet de schéma
• SQL Developer prend en charge la création de n'importe

quel objet de schéma via le menu contextuel.
• Modifiez les objets à l'aide de la boîte de dialogue d'édition
ou de l'un des nombreux menus contextuels.
• Consultez le code LDD pour voir les ajustements tels que
la création d'un nouvel objet ou la modification d'un objet
de schéma existant.

Développez Connections.
Cliquez avec le bouton droit
de la souris sur Tables et
sélectionnez New Table.
Créer un objet de schéma

SQL Developer permet de créer n'importe quel objet de schéma via l'exécution d'une
instruction SQL dans SQL Worksheet. Vous pouvez aussi créer des objets à l'aide des
menus contextuels. Une fois les objets créés, vous pouvez les modifier à l'aide de la boîte
de dialogue d'édition ou de l'un des nombreux menus contextuels.
A mesure que des objets sont créés ou modifiés, vous pouvez voir ces ajustements dans le
code LDD (Langage de définition de données). L'option Export DDL vous permet de créer
l'intégralité du code LDD pour un ou plusieurs objets du schéma.
La diapositive ci-dessus illustre la création d'une table à l'aide du menu contextuel. Pour
ouvrir une boîte de dialogue permettant de créer une nouvelle table, cliquez avec le bouton
droit de la souris sur Tables et sélectionnez New Table. Les boîtes de dialogue permettant
de créer et de modifier des objets de base de données proposent plusieurs onglets
correspondant à différents regroupements logiques de propriétés pour le type d'objet
concerné.

Créer une nouvelle table : Exemple
Cochez la case
Advanced pour obtenir
toutes les options de
définition de table.

Cliquez sur + pour
ajouter une colonne.
Cliquez sur x pour Indiquez ici le nom de la
supprimer une colonne. colonne, le type de données, la
valeur par défaut et la
contrainte NULL.
Créer une nouvelle table : Exemple

Dans la boîte de dialogue Create Table, si vous ne cochez pas la case Advanced, vous
pouvez créer une table rapidement en indiquant ses colonnes et certaines caractéristiques
courantes.
Si vous cochez la case Advanced, la boîte de dialogue Create Table propose plusieurs
autres options qui vous permettent d'indiquer davantage de caractéristiques pendant la
création de la table.
L'exemple de la diapositive ci-dessus présente la création de la table DEPENDENTS avec la
case Advanced cochée.
Pour créer une nouvelle table, procédez comme suit :
1. Dans le navigateur de connexions, cliquez avec le bouton droit de la souris sur Tables.
2. Sélectionnez Create TABLE.
3. Dans la boîte de dialogue Create Table, cochez la case Advanced.
4. Indiquez les informations relatives aux colonnes. Dans la section des propriétés de
colonne, indiquez le nom de colonne, le type de données et la valeur par défaut, puis
cochez la case "Cannot be Null" pour définir une colonne NOT NULL. Cliquez sur +
pour ajouter une colonne et sur x pour en supprimer une. Dans la capture d'écran, la
colonne LAST_NAME est définie avec le type VARCHAR2(20) et en tant que colonne
NOT NULL (la case "Cannot be Null" est cochée).
5. Cliquez sur OK.
De manière facultative, vous pouvez indiquer une clé primaire dans l'onglet Primary Key
de la boîte de dialogue. Vous serez parfois amené à modifier une table que vous avez créée.
Pour ce faire, cliquez dessus avec le bouton droit de la souris dans le navigateur de
connexions, puis sélectionnez Edit.

Définissez une contrainte sur la table en
sélectionnant l'option appropriée :
Primary Key, Unique Constraints,
Foreign Keys ou Check Constraints.

Dans la boîte de dialogue Create Table, vous pouvez également définir tous les types de
contrainte sur la table. Dans la diapositive ci-dessus, l'option Primary Key est sélectionnée.
Le nom par défaut DEPENDENTS_PK est attribué à la contrainte. Vous pouvez
sélectionner la colonne appropriée dans la liste Available Columns, puis cliquer sur > pour
la déplacer vers la liste Selected Columns. Dans la diapositive, la colonne ID est désignée
comme clé primaire. De même, vous pouvez sélectionner l'option Unique Constraints pour
définir une contrainte unique ou sur l'option Foreign Keys pour définir une contrainte de
clé étrangère. Cliquez sur OK.
Dans le navigateur de connexions, si vous souhaitez définir des contraintes sur une table
existante, cliquez avec le bouton droit de la souris sur la table et sélectionnez Edit.
Vous obtenez une boîte de dialogue similaire à celle qui est présentée dans la diapositive
ci-dessus. Pour procéder à une modification, vous pouvez aussi cliquer sur l'icône
représentant un crayon.

Modifier une table
1 2

4
Modifier une table

Lorsque vous créez une table, celle-ci est ajoutée sous le noeud Tables dans le navigateur
de connexions. Vous pouvez afficher la structure de la table et même modifier la définition
des colonnes de la table. Dans le navigateur de connexions, cliquez sur la table à modifier.
Sur le côté droit figure un ensemble d'onglets fournissant tous les détails relatifs à la table.
L'onglet Columns présente la structure de la table, et l'onglet Data, les données de la table.
Dans l'onglet Columns, procédez comme suit :
1. Cliquez sur Actions. Un sous-menu apparaît.
2. Sélectionnez Table. Un ensemble d'options de menu apparaît. Si vous souhaitez
renommer la table, sélectionnez Rename. Si vous souhaitez supprimer toutes les lignes
de la table, sélectionnez Truncate. Pour supprimer la table, sélectionnez Drop.
3. Si vous souhaitez ajouter une contrainte CHECK sur la colonne GENDER de sorte que
celle-ci accepte uniquement les valeurs "M" et "F", vérifiez que la colonne GENDER
est bien sélectionnée, puis choisissez Constraint et cliquez sur Add Check.
4. Si vous souhaitez supprimer une colonne, sélectionnez Column dans le sous-menu
Actions, puis cliquez sur Drop.
Remarque : Vous obtenez les mêmes options de menu en cliquant avec le bouton droit de
la souris sur la table dans le navigateur de connexions.

Ajouter des données à une table

Ajouter des données à une table

Pour ajouter des lignes dans la table, procédez comme suit :
1. Dans le navigateur de connexions, sélectionnez la table dans laquelle vous souhaitez
ajouter des données. Cliquez sur l'onglet Data.
2. Cliquez sur l'icône Insert Row. Une ligne vide est ajoutée après la ligne sélectionnée,
vous permettant ainsi de saisir de nouvelles données.
3. Entrez les valeurs des champs de l'enregistrement. Pour ajouter une autre ligne, cliquez
à nouveau sur l'icône Insert Row.

Mettre à jour et supprimer des lignes

Mettre à jour et supprimer des lignes

1. Pour mettre à jour des données d'une table, apportez les modifications directement
dans la grille de valeurs de l'onglet Data. Lorsque vous entrez dans une cellule de la
grille, vous pouvez modifier directement les données d'un certain nombre de types.
D'une manière générale, vous pouvez modifier le contenu d'une cellule en cliquant sur
le bouton représentant des points de suspension (...).
2. Cliquez sur Delete Selected Row(s) pour marquer les lignes sélectionnées pour
suppression. La suppression n'a réellement lieu que lorsque vous validez (commit) les
modifications.

Validation et annulation
Cliquez sur l'icône Commit Cliquez sur l'icône Rollback

Changes pour enregistrer Changes pour annuler la
la transaction. transaction.

Validation et annulation
Après avoir inséré de nouvelles lignes ou mis à jour des lignes existantes, vous pouvez
enregistrer les modifications ou les annuler.
1. Pour enregistrer les modifications, cliquez sur l'icône Commit Changes. La transaction
en cours prend alors fin et toutes les modifications réalisées dans cette transaction
deviennent définitives.
2. Pour annuler les modifications, cliquez sur l'icône Rollback Changes. Tout le travail
réalisé dans la transaction en cours est annulé.

Créer une vue

Créer une vue

Les vues sont des tables virtuelles (semblables aux interrogations dans certains produits de
base de données) qui permettent de sélectionner des données dans une ou plusieurs tables
sous-jacentes. Pour créer une vue, procédez comme suit :
1. Dans le navigateur de connexions, cliquez avec le bouton droit de la souris sur Views
et sélectionnez New View.
2. Dans la boîte de dialogue Create View, cochez la case Advanced. Lorsque cette option
est cochée, la boîte de dialogue change de manière à inclure un volet proposant un
ensemble étendu de fonctions pour la création de la vue.
3. Dans la zone SQL Query, vous pouvez saisir directement l'interrogation SQL. Vous
pouvez aussi développer le noeud SQL Query et utiliser ses différentes options pour
définir la vue étape par étape. Cliquez sur OK. La vue est ajoutée au noeud Views dans
le navigateur de connexions.



Pour extraire des données d'une vue, procédez comme suit :
1. Dans le navigateur de connexions, développez Views. Sélectionnez la vue dont vous
souhaitez afficher les données.
2. Cliquez sur l'onglet Data pour afficher les données.



Les séquences sont utilisées pour générer des entiers uniques. Vous pouvez utiliser des
séquences pour générer automatiquement des valeurs de clé primaire. Pour créer une
séquence, procédez comme suit :
1. Dans le navigateur de connexions, développez Sequences. Sélectionnez New
Sequence.
2. Dans la boîte de dialogue Create Database Sequence, indiquez le nom du schéma et
celui de la séquence. Dans l'onglet Properties, indiquez la valeur de l'incrément, la
valeur minimum, la valeur de départ, la valeur maximum, etc. Vous pouvez examiner
le code de cette séquence et le modifier en cliquant sur l'onglet DDL. Cliquez sur OK.
Remarque : Vous pouvez modifier ou supprimer une séquence à l'aide des options de
menu qui apparaissent lorsque vous cliquez avec le bouton droit de la souris sur la
séquence.

Créer des index
2
1

Créer des index

Un index est un objet de base de données qui contient une entrée pour chaque valeur qui
apparaît dans la ou les colonnes indexées de la table ou du cluster. Il fournit un accès direct
et rapide aux lignes. Des index sont créés automatiquement sur les colonnes de clé
primaire. En revanche, si vous souhaitez bénéficier des avantages de l'indexation pour
d'autres colonnes, vous devez créer ces index.
Pour créer un index, procédez comme suit :
1. Cliquez avec le bouton droit de la souris sur Indexes dans le navigateur de connexions.
Sélectionnez New Index.
2. Dans la boîte de dialogue Create Index, sélectionnez le schéma auquel appartiendra
l'index. Indiquez le nom de l'index.
3. Dans l'onglet Properties, indiquez le schéma auquel appartient la table à indexer.
Sélectionnez la table qui sera associée à l'index. Sélectionnez le type d'index.
Définissez l'index en indiquant des noms de colonne de la table ou des expressions de
colonne. Pour ajouter une expression d'index, cliquez sur l'icône Add Column
Expression (+). Un nom de colonne est ajouté à cet emplacement et dans l'expression
de colonne, où vous pouvez le modifier. Vous pouvez aussi préciser l'ordre de l'index.
Remarque : Pour modifier, supprimer, reconstruire ou renommer un index, cliquez dessus
avec le bouton droit de la souris et utilisez les options de menu qui apparaissent.

Créer un synonyme
1 4

Créer un synonyme
Les synonymes permettent d'attribuer un autre nom aux tables, aux vues, aux séquences ou
à d'autres synonymes. Le navigateur de connexions comporte un noeud Synonyms pour
tous les synonymes (publics et privés) appartenant à l'utilisateur associé à la connexion
considérée, et un noeud Public Synonyms pour tous les synonymes publics définis pour la
base de données associée à la connexion.
Pour créer un synonyme, procédez comme suit :
1. Dans le navigateur de connexions, cliquez avec le bouton droit de la souris sur
Synonyms. Sélectionnez New Synonym.
2. Dans la boîte de dialogue Create Database Synonym, cochez la case Public si vous
souhaitez que le synonyme soit accessible à tous les utilisateurs. Les synonymes privés
ne sont accessibles qu'au sein de leur schéma.
3. Entrez le nom du synonyme.
4. Dans l'onglet Properties, sélectionnez le schéma qui contient l'objet pour lequel le
synonyme est défini. Vous pouvez entrer directement le nom de l'objet (si l'option
Name based est sélectionnée) ou vous pouvez sélectionner l'option Object based pour
obtenir la liste déroulante de tous les objets du schéma. Sélectionnez l'objet dans la
liste. Cliquez sur OK.
Remarque : Les synonymes publics sont ajoutés sous un autre noeud du navigateur de
connexions. Il s'agit du noeud Public Synonyms. Pour supprimer un synonyme, cliquez
simplement dessus avec le bouton droit de la souris et sélectionnez Drop dans le menu.

Utiliser des snippets
Les snippets sont des fragments de code représentant une

syntaxe ou des exemples.
Lorsque vous placez le pointeur
de la souris ici, la fenêtre Snippets
apparaît. Vous pouvez sélectionner la
catégorie de fonctions de votre choix
dans la liste déroulante.

Utiliser des snippets

Vous pouvez avoir besoin de certains fragments de code prédéfinis lorsque vous utilisez
SQL Worksheet, ou pendant la création ou la modification d'une fonction ou d'une
procédure PL/SQL. A cet effet, SQL Developer fournit une fonctionnalité appelée
Snippets. Les snippets sont des fragments de code : fonctions SQL, conseils (Hints) de
l'optimiseur et diverses techniques de programmation PL/SQL. Ces snippets peuvent être
insérés dans la fenêtre d'édition par simple glissement.
Pour afficher les snippets, sélectionnez View > Snippets.
La fenêtre Snippets s'affiche dans la partie droite de l'écran. Utilisez la liste déroulante pour
sélectionner un groupe. Le bouton Snippets situé dans la marge de droite permet d'afficher
la fenêtre Snippets lorsqu'elle est masquée.

Utiliser des snippets : Exemple
Insérer
un snippet
Modifier

le snippet
Utiliser des snippets : Exemple

Pour insérer un snippet dans le code d'une feuille de calcul SQL ou d'une fonction ou
procédure PL/SQL, faites-le glisser de la fenêtre Snippets jusqu'à l'emplacement souhaité
dans le code. Vous pouvez ensuite modifier la syntaxe pour que la fonction SQL soit valide
dans le contexte en cours. Pour afficher la description succincte d'une fonction SQL dans
une info-bulle, placez le curseur sur le nom de cette fonction.
La diapositive ci-dessus présente le déplacement de CONCAT(char1, char2) à partir
du groupe Character Functions de la fenêtre Snippets. La syntaxe de la fonction CONCAT
est ensuite modifiée et le reste de l'instruction est ajouté comme suit :
SELECT CONCAT(first_name, last_name)
FROM employees;

Moteurs de recherche et outils externes
Raccourcis vers des outils

fréquemment utilisés
Liens vers des moteurs

de recherche et forums

de discussion populaires
Moteurs de recherche et outils externes

Afin d'améliorer la productivité des développeurs SQL, SQL Developer comprend des liens
permettant d'accéder rapidement à des moteurs de recherche et à des forums de discussion
populaires tels que AskTom, Google, etc. Il propose également des icônes de raccourci vers
des outils fréquemment utilisés tels que le Bloc-notes, Microsoft Word, Dreamweaver, etc.
Vous pouvez ajouter des outils externes à la liste existante ou supprimer les raccourcis vers
les outils que vous utilisez rarement. Pour ce faire, procédez comme suit :
1. Dans le menu Tools, sélectionnez External Tools.
2. Dans la boîte de dialogue External Tools, sélectionnez New pour ajouter de nouveaux
outils. Sélectionnez Delete pour supprimer n'importe quel outil de la liste.

Définir des préférences
• Personnalisez l'interface et l'environnement de SQL

Developer.
• Dans le menu Tools, sélectionnez Preferences.

Définir des préférences

Vous pouvez personnaliser de nombreux aspects de l'interface et de l'environnement de
SQL Developer en modifiant les préférences SQL Developer en fonction de vos habitudes
et de vos besoins. Pour modifier les préférences SQL Developer, sélectionnez Tools, puis
Preferences.
Les préférences sont regroupées selon les catégories suivantes :
• Environment
• Accelerators (raccourcis clavier)
• Code Editors
• Database
• Debugger
• Documentation
• Extensions
• File Types
• Migration
• PL/SQL Compilers
• PL/SQL Debugger, etc.

Tutoriel SQL Developer
• Pour apprendre à utiliser Oracle SQL Developer pour

effectuer des tâches de développement de base de données
courantes, suivez le tutoriel Oracle SQL Developer.
• Il est disponible à l'adresse :
http://st-curriculum.oracle.com/tutorial/SQLDeveloper/index.htm

Tutoriel SQL Developer

Le tutoriel SQL Developer explique de manière détaillée comment effectuer les tâches de
développement de base de données courantes dans SQL Developer. Il comporte des
démonstrations indiquant visuellement et étape par étape comment réaliser des tâches
spécifiques.
Consultez les rubriques/sections suivantes relatives au langage SQL :
• Utiliser des objets de base de données
• Accéder à des données
• Manipuler des données

Synthèse
Cette annexe a traité des sujets suivants :

• Consulter, créer et modifier des objets de base de données
à l'aide de l'interface graphique SQL Developer
• Insérer, mettre à jour et supprimer des lignes dans une table
à l'aide de l'interface graphique SQL Developer

Synthèse
SQL Developer est un outil graphique gratuit conçu pour simplifier les tâches de
développement d'une base de données. Il permet de consulter, de créer et de modifier des
objets de base de données. Les options des menus contextuels et l'interface graphique vous
permettent de réaliser les mêmes tâches de développement de base de données qu'avec des
instructions SQL.


Index

A
Alias i-38
ALL i-2, i-12, i-16, i-35, i-46, i-49, i-51, i-57
AND i-11, i-13, i-14, i-17, i-22, i-30, i-31, i-32, i-34, i-36,
i-40, i-41, i-48, i-49, i-57, i-58
Attributs i-22, i-23, i-24
B
Base de données i-2, i-4, i-10, i-11, i-13, i-16, i-17, i-18,
i-19, i-20, i-22, i-27, i-28, i-30, i-34, i-35, i-36, i-37, i-38,
i-39, i-40, i-41, i-42, i-48, i-49, i-56, i-57, i-58
Base de données relationnelle i-2, i-16, i-18, i-19, i-27, i-28,

i-30, i-56
BI Publisher i-14
C
CASE i-38, i-58
commande i-14, i-22, i-32, i-41, i-48, i-49, i-57
contrainte i-16, i-40, i-56
Contraintes i-16, i-40, i-56
COUNT i-51, i-59
Créer une connexion de base de données i-37, i-38, i-39, i-58
D
Date i-17, i-18, i-22, i-31, i-51
DEFAULT i-38
DELETE i-31
DISTINCT i-21, i-25, i-40
E
Entité/relation i-21, i-22, i-23
Execute Statement i-42, i-44, i-47
expression i-5
Exécuter des instructions SQL i-41, i-44
F
fonction i-2, i-4, i-5, i-9, i-10, i-11, i-12, i-13, i-16,
i-18, i-30, i-32, i-36, i-45, i-56
fonctions i-4, i-5, i-9, i-11, i-13, i-16, i-18, i-36, i-56
Fonctions i-4, i-5, i-9, i-11, i-13, i-16, i-18, i-36, i-56
Oracle Database 11g : Les fondamentaux du langage SQL (I) Index-2

F
Fonctions de conversion i-5
Fonctions de groupe i-5
I
icône i-41, i-42, i-43, i-44, i-47, i-49, i-58, i-59
Identificateur unique i-23, i-24
IN i-1, i-2, i-3, i-4, i-5, i-6, i-7, i-8, i-9, i-10,
i-11, i-12, i-13, i-14, i-15, i-16, i-17, i-18, i-19, i-20, i-21,
i-22, i-23, i-24, i-25, i-26, i-27, i-28, i-29, i-30, i-31, i-32,
i-33, i-34, i-35, i-36, i-37, i-38, i-39, i-40, i-41, i-42, i-43,
i-44, i-45, i-46, i-47, i-48, i-49, i-50, i-51, i-52, i-53, i-55,

i-56, i-57, i-58, i-59
Index i-35, i-40, i-55
INSERT i-16, i-30, i-31
instruction i-2, i-4, i-5, i-6, i-10, i-16, i-30, i-31, i-32,
i-34, i-41, i-42, i-43, i-44, i-45, i-46, i-47, i-48, i-49
Interrogation i-4, i-5, i-14, i-30, i-36, i-44, i-46, i-47
Interrogations i-4, i-5, i-14, i-36, i-46, i-47
INTERSECT i-28
J
Java i-9, i-35, i-56, i-58
M
MINUS i-23
MOD i-9, i-10, i-11, i-12, i-13, i-14, i-16, i-17, i-18, i-20,
i-21, i-22, i-23, i-24, i-26, i-30, i-34, i-36, i-40, i-42, i-56,
i-58
Mots-clés i-44, i-45
N
NOT i-10, i-12, i-13, i-35, i-48
NULL i-26, i-28

O
OLTP i-11, i-16
ON i-1, i-2, i-3, i-4, i-5, i-6, i-7, i-8, i-9, i-10,
i-11, i-12, i-13, i-14, i-15, i-16, i-17, i-18, i-19, i-20, i-21,
i-22, i-23, i-24, i-25, i-26, i-27, i-28, i-29, i-30, i-31, i-32,
i-33, i-34, i-35, i-36, i-37, i-38, i-39, i-40, i-41, i-42, i-43,
i-44, i-45, i-46, i-47, i-48, i-49, i-50, i-51, i-52, i-53, i-54,
i-55, i-56, i-57, i-58, i-59
option i-36, i-41, i-44, i-48
opérateur i-5, i-18
Opérateurs ensemblistes i-5

OR i-2, i-3, i-4, i-7, i-8, i-9, i-10, i-11, i-12, i-13,
i-14, i-15, i-16, i-17, i-18, i-19, i-20, i-21, i-22, i-25, i-26,
i-27, i-28, i-29, i-30, i-31, i-32, i-33, i-34, i-35, i-36, i-37,
i-38, i-39, i-40, i-41, i-42, i-43, i-44, i-45, i-46, i-47, i-48,
i-49, i-50, i-51, i-52, i-53, i-54, i-55, i-56, i-57, i-58, i-59
Oracle Database 11g i-2, i-3, i-4, i-8, i-9, i-10, i-11,
i-14, i-15, i-29, i-33, i-49, i-50, i-53, i-54, i-55, i-56
Oracle Enterprise Manager Grid Control 10g i-13, i-56
Oracle Fusion Middleware i-12, i-13, i-56
Oracle SQL Developer i-2, i-3, i-7, i-8, i-15, i-29, i-32,
i-33, i-34, i-35, i-36, i-37, i-38, i-40, i-41, i-45, i-47, i-48,
i-49, i-50, i-53, i-57, i-58
Ordre i-27
R
REFERENCES i-36, i-47
S
Schéma i-2, i-3, i-4, i-6, i-8, i-15, i-24, i-29, i-33, i-34,
i-36, i-37, i-38, i-40, i-50, i-51, i-53, i-57
SELECT i-4, i-5, i-30, i-31, i-38, i-39, i-58
SGBDR i-2, i-18, i-25, i-27, i-56
SGBDR orienté objet i-2, i-56
Sous-interrogation i-5
SQL Developer i-2, i-3, i-7, i-8, i-9, i-15, i-29, i-32,
i-33, i-34, i-35, i-36, i-37, i-38, i-40, i-41, i-45, i-47, i-48,
i-49, i-50, i-53, i-54, i-57, i-58

S
Synonyme i-23, i-24
Sélection i-4, i-36, i-38, i-40, i-41, i-45, i-46, i-47, i-48,
i-58
T
table i-3, i-4, i-5, i-6, i-7, i-8, i-15, i-19, i-20, i-25,
i-26, i-27, i-28, i-29, i-30, i-33, i-40, i-48, i-50, i-51, i-52,
i-53, i-57, i-59
Transactions i-11, i-31
Tri i-4, i-5, i-9, i-11, i-13, i-14, i-16, i-22, i-23, i-24,
i-27, i-31, i-46, i-48, i-51, i-59

TRUNC i-31
Types de données i-9, i-16
U
UNIQUE i-9, i-11, i-20, i-23, i-24, i-25, i-26, i-27, i-28, i-34,
i-44, i-48, i-56
UPDATE i-31
V
valeur i-23, i-26, i-27, i-28, i-37, i-38
valeurs i-23, i-26
Vues i-12, i-40
X
XML i-9, i-14, i-37, i-38, i-56


D49996FR10 sg2

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

D49996FR10 sg2

Transféré par

Droits d'auteur :

Formats disponibles

THESE eKIT MATERIALS ARE FOR YOUR USE IN THIS CLASSROOM ONLY.

COPYING eKIT MATERIALS FROM THIS COMPUTER IS STRICTLY PROHIBITED

Manuel du stagiaire - Volume II

Oracle University and OMNIDATA. use only

Oracle University and OMNIDATA. use only

Oracle University and OMNIDATA. use only

Lancer SQL*Plus à partir d'Oracle SQL Developer I-48

1 Extraire des données à l'aide de l'instruction SQL SELECT

Oracle University and OMNIDATA. use only

Oracle University and OMNIDATA. use only

3 Utiliser des fonctions monolignes pour personnaliser les résultats

Utiliser les fonctions de conversion de casse 3-12

Oracle University and OMNIDATA. use only

4 Utiliser des fonctions de conversion et des expressions conditionnelles

Contenu du chapitre 4-35

Oracle University and OMNIDATA. use only

6 Afficher des données provenant de plusieurs tables

Contenu du chapitre 6-8

Oracle University and OMNIDATA. use only

7 Utiliser des sous-interrogations pour résoudre des interrogations

Utiliser des fonctions de groupe dans une sous-interrogation 7-12

Oracle University and OMNIDATA. use only

Oracle University and OMNIDATA. use only

Présentation de l'exercice 9 9-47

10 Utiliser des instructions LDD pour créer et gérer des tables

Oracle University and OMNIDATA. use only

11 Créer d'autres objets de schéma

Vues simples et vues complexes 11 -7

Oracle University and OMNIDATA. use only

Annexe A - Solutions des exercices

Oracle University and OMNIDATA. use only

Oracle University and OMNIDATA. use only

Oracle University and OMNIDATA. use only

Oracle University and OMNIDATA. use only

Oracle University and OMNIDATA. use only

Conventions typographiques concernant le texte

Oracle University and OMNIDATA. use only

Copyright © 2007, Oracle. Tous droits réservés.

Oracle University and OMNIDATA. use only

A la fin de ce chapitre, vous pourrez :

Oracle University and OMNIDATA. use only

Oracle Database 11g : Les fondamentaux du langage SQL (I) 9 - 2

• Ajouter de nouvelles lignes dans une table

Oracle University and OMNIDATA. use only

Copyright © 2007, Oracle. Tous droits réservés.

Oracle Database 11g : Les fondamentaux du langage SQL (I) 9 - 3

• Une instruction LMD est exécutée dans les cas suivants :

Oracle University and OMNIDATA. use only

Langage de manipulation de données

Oracle Database 11g : Les fondamentaux du langage SQL (I) 9 - 4

Insérez une nouvelle ligne

Oracle University and OMNIDATA. use only

Ajouter une nouvelle ligne à une table

Oracle Database 11g : Les fondamentaux du langage SQL (I) 9 - 5

• Ajoutez de nouvelles lignes à une table à l'aide de

• Avec cette syntaxe, une seule ligne est insérée à la fois.

Oracle University and OMNIDATA. use only

Syntaxe de l'instruction INSERT

Oracle Database 11g : Les fondamentaux du langage SQL (I) 9 - 6

• Insérez une nouvelle ligne contenant des valeurs

Oracle University and OMNIDATA. use only

Copyright © 2007, Oracle. Tous droits réservés.

Insérer de nouvelles lignes