2015 01 04 Cours SGBD

Direction Générale Institut Supérieur des
Des Etudes Technologiques Etudes

******** DGET ******* Technologiques du Kef
Support de cours
« SGBD »
Réalisé par :
BOUKCHIM Mosaab
(AT-Iset de Kef)
HOSNI Anis
(AT-Iset de Kef)
Niveau : Quatrième niveau en Informatique

Option : Informatique de gestion, Réseaux informatique
Version : 1.0
PLAN
Chapitre 1 : Introduction aux bases de données...................................4

1-Introduction.........................................................................4
2-Définitions ...........................................................................4
3-Architecture ANSI/SPARC d’un SGBD : ...........................4
4-Historique des SGBD .........................................................5
5-Propriétés des bases de données relationnels ...............5
Chapitre 2 : Installation de Oracle 9i ...................................................7
1-Objectifs ..............................................................................7
2-Ressources .........................................................................7
3-Création d'une première base de données ....................12
4-Configuration de la connectique.....................................19
5-Ma première connexion ...................................................29
Chapitre 3 : SQL..................................................................................30
1- Interrogation : l’ordre SELCT .........................................30
2- Les jointures : ..................................................................30
2.1 L’équijointure :........................................................................................................... 31
2.2 La non équijointure : .................................................................................................. 31
2.3 Autojointure : ............................................................................................................. 31
2.4 Jointure externe : ........................................................................................................ 31
3- Les fonctions de groupe.................................................32
3.1 Objectifs: .................................................................................................................... 32
3.2 Définitions :................................................................................................................ 32
3.3 Quelques fonctions de groupe : .................................................................................. 32
3.4 Exemples d’utilisation de AVG,SUM,MAX,MIN : .................................................. 33
3.5 Utilisation de la fonction COUNT : ........................................................................... 33
3.6 Utilisation de la fonction NVL :................................................................................ 34
3.7 Création de groupe de données , la clause GROUP BY : ......................................... 34
3.8.Restriction de groupes, HAVING .............................................................................. 35
4- Les sous interrogations..................................................35
4.1 Sous-interrogation ramenant une seule valeur (monoligne) ...................................... 35
4.2 Sous-interrogation ramenant plusieurs lignes (multiligne) ........................................ 35
4.3 Sous-interrogation ramenant plusieurs colonnes (multicolonnes) ............................. 36
4.4Sous-interrogation synchronisée avec l'interrogation principale ................................ 36
4.5 Sous-interrogations multiples..................................................................................... 37
5- Les opérateurs ensemblistes :.......................................38
5.1 Objectifs : ................................................................................................................... 38
5.2 Opérateur UNION ...................................................................................................... 38
5.3 Opérateur INTERSECT ............................................................................................. 39
5.4 Opérateur MINUS ...................................................................................................... 39
5.5 Opérateur UNION ALL : ........................................................................................... 39
5.6 Remarques :................................................................................................................ 39
6- Langage de manipulation de données LMD .................40
6.1 Définition ................................................................................................................... 40
6.2 Ajout de lignes :INSERT ........................................................................................... 40
6.3 Modification de lignes : UPDATE............................................................................. 40
6.4 Suppression de lignes : DELETE............................................................................... 41
7- Lanagae de définition de données LDD ........................41
7.1 Les types de données en SQL .................................................................................... 41
7.2 Les contraintes............................................................................................................ 42
7.3 L’ordre CREATE Table :pour la création d’une table............................................... 42
7.4 L’order ALTER TABLE :.......................................................................................... 43
8. Langage de contrôle de données LCD ..........................44
8.1 Les transactions dans SQL : COMMIT et ROLLBACK ........................................... 44
Chapitre 4 : La langage PL/SQL ........................................................45
1- Introduction......................................................................45
2- Structure d’un bloc PL/SQL............................................45
3- Les déclarations PL/SQL ................................................46
3.1 Types de données ....................................................................................................... 46
3.2 Variables et constantes ............................................................................................... 47
3.2.1. La définition des variables en PL/SQL .............................................................. 47
3.4. Les enregistrements prédéfinis (record PL/SQL)...................................................... 48
3.4.1 La déclaration d'un enregistrement ..................................................................... 48
3.4.2 L'accès aux champs d'un enregistrement............................................................. 48
4-Structure de controle .......................................................49
4.1. Les traitements Conditionnels................................................................................... 49
4.2 Les Traitements.Répétitifs ......................................................................................... 50
4.2.1. l’instruction LOOP............................................................................................. 50
4.2.2. L'instruction FOR …LOOP ............................................................................... 50
5. LES CURSEURS EN PL/SQL...........................................51
5.1. Définition .................................................................................................................. 51
5.2. Les types de curseurs................................................................................................. 51
5.3. Les étapes d'utilisation d'un curseur explicite ........................................................... 51
5.3.1. La déclaration d'un curseur ................................................................................ 51
5.3.2. L'ouverture et la fermeture d’un curseur ............................................................ 51
5.3.3. Le traitement des lignes...................................................................................... 52
5.4 Les attributs d’un curseur........................................................................................... 53
5.4.1 l’attribut %Found ................................................................................................ 53
5.4.2. L'attribut %NotFound......................................................................................... 54
5.4.3. L'attribut %IsOpen ............................................................................................. 55
5.4.4.'L'attribut %RowCount........................................................................................ 55
5.4.5. L'attribut %Rowtype .......................................................................................... 56
5.5. Les boucles et les curseurs ........................................................................................ 56
5.6. Le curseur paramètré................................................................................................. 57
5.7. La clause "current of…"............................................................................................ 58
6 Utilisation de sous-programmes.....................................58
6.1 Déclaration d’une procédure ...................................................................................... 58
6.2 Déclaration d’une fonction......................................................................................... 59
7. GESTION DES ERREURS................................................60
7.1. Les exceptions internes ............................................................................................. 60
7.2. Les exceptions utilisateur (externes) ......................................................................... 62
Annexe1 : Complément de cours : les fonctions .................................63
1- Expressions et fonctions arithmétiques .......................63
1.1 Opérateurs arithmétiques............................................................................................ 63
1.2 Priorité des opérateurs................................................................................................ 63
1.3 Fonctions arithmétiques ............................................................................................. 63
2- Expressions et fonctions sur les chaînes de caractères
...............................................................................................64
2.1 Opérateur sur les chaînes de caractères...................................................................... 64
2.2 Fonctions sur les chaînes de caractères ...................................................................... 65
3- Expressions et fonctions sur les dates.........................66
3.1 Opérateurs sur les dates.............................................................................................. 66
3.2 Fonctions sur les dates................................................................................................ 66
SYSDATE.................................................................................................................... 66
4- Fonctions de conversion ................................................66
5- Autres fonctions ..............................................................68
LEAST ......................................................................................................................... 68
Annexe 2 : Gestion des utilisateurs et des privilèges..........................69
I-Gestion des utilisateurs :..................................................69
1-Création d’un utilisateur : ............................................................................................. 69
2-Modification d’un utilisateur : ...................................................................................... 70
3-Suppression d’un utilisateur.......................................................................................... 70
II-Gestion des privilèges : ...................................................70
1-Gestion des privilèges au niveau système :................................................................... 70
a-Attribution d’un privilège: ........................................................................................ 70
b-Suppression d’un système :....................................................................................... 71
c-Exemple de privilège système :................................................................................. 71
2-Gestion de privilèges objets .......................................................................................... 71
a-Attribution de privilèges : ......................................................................................... 71
b-suppression de privilège :.......................................................................................... 71
c-exemple de privilèges objets ..................................................................................... 71
Annexe 3 : Gestion d’une base de données .........................................72
1- Création d’une base de données: ..................................72
2- Démarrage de la base : ...................................................73
3- Arrêt de la base : .............................................................73
Présentation du cours
Ce cours s’intitule « SGBD ». Il est destiné aux étudiants du quatrième niveau option Réseaux
Informatiques et Informatique de gestion au sein des Instituts supérieurs des études
technologiques.
Pré requis :
Ces étudiants ont déjà vu le cours « fichiers et base de données » en deuxième niveau. Donc,
plusieurs définitions et termes ne leur sont pas étrange, ainsi que la conception d’une base de
donnée en utilisant MERISE. Leurs travaux pratiques ont été réalisé avec Microsoft Access.
Objectif général :
Comprendre :
- les concepts des bases de données
- l’utilité de leur utilisation
- maîtriser l’interrogation, la manipulation et la gestion d’une base de données
Objectifs spécifiques :
Objectifs spécifiques Eléments de contenu
Avoir une idée sur l’évolution des SGBD. Définition de BD
Définition de SGBD
Architecture ANSI/SPARC
Les trois générations des SGBD
Bien saisir les contraintes sur les tables et leur PRIMARY KEY
utilité autant que règles de gestion. FOREIGN KEY
UNIQUE
CHECK
NOT NULL
Comment créer une base de données, ses - CREATE DATABASE
tables et comment les modifiés (LDD de - CREATE TABLE
SQL). - ALTER TABLE
Savoir interroger une BD en vue d’extraire et L’ordre SELECT
d’afficher des informations spécifiques. Les fonctions de groupe
Les jointures
Les sous interrogations
Les opérateurs ensemblistes
Connaître les commandes nécessaires de mise INSERT
à jour de données (LMD de SQL). UPDATE
DELETE
Se familiariser avec le langage PL/sql Les types de données
Les variables
Les structures conditionnels
Les structures répetitives
Les blocs Pl/sql
Comprendre l’utilité des procédures et CREATE PROCEDURE
fonctions stockés. CREATE FUNCTION
Saisir le rôle des déclencheurs CREATE TRIGGER
Pouvoir créer et supprimer des utilisateurs CREATE USER
DROP USER
Gérer les privilèges objets et systèmes GRANT
REVOKE
Savoir valider et annuler la mise à jour de COMMIT
donnés ROLLBACK
Pré-requis :
Windows, BD, Access.
Formule pédagogique :
Exposé informel
Laboratoire
Moyens pédagogiques :
Tableau
Support de cours
Méthodologie :
Cours intégré
Travaux dirigés (réalisation et correction d’exercices)
Travaux pratiques ( Oracle)
Evaluation :
Interrogations écrites
Devoir surveillé
Examens de travaux pratiques
Examen final
Volume Horaire :
22,5 heures de cours intégré
45 heures de travaux pratiques
Bibliographie
• Oracle Corporation Documentation
• NETG Documentation Skill Builder

Network Education Training Group
• Pack OCP DBA Oracle 9i EXAM

Edition : Oracle Press
• Les bases de données Oracle 8i

Développement, administration ,optimisation
Auteur :Roger Chapuis
Edition DUNOD
• Bases de données Objet et Relationnel

Auteur :Georges Gardarin
Edition EYROLLES
• SGBD avancés : Bases de données objets, déductives, réparties.

Auteurs :G.Gardarin, P.valduriez
Edition EYROLLES
Netographie
• www.developpez.com/cours/sql-Oracle
• www.oracle.com
• www.otn.com
Cours SGBD Oracle Hosni.A & Boukchim.M
Chapitre 1 : Introduction aux bases de données
Introduction
Les bases de données ont pris aujourd’hui une place essentielle dans l’informatique, plus
particulièrement en gestion .Au cours des 40 dernières années : des concepts, méthodes et
algorithmes ont été développés pour gérer des données sur mémoires secondaires ; ils
constituent aujourd’hui l’essentiel de la discipline « base de données ».
1- Définitions
Une base de données est un ensemble de données modélisant les objets d’une partie de monde
réel et servent de support à une application informatique.
Un SGBD peut être perçu comme un ensemble de logiciels systèmes permettant aux
utilisateurs d’insérer, de modifier et de rechercher efficacement des données spécifiques dans
une grande masse d’informations partagée entre plusieurs utilisateurs.
Un SGBD est un outil informatique qui permet la sauvegarde, l’interrogation ,la recherche et
la mise en forme de données stockées sur mémoires secondaires. Ce sont des fonctions
premières, complétés par des fonctions souvent plus complexes destinés par exemple à
assurer le partage de données mais aussi à protéger les données contre tout incident et à
obtenir des performances acceptables.
3-Architecture ANSI/SPARC d’un SGBD :
Niveau externe
Niveau
conceptuel
Niveau
interne
Figure 1 : Architecture ANSI/SPARC

Uns SGBD se compose de trois couches de fonctions emboîtés, depuis les mémoires
auxiliaires vers les utilisateurs :
- La gestion des récipients des données sur les mémoires secondaires constitue
traditionnellement la première couche : le gestionnaire de fichiers, appelé encore SGF.
Celui-ci fournit aux couches supérieurs des mémoires secondaires idéales adressables
par objets et capable de recherche par le contenu des objets (mécanisme d’indexation
notamment).
- La gestion des données stockées dans les fichiers, l’assemblage de ces données en
objets, le placement de ces objets dans les fichiers, la gestion des liens entre objets et
la gestion de structures permettant d’accélérer les accès aux objets constituent la
deuxième couche, c’est le système d’accès aux données ou SGBD interne. Celui-ci
repose généralement sur un modèle de données interne, par exemple des tables reliées
par des pointeurs.
- La fonction essentielle de la troisième couche consiste dans la mise en forme et les
présentation des données aux programmes d’application et aux utilisateurs interactifs
d’une part et d’autres part, l’analyse et l’interprétation des requêtes utilisateurs en
primitives interne.
A.U 2007/2008 4/75

4-Historique des SGBD

L’histoire d’un SGBD peut être résumé en trois générations :
- La première génération s’appuie sur les modèles de données hiérarchiques et réseau.
Elle vise à étendre un système de fichiers(l’ancêtre des SGBD) par des possibilités de
liaisons inter fichiers matérialisée par des pointeurs.
Un SGBD de première génération fournit une faible indépendance physique
compliquant ainsi l’administration et la manipulation des données.
En particulier, son langage de manipulation de données navigationel impose au
programmeur de spécifier l’accès aux données en naviguant dans le graphe da la base.
- La deuxième génération de SGBD est née vers 1970 avec l’apparition du modèle de
données relationnel.
Une dizaine d’années d’efforts, de recherche et de développement furent nécessaire
pour aboutir à la commercialisation des premiers SGBD relationnels. Depuis la
technologie des bases de données relationnels a fait l’objet de progrès remarquables en
termes de facilité d’usage et de performance.
Aujourd’hui tout SGBD relationnel offre un ensemble intégré d’outils basées sur un
langage de quatrième génération afin d’accroitre la productivité des utilisateurs. Aussi
certains systèmes supportent efficacement les applications transactionnelles, très
exigeantes en performances. En conséquence, le marché actuel des bases de données
est couvert en grande majorité par les SGBD relationnels.
La première et deuxième génération d’SGBD on été conçus pour les applications de gestion
classique, comme par exemple la gestion de stocks ou la comptabilité d’une entreprise.
Ces SGBDs sont généralement implantés comme une couche externe d’un système opératoire
installé sur un calculateur.
Deux tendances complémentaires récentes soulignent les limites de ces systèmes :
a-/ La première est la manifestation de besoins pressants en gestion de données de la part
d’applications nouvelles tel que le bureautique, la conception assistée par ordinateur(CAO) et
le génie logiciel qui se singularisent par rapport aux applications traditionnelles
b-/La seconde tendance est la diversité croissante des environnements informatiques
essentiellement décentralisée qui favorisent la répartition et l’hétérogénéité des données.
- la troisième génération des SGBDs désignent des systèmes qui supportent bien ces
applications nouvelles ou exploitent des environnements opérationnels complexes
(répartis, parallèles ou hétérogènes).
Cette nouvelle génération, initiée dans quelques laboratoires de recherche vers la fin des
années1970, fiat depuis ce temps l’objet de travaux de recherche et de développement
intenses.
5-Propriétés des bases de données relationnels

Le modèle relationnel inventé par Codd, peut être introduit informellement par les trois
propriétés suivantes :
a- Les structures de données sont simples et se construisent à partir de la théorie des
ensembles. Ce sont des tables à deux dimensions dont chaque élément appartient à un
ensemble de valeurs appelé domaine. Puisqu’elle définit une relation entre des domaines, une
telle table est appelé aussi relation .Une colonne d’une relation appelé attribut est définie sur
un même domaine. Une ligne d’une relation appelé n-uplet ou tuple, relie logiquement les
éléments d’informations fournis par les valeurs d’attributs.
Toute information de la base de données doit être représentée explicitement par des valeurs
dans des tables.
A.U 2007/2008 5/75

b- Un ensemble d’opérateurs appliqués à des relations, constituant l’algèbre

relationnelle, permet la définition, la recherche et la mise à jour des données. Chaque
opérateur prend une ou deux relations en arguments et produit une relation.
L’algèbre relationnelle comprend les opérateurs classiques de la théorie des ensembles(
produit cartésien, union, intersection, différence) et des opérateurs permettant de composer
des sous ensembles d’une ou de relations(projection, restriction, jointure et division).
c-Un ensemble de contraintes sémantiques définit les états cohérents de la base de

données. Il existe au minimum deux contraintes d’intégrité structurelles :
• la première est l’unicité de clé, qui spécifie qu’un ou plusieurs

attributs constituent la clé unique d’une relation. Par exemple ,NSS
est la clé unique de la relation Personne.
• La seconde est la contrainte de référence, qui permet de garantir que
la valeur d’une donnée dans une relation est présente dans une autre
relation.. Par exemple, un produit commandé , référencé dans la
relation commande doit exister aussi dans la relation produit.
L’avantage majeur d’un SGBD relationnel est sa faculté à assuré l’indépendance complète
entre la description des données logiques( en termes relationnels) et physiques ( en termes de
fichiers et liaisons inter-fichiers). Cette indépendance a permis le développement de langages
de définition et de manipulation de données de haut niveau appelé langage de requêtes, au
dessus de l’algèbre relationnelle.
Ces langages sont typiquement assertionels, c'est-à-dire basé sur la logique des prédicats et
libèrent le programmeur de la spécification des chemins d’accès aux données.
En conséquence l’optimisation des requêtes de manipulation de données peut être entièrement
automatisée. L’existence du langage de requêtes standard SQL [ANSI 86] contribue d’ailleurs
fortement à la promotion du modèle relationnel.
SQL fournit une interface uniforme aux administrateurs, programmeurs d’applications et
utilisateurs finals, pour la définition, le contrôle et la manipulation des données. Un autre
avantage de cette indépendance physique est de fournir une base solide pour l’aide à la
conception des schémas conceptuels et internes. Le plupart des SGBD commercialisés
supportent le langage SQL. De plus ils offrent généralement un ensemble intégré d’outils
L4G( générateur d’applications, gérant de menu et de fenêtres, aide à la conception de
schémas,..) qui facilite le développement des applications base de données et améliore ainsi la
productivité des utilisateurs. La réalisation de ces outils a été facilitée par la simplicité et la
puissance du modèle relationnel.
A.U 2007/2008 6/75

Chapitre 2 : Installation de Oracle 9i
1-Objectifs
Ce chapitre a pour unique but de donner à l’étudiant une méthode pour installer Oracle 9i pas-
à-pas.
2-Ressources
Sachez avant tout que, comparativement à ses concurrents, Oracle est extrêmement gourmand
en ressources (mémoire et disque). Il est en effet très difficile de dissocier le moteur SGBDR
des composants annexes, ceux-ci étant plus ou moins incorporés à l'installation. Partant
installer un moteur SGBDR, vous vous trouverez sans vous en rendre compte avec un
environnement complet de développement, un serveur applicatif Apache, un pare-feu, etc.
Expérience douloureuse faite, assurez-vous
* d'avoir des droits Administrateurs/root
* d'avoir installé au préalable un JDK 1.1.3 sur la machine cible
Taille (sous
Installation
Windows)
Entreprise (version complète) 2.59 Go
Standard 2.46 Go
Personnelle (mono-utilisateur) 2.49 Go
Client administrateur 798 Mo
3-Installation du logiciel
Insérons le premier des 3 CDs.
Si l'autorun ne démarre pas, lançons manuellement setup.exe

Cliquons ensuite sur Démarrer l'installation ou, si vous n'en êtes pas a votre première
installation, sur Installer/Désinstaller les produits
A.U 2007/2008 7/75

Remarquons que la langue utilisée par l'Installer dépend de celle utilisée par votre système
d'exploitation.
Si une version Oracle n'est plus utile et existe encore, commencez par la supprimer via le
bouton Désinstaller les produits. Sinon, bouton Suivant.
A.U 2007/2008 8/75

C'est ici que nous déterminons la variable ORACLE_HOME, c'est-à-dire l'endroit physique
où le logiciel Oracle sera installé. Choisissez d'emblée un disque sur lequel il y a 3Go de libre
(hormis pour une installation pure cliente).
Choix du produit à installer. Nous sommes intéressés à installer le serveur et son client sur
notre machine et choisissons donc la 1ère option.
Notez le bouton Langue du produit
Si celà vous intéresse, vous pouvez toujours ajouter un langage. Sinon, si l'anglais vous suffit,
vous pouvez allègrement sauter ce menu.
Passons maintenant au choix des produits à installer
A.U 2007/2008 9/75

Choisissons l'installation standard afin de ne pas se priver du plaisir de configurer la couche

réseau
Dans son processus d'installation, Oracle inclut la création de la 1ère base. Par soucis de
clarté, nous dissocierons ces 2 processus et exécuterons cette tâche dans le chapitre suivant.
Voici donc le résumé des options choisies
A.U 2007/2008 10/75

Si quelque chose vous semble inexacte, il est encore temps de revenir en arrière pour apporter
les corrections voulues.
A.U 2007/2008 11/75

Et c'est parti : le temps d'une bonne pause café...
... qui ne devrait pas vous faire oublier de changer les CDs !
Voilà, c'est fini. Pendant tout ce temps, Oracle a même pris le temps de configurer un serveur
http Apache.
Vous pouvez choisir le bouton Quitter.
L'installation du logiciel s'est apparemment bien déroulée.
3-Création d'une première base de données

Notons que pour l'instant, certains services ont été installes sous XP, mais aucun n'est
démarré. Voici leur liste exhaustive:
Nom du service Status Startup Type
Oracle OLAP 9.0.1.0.1 Manual
Oracle OLAP Agent Manual
OraclOracle9iAgent Automatic
OracleOracle9iClientCache Manual
A.U 2007/2008 12/75

OracleOracle9iHTTPServer Automatic
OracleOracle9iPagingServer Manual
OracleOracle9iSNMPPeerEncapsulator Manual
OracleOracle9iSNMPPeerMasterAgent Manual
Pour démarrer sans douleurs, nous allons créer notre première base de données en utilisant
l'assistant : Menu Oracle - Oracle9i -> Configuration and Migration Tools -> Database
Configuration Assistant.
Nous voulons créer une base. Choisissons donc la 1ère option.
A.U 2007/2008 13/75

Pour permettre à l'assistant de configurer la base de données le plus correctement possible, un

choix s'offre à vous:
Si vous décidez d'optimiser votre base pour l'utilisation de selects massifs sur de très grosses
tables, au détriment des modifications, choisissez l'option Datawarehouse
Choisissez Transaction Processing si votre environnement est axé sur des mise à jour
nombreuses et concurrentes, avec un grand nombre d'utilisateurs.
Si c’est une utilisation classique, optez pour General Purpose.
A.U 2007/2008 14/75

Voici 2 informations primordiales qu'il vous faut saisir et ne pas mélanger.... et dont il faudra
vous souvenir.
* le nom global Oracle (de type NomDeLaBase.domain.extension)
* l'identificateur systeme Oracle, ou SID. Ce dernier ne devait pas dépasser 4 caractères dans
les versions précédentes, cette limite a fort heureusement été bannie dans la version 9.
Nous allons maintenant definir comment Oracle va gérer ses connexions utilisateurs. Dans
notre cas de figure (peu d'utilisateurs concurrents), nous pouvons opter pour la première
option.
A.U 2007/2008 15/75

Compte tenu que le poste que l'on utilise n'est visiblement pas dédie à Oracle, on ne lui
attribue que 50% de la mémoire disponible (en espérant que celà soit suffisant: dans mon
exemple, la machine a 512Mo de RAM).
A.U 2007/2008 16/75

Oracle a défini pour nous un certain nombre de fichiers (de contrôle, de données, de redo log,
de journalisation...). Plus tard, vous pourrez les déplacer pour des raisons de place, de
sécurité, ... Nous nous contentons pour l'instant aux valeurs par défaut.
Nous pourrions ici sauvegarder nos options comme base model. Nous n'aurons pas pour
l'instant cette prétention.
A.U 2007/2008 17/75

Voici un recapitultif des options que nous avons choisies. Après une dernière validation, la
génération de la base commence.
Chaque base de données est accessible par des utilisateurs particuliers. Nous allons pouvoir
les gérer dans l'écran qui suit.
A.U 2007/2008 18/75

Relevons les deux utilisateurs Oracle système que sont SYS et SYSTEM.
Dès la version 9.0.2, le système vous demande de leur spécifier un mot de passe bien
particuliers, ceci pour faire fi des problèmes de sécurité relatifs aux mots de passe par défaut
(avant, seul SYS devait être changé, SYSTEM pouvant maintenir le mot de passe manager
Lorsque ceci est fait, la génération de la base est terminée.
4-Configuration de la connectique
Etant en architecture Client/Serveur, il va falloir maintenant configurer la couche réseau avec
que Serveur et Clients puissent communiquer. Démarrons donc le programme Oracle -
Oracle9i -> Configuration and Migration Tools -> Net Configuration Assistant.
A.U 2007/2008 19/75

Voici le menu principal de l'assistant. Nous allons commencer par le module d'écoute du
serveur.
Nous choisissons donc d'ajouter un module d'écoute. Par ce biais, nous autorisons le serveur
Oracle à écouter sur un port particulier de la machine si un client lui envoie une requête.
A.U 2007/2008 20/75

Déterminons un nom pour ce module d'écoute.
Nous devons choisir un protocol réseau (au minimum) qui sera utilisé. Nous optons pour le
protocole le plus répandu, à savoir le TCP-IP.
Nous déterminons le port d'écoute. Ici, deux écoles s'affrontent pour des raisons de sécurité:
les DBAs qui prônent le maintient du port par défaut qu'Oracle propose (1521), et ceux pour
lesquels ceci constitue une faille dans la sécurité. Partant du fait que la plupart des serveurs
dignes de ce nom incorporent un pare-feu (firewall), nous garderons pour commencer le port
par défaut.
A.U 2007/2008 21/75

Pour l'instant, un seul module nous suffit.
Choisissons maintenant une méthode de résolution de noms.
A.U 2007/2008 22/75

Voici les divers choix qui s’offrent à nous. Il est inutile de compliquer en ajoutant trop de
résolution. Normalement, le système en a présélectionné une par défaut.
Fin de la configuration de la résolution des nom (en fait, il n'y avait rien à faire).
A.U 2007/2008 23/75

Après avoir configuré le serveur pour qu’il écoute le client, il va nous falloir configurer le
client pour qu'il sache à qui parler.
Pour chaque client, il faudra donc configurer un service réseau en local. On le verra plus tard,
la distribution d'un unique fichier sur tous les clients sera suffisante.
Compte tenu de quelques problèmes de compatibilité descendante avec les versions pré-8, il
est nécessaire de spécifier si le serveur utilise une version plus ou moins récente.
A.U 2007/2008 24/75

Donnons ensuite un nom au service. Par habitude on donne généralement le nom SID
Voici venu le temps du choix du protcole. C'est le protocole TCP-IP qui s'impose
généralement.
Le serveur de données va utiliser un port d'écoute pour communiquer avec ses clients. Il faut
donc spécifier
A.U 2007/2008 25/75

* l'adresse IP de la machine hébergeant le serveur Oracle (ou son nom s'il est reconnu par le
DNS)
* le numéro de port sur lequel il communiquera. En standard, Oracle utilise le port 1521. Si
vous avez activé un pare-feu sur le serveur, n'oubliez pas d'ouvrir ce port.
Cet écran vous permet alors de tester la connectivité ainsi configurée. Il est fortement
conseillé de perdre quelques minutes à ce test
.
Si, comme moi, vous avez modifié les logins par défaut, vous pourriez vous retrouver avec ce
type d'erreur. Pas de panique, il suffit juste de changer de connexion grâce au bouton adéquat.
A.U 2007/2008 26/75

Voilà, calibré sur ce que nous avions spécifié lors de la configuration des utilisateurs
Visiblement, tout est en ordre maintenant.
Nous attribuons maintenant un nom au service réseau précédemment créé. Il va nous faciliter
la tâche plus tard.
A.U 2007/2008 27/75

Il est possible de configurer plusieurs services. Nous ne sommes pas intéressés ici.
Voilà! La configuration de la couche réseau est faite.

Installation via fichier de réponses
Si vous ne souhaitez pas rester derrière votre écran à remplir cet ensemble de boîtes de
dialogues, il est possible de lancer l'Installer en lui spécifiant un fichier de réponses qui fera,
lorsqu'il aura été correctement rempli, la majeure partie de ces tâches fastidieuses.
Exemple de fichier de réponses

[General]
RESPONSEFILE_VERSION=1.7.0
[SESSION]
FROM_LOCATION="w:\stage\products.jar"
FROM_LOCATION_CD_LABEL="Oracle9i"
NEXT_SESSION_RESPONSE=
ORACLE_HOME="d:\oracle\9i"
ORACLE_HOME_NAME="O9i"
TOPLEVEL_COMPONENT={"oracle.server","9.2.0.1.0"}
DEINSTALL_LIST={"oracle.server","9.2.0.1.0"}
SHOW_SPLASH_SCREEN=false
SHOW_WELCOME_PAGE=false
SHOW_COMPONENT_LOCATIONS_PAGE=false
SHOW_CUSTOM_TREE_PAGE=false
SHOW_SUMMARY_PAGE=FALSE
SHOW_INSTALL_PROGRESS_PAGE=TRUE
SHOW_REQUIRED_CONFIG_TOOL_PAGE=FALSE
SHOW_OPTIONAL_CONFIG_TOOL_PAGE=false
SHOW_RELEASE_NOTES=false
SHOW_END_SESSION_PAGE=false
SHOW_EXIT_CONFIRMATION=false
NEXT_SESSION=false
A.U 2007/2008 28/75

NEXT_SESSION_ON_FAIL=false
SHOW_DEINSTALL_CONFIRMATION=FALSE
SHOW_DEINSTALL_PROGRESS=true
LOCATION_FOR_DISK2="W:\"
LOCATION_FOR_DISK3="W:\"
[oracle.server_9.2.0.1.0]
COMPONENT_LANGUAGES={"fr"}
INSTALL_TYPE="EE"
s_cfgtyperet="Software Only"
[oracle.options.ops_9.2.0.1.0]
s_rawDeviceName=
[oracle.apache_9.2.0.1.0]
s_jservPort=
s_apachePort=
b_autoStartApache=
Des exemples de fichiers similaires se trouvent sous le CD d'installation 1, dans le répertoire

Response.
Modifiez-le donc à voter convenance, et lancez-le via
C:\>setup -responsefile c:\temp\monInstallO9i.res
... dans la mesure où votre CD est l'unité C: et votre fichier de réponses a été sauvegardé sous
c:\temp\monInstallO9i.res
5-Ma première connexion

Exemple sous Windows, dans une fenêtre de commande
Microsoft Windows 2000 [Version 5.00.2195]
(C) Copyright 1985-2000 Microsoft Corp.
C:\>sqlplus system/MotDePasse@ORACLEDB
SQL*Plus: Release 9.2.0.1.0 - Production on Ma Fev 3 14:02:15 2004
Copyright (c) 1982, 2002, Oracle Corporation. All rights reserved.
ConnectT a :
Oracle9i Enterprise Edition Release 9.2.0.1.0 - Production
With the Partitioning, OLAP and Oracle Data Mining options
JServer Release 9.2.0.1.0 - Production
SQL> desc DICTIONARY

Nom NULL ? Type
----------------------------------------- -------- -----------------------
-----
TABLE_NAME VARCHAR2(30)
COMMENTS VARCHAR2(4000)
SQL>exit
A.U 2007/2008 29/75

Chapitre 3 : SQL
1- Interrogation : l’ordre SELCT

Le syntaxe complet d’un ordre SELECT
SELECT col, col, ..

FROM nom_table
[WHERE condition [ OR | AND condition]]
[GROUP BY col, col, ..]
[HAVING condition [ OR | AND condition]]
[ORDER BY col, col, …]
L’ordre SELECT permet l’interrogation d’une base de données afin d’afficher des données.
Il permet :
La projection
La selection
La jointure
La clause SELECT contient la liste de colonnes qui vont etre affichés comme résultat. La
clause FROM spécifie la ou les tables dans laquelle , la recherche va etre éffectuée. La clause
WHERE spécifie une condition de selection de quelques enregistrements de l’ensemble de
données de la tables.
Exemple : afficher le nom et le salaire de chaque employé :
Réponse :
Select ename, sal
From emp ;
Exemple :afficher les jobs des employés de département 20
Réponse :
Select job
From emp
Where deptno=20
2- Les jointures :
Une jointure a pour but d’afficher des informations issus de plusieurs tables.
Quand on précise plusieurs tables dans la clause FROM, on obtient le produit cartésien des
tables. Ce produit cartésien n’a aucun intérêt. Ce qui est normalement souhaité, c'est de
joindre les informations de diverses tables, en recollant les lignes des tables suivant les
valeurs qu'elles ont dans certaines colonnes.
Exemple : afficher le nom de l’employé et le nom de son département.
Dans cet exemple, le nom de l’employé se trouve dans la table « emp », tandis que le nom de
département se trouve dans « dept ». c’est la colonne deptno qui existe dans les deux tables
qui va assurée leur liaison.
IL y quatres types de jointures :
L’équijointure
La non équijointure
L’autojointure
La jointure externe.
A.U 2007/2008 30/75

2.1 L’équijointure :
Appelé encore jointure simple ou naturelle, basé sur l’égalité des valeurs de deux colonnes
dans deux tables différentes. Par exemple , une clé primaire d’une table et la clé étrangère qui
lui correspond dans une autre table.
Exercice : afficher le nom de l’employé numéro 7800, et le nom de son département.
Dans cet exemple, le nom de l’employé se trouve dans la table « emp », tandis que le nom de
département se trouve dans « dept ». c’est la colonne deptno qui existe dans les deux tables
qui va assurée leur liaison.
Réponse :
Select ename, dname
From emp, dept
Where empno=7800 ;
2.2 La non équijointure :

La relation entre la table « emp » et la table « salgrade » est une nonéquijointure car aucune
colonne de la table « emp » ne correspond directement à une colonne de la table « salgrade».
La relation qui existe entre les deux tables est la suivante : les valeurs de la colonne SAL
De la table « emp » sont comprises entre les valeurs des colonnes « LOSAL » et « HISAL »
de la table « SALGRADE ». Il faut donc utiliser un autre opérateur que le signe « = » pour
effectuer une jointure.
Exercice : afficher pour chaque employé , son salaire et son grade.
Réponse :
Select ename, sal, grade
From emp, salgrade
Where sal betwenn losal and hisal
2.3 Autojointure :
L’autojointure est une liaison d’une table à elle-même. C'est-à-dire, utiliser la meme table
deux fois, la premiere pour cherche une valeur X à partir de données, et la deuxieme est de
trouver le résultét final à partir de X.
Exercice : afficher le nom du directeur de l’emloyé numéro 7800.

Réponse :
select e.ename
from emp e, emp p
where e.empno = 7800 and e.mgr = p.empno ;
Les serveur Oracle exécute cet ordre en trois étapes :

- parcourir la colonne « empno » de la table « emp » en cherchant la valeur 7800.
- Lire la valeur « mgr » de cet employé :6200
- Chercher 6200 dans la colonne « empno » et lire le nom de directeur dans la
colonne « ename »
2.4 Jointure externe :

La jointure externe permet de visualiser les lignes qui ne rependent pas à la condition de
jointure. L’opérateur de jointure externe est le signe (+). Il se place du coté de la jointure ou
l’information est incomplète.
A.U 2007/2008 31/75

Il crée une ou plusieurs lignes NULL auquel une ou plusieurs lignes de la table complete sont
liées.
Exercice : afficher les nom des départements et les noms de leur département meme les
départements ne contenant pas d’employé :
Réponse :
Select d.dname, e.ename
From emp e, dept d
Where e.deptno (+) = d.deptno ;
3- Les fonctions de groupe

3.1 Objectifs:
A la fin de cette partie vous aurez :
- Identifier les fonctions de groupe disponibles
- savoir regrouper les données avec la clause GROUP BY
- savoir inclure et exclure des groupes par la clause HAVING
3.2 Définitions :
Les fonctions de groupe agissent sur des groupes de lignes et donne un résultat par groupe
Table « emp »
empno … job … sal

1100 ….. CLERK 500 … Le plus grand salaire ???
1110 SALESMAN 600 MAX(sal)
…….
…..
3.3 Quelques fonctions de groupe :
AVG(col) moyenne
SUM(col) somme
MIN(col) plus petite des valeurs
MAX(col) plus grande des valeurs
COUNT(*) nombre de lignes
COUNT(col) nombre de valeurs non nulles de la
colonne
COUNT(DISTINCT col) nombre de valeurs non nulles
distinctes
A.U 2007/2008 32/75

3.4 Exemples d’utilisation de AVG,SUM,MAX,MIN :
AVG et SUM sont utilisées avec les données numériques.

Exemple :
select AVG(sal), SUM (sal), MIN(sal), mAX (sal)
from emp ;
MIN et MAX s’utilisent avec tout type de données.
Exemple :
SQL>Select MIN (hiredate), MAX(hiredate)
From emp ;
MIN(hiredate) MAX(hiredate)
21-JAN-1981 26-MAR-1992
SQL>Select MIN (ename), MAX (ename)

From emp ;
MIN (ename) MAX (ename)

ADAMS WARD
3.5 Utilisation de la fonction COUNT :

COUNT(*) ramène le nombre de ligne d’une table.
Exercice : afficher le nombre d’employé de département 30
Réponse :
SQl> Select count(*)
From emp
Where deptno = 30 ;
Count (*)
26
Exercice : afficher le nombre d’employé de département 10, qui ont une commision :
Réponse :
SQl> Select count(comm)
From emp
Where deptno = 10 ;
Exercice : nombre de départements possédant des employés.

Réponse
SQl> Select count( distinct ( deptno ))
From emp ;
A.U 2007/2008 33/75

3.6 Utilisation de la fonction NVL :

la fonction NVL force la prise en compte des valeurs NULL dans les fonctions de groupe en
remplaçant la valeur NULL par une autre valeur.
Exercie :
SQL> Select AVG( NVL ( comm , 0 ))
From emp ;
3.7 Création de groupe de données , la clause GROUP BY :
empno … job … sal Deptno AVG(sal)

1100 ….. CLERK 500 … le salaire moyen
10 1500
1110 SALESMAN 600
par département 20 1300
……. 30 1350
…..
Il est possible de subdiviser la table en groupes, chaque groupe étant l'ensemble des lignes
ayant une valeur commune.
Syntaxe :
Select colonne, fonction_de_groupe
From table
[ where condition]
GROUP BY exp1, exp2,...
La clause GROUP BY groupe en une seule ligne toutes les lignes pour lesquelles exp1,
exp2,... ont la même valeur. Cette clause se place juste après la clause WHERE, ou après la
clause FROM si la clause WHERE n'existe pas. Des lignes peuvent être éliminées avant que
le groupe ne soit formé grâce à la clause WHERE.
Remarque : la clause GROUP BY doit inclure tout les colonnes de la liste SELECT qui ne
figure pas dans une fonction de groupement
Exercice : calculer le salaire moyen par département trié par salaire moyen.
Réponse :
SQL> Select deptno, AVG(sal)
From emp
Group by deptno
Order by AVG(sal)
Exercice :afficher la somme des salaires pour chaque poste ,regroupé par département.
Réponse :
Select deptno, job, SUM (sal)
From emp
Group by deptno, job ;
A.U 2007/2008 34/75

3.8.Restriction de groupes, HAVING

On ne peut pas utiliser la clause WHERE pour limiter les groupes. La clause HAVING
permet ceci.
Exercice : afficher le salaire moyen de chaque département ,qui dépasse 1300.
Réponse :
Select deptno, AVG (sal)
From emp
Group by deptno
HAVING AVG(sal) > 1300 ;
4- Les sous interrogations

Une caractéristique puissante de SQL est la possibilité qu'un critère de recherche employé
dans une
clause WHERE (expression à droite d'un opérateur de comparaison) soit lui-même le résultat
d'un
SELECT ; c'est ce qu'on appelle une sous-interrogation.
4.1 Sous-interrogation ramenant une seule valeur (monoligne)
Exercice : Quels sont les employés ayant la même fonction que JAMES ?
La fonction de JAMES est inconnu, d’où la nécessité d’utiliser une sous interrogation
ramenant cette
valeur
Réponse :
SQL> Select ename

From emp
Where job = (select job
From emp
Where ename=’JAMES’) ;
Remarques
- une sous-interrogation qui ne ramène aucune ligne se termine avec un code d'erreur.
- une sous-interrogation ramenant plusieurs lignes provoquera aussi, dans ce cas, une erreur
- avec une sous interrogations monolognes, on utilise un opérateur monoligne(=, !=, >, >=, <,
<=)
4.2 Sous-interrogation ramenant plusieurs lignes (multiligne)
Une sous-interrogation peut ramener plusieurs lignes à condition que l'opérateur de

comparaison
A.U 2007/2008 35/75

admette à sa droite un ensemble de valeurs. Les opérateurs permettant de comparer une valeur
à un
ensemble de valeurs sont :
- l'opérateur IN
- les opérateurs obtenus en ajoutant ANY ou ALL à la suite d'un opérateur de comparaison
classique (=, !=, >, >=, <, <=)
- ANY: la comparaison est vraie si elle est vraie pour au moins un des éléments de
l'ensemble.
- ALL: la comparaison sera vraie si elle est vraie pour tous les éléments de l'ensemble.
Exercice : Quels sont les employés gagnant plus que tous les employés du département 30.
Réponse :
Select ename
From emp
Where sal > ALL (select sal
From emp
Where deptno = 30) ;
4.3 Sous-interrogation ramenant plusieurs colonnes

(multicolonnes)
Il est possible de comparer le résultat d'un SELECT ramenant plusieurs colonnes à une liste
de colonnes. La liste de colonnes figurera entre parenthèses à gauche de l'opérateur de
comparaison.
Exercice : Quels sont les employés ayant même fonction et même supérieur que CODD?
Réponse :
Select ename
From emp
Where (job , mgr) = (select job ,mgr
From emp
Where ename= ‘CODD ‘) ;
4.4Sous-interrogation synchronisée avec l'interrogation principale
Dans les exemples précédents, la sous-interrogation était évaluée d'abord, puis le résultat
pouvait être utilisé pour exécuter l'interrogation principale. SQL sait également traiter une
sous- interrogation faisant référence à une colonne de la table de l'interrogation principale. Le
traitement dans ce cas est plus complexe car il faut évaluer la sous-interrogation pour chaque
ligne de l'interrogation principale.
Exercice : Quels sont les employés ne travaillant pas dans le même département que leur
supérieur hiérarchique ?
Réponse :
Select ename
From emp e
Where deptno < > (select deptno
A.U 2007/2008 36/75

From emp
Where empno=e.mgr)
Il a fallu ici renommer la table emp de l'interrogation principale pour pouvoir la référencer
dans la sous-interrogation.
4.5 Sous-interrogations multiples
Un SELECT peut comporter plusieurs sous-interrogations, soit imbriquées, soit au même

niveau dans différents prédicats combinés par des AND ou des OR.
Exercice : Afficher les noms et les jobs des employés qui ont le meme job que l’employé
numero 7800 et qui ont un salaire supérieur à celui de l’employé numéro 7654.
Réponse 1 :
SQL> Select ename

From emp
From emp
Where empno=7800)
AND
Sal > (select sal
From emp
Where empno = 7654) ;
Réponse 2 :
SQL> Select ename
From emp
From emp
Where empno=7800)
INTERSECT
Select ename
From emp
Where Sal > (select sal
From emp
Where empno = 7654) ;
Exercice :afficher le nom, le job et le salaire de tout les employés dont le salaire est égal au
salaire minimum des employés.
Réponse :
Select ename, sal, job
From emp
Where sal = (select MIN (sal)
From emp) ;
Exercice :afficher tout les départements dont le salaire minimum est supérieur au salaire
minimum de département 20.
A.U 2007/2008 37/75

Réponse
Select deptno
From emp
Group by deptno
Having MIN(sal) >( select MIN (sal)
From emp
Where deptno=20)
Exercice :trouver les jobs ayant le salaire moyen le moins élevé.

Réponse :
Select job , AVG (sal)
From emp
Froup by job
Having AVG(sal) = (select MIN ( AVG ( sal ) )
From emp
Group by job) ;
5- Les opérateurs ensemblistes :
5.1 Objectifs :
A la fin de cette partie, vous saurez :
- décrire les opérateurs ensemblistes
- utiliser un opérateur ensembliste pour combiner plusieurs requêtes en une seule
- vérifier l’ordre des lignes ramenées
Pour cette section on supposera que deux tables :

EMP( empno, ename, job, mgr,sal, comm, hiredate ,deptno)
EMP_HISTORY(num, nom, fonction, numdept)
EMP : contient des informations sur les employés qui travaillent encore.
EMP_HISTORY :contient des informations sur les employés qui ont quitté les entreprises
5.2 Opérateur UNION

L'opérateur UNION permet de fusionner deux sélections de tables pour obtenir un
ensemble de lignes égal à la réunion des lignes des deux sélections. Les lignes
communes n'apparaîtront qu'une fois.
Exemple :
Les noms des SALESMAN :
SELECT ename FROM EMP
WHERE job=' SALESMAN '
UNION
A.U 2007/2008 38/75

SELECT nom FROM EMP_HISTORY

WHERE fonction='SALESMAN'
5.3 Opérateur INTERSECT

L'opérateur INTERSECT permet d'obtenir l'ensemble des lignes communes à deux
interrogations.
Exemple :
Liste des job qui existe depuis la création de l’entreprise :
SELECT distinct(job) FROM EMP
INTERSECT
SELECT distinct(fonction) FROM EMP_HISTORY
5.4 Opérateur MINUS

L’opérateur MINUS permet d'ôter d'une sélection les lignes obtenues dans une deuxième
sélection.
Exemple :
Liste des départements qui n’ont pas des employés qui ont quitté l’entreprise
SELECT deptno FROM EMP
MINUS
SELECT numdept FROM EMP_HISTORY ;
5.5 Opérateur UNION ALL :

Cet opérateur , par opposition à UNION , n’elemine pas les doublons :
Exemple :
Liste de nom des employés depuis la création de l’entreprise :
SELECT ename FROM EMP
UNION ALL
SELECT nom FROM EMP_HISTORY
5.6 Remarques :
- le nombre de colonnes dans les deux ordres SELECT doit etre égale.
- les types de colonnes doivent etre identique respectivement.( première colonne de premier
ordre avec première colonne du second,…etc.
Exercice : Afficher les noms et salaire de tous les employés :
SELECT ename , sal
FROM EMP
UNION
SELECT nom , 0
FROM EMP_HISTORY
La valeur de « sal » est 0 pour tous les employés qui ont quitté l’entreprise.
A.U 2007/2008 39/75

6- Langage de manipulation de données LMD
6.1 Définition
Le langage de manipulation de données est le langage permettant de modifier les informations

contenues dans une base de données.
L'unité manipulée est la ligne. Il existe trois commandes sql permettant d'effectuer les trois
types de
modifications des données : ajout, modification et suppression.
6.2 Ajout de lignes :INSERT
La commande INSERT permet d'insérer une ligne dans une table en spécifiant les valeurs à
insérer.
La syntaxe est la suivante :
INSERT INTO nom_table(nom_col1, nom_col2, ...)

VALUES (val1, val2...)
La liste des noms de colonne est optionnelle. Si elle est omise, la liste des colonnes sera par
défaut
la liste de l'ensemble des colonnes de la table dans l'ordre de la création de la table.
Si une liste de colonnes est spécifiée, les colonnes ne figurant pas dans la liste auront la valeur
NULL.
Il est possible d'insérer dans une table des lignes provenant d'une autre table. La syntaxe est la
suivante :
INSERT INTO nom_table(nom_col1, nom_col2, ...)
SELECT ...
Le SELECT peut contenir n'importe quelle clause sauf un ORDER BY qui impliquerait un
classement
des lignes contraire à l'esprit du relationnel.
Exemple : Insérer dans la table bonus les noms et salaires des directeurs.
INSERT INTO bonus
SELECT nom, salaire
FROM emp
WHERE fonction = 'directeur';
6.3 Modification de lignes : UPDATE
La commande UPDATE permet de modifier les valeurs d'une ou plusieurs colonnes, dans une
ou plusieurs lignes existantes d'une table. La syntaxe est la suivante :
UPDATE nom_table
SET nom_col1 = {expression1 | ( SELECT ...) },
nom_col2 = {expression2 | ( SELECT ...) }
A.U 2007/2008 40/75

WHERE prédicat
Les valeurs des colonnes nom_col1, nom_col2, ... sont modifiées dans toutes les lignes
satisfaisant au prédicat. En l'absence d'une clause WHERE, toutes les lignes sont mises à jour.
Les expressions expression1, expression2,... peuvent faire référence aux anciennes valeurs
de la ligne.
Exemple : Augmenter de 10% les salaires ingénieurs.

UPDATE emp
SET salaire = salaire * 1.1
WHERE fonction = 'ingénieur' ;
6.4 Suppression de lignes : DELETE
La commande DELETE permet de supprimer des lignes d'une table.

La syntaxe est la suivante :
DELETE FROM nom_table
WHERE prédicat ;
Toutes les lignes pour lesquelles prédicat est évalué à vrai sont supprimées. En l'absence de
clause WHERE, toutes les lignes de la table sont supprimées.
7- Lanagae de définition de données LDD

7.1 Les types de données en SQL
Les types de données les plus utilisés sont :
NUMBER[(longueur,[précision]
Ce type de données permet de stocker des données numériques à la fois entières et
réelles dont la valeur est comprise entre 10^-130 et 10^125 avec une précision de 38
chiffres.
Longueur
précise le nombre maximum de chiffres significatifs stockés (par défaut 38),
Précision
donne le nombre maximum de chiffres après la virgule (par défaut 38), sa valeur peut
être
comprise entre -84 et 127. Une valeur négative signifie que le nombre est arrondi à
gauche de la
virgule.
CHAR(longueur)
Ce type de données permet de stocker des chaînes de caractères de longueur fixe. longueur
doit
être inférieur à 255, sa valeur par défaut est 1.
VARCHAR2(longueur)
Ce type de données permet de stocker des chaînes de caractères de longueur variable.
longueur
doit être inférieur à 2000, il n'y a pas de valeur par défaut.
DATE
Ce type de données permet de stocker des données constituées d'une date et d'une heure.
A.U 2007/2008 41/75

7.2 Les contraintes
Les différentes contraintes que l'on peut déclarer sont les suivantes :
NOT NULL
La colonne ne peut pas contenir de valeurs NULL.
UNIQUE
Chaque ligne de la table doit avoir une valeur différente ou NULL pour cette (ou ces)
colonne.
PRIMARY KEY
Chaque ligne de la table doit avoir une valeur différente pour cette (ou ces) colonne. les
valeurs
NULL sont rejetées.
FOREIGN KEY
Cette colonne fait référence à une colonne clé d'une autre table.
CHECK
Permet de spécifier les valeurs acceptables pour une colonne.
7.3 L’ordre CREATE Table :pour la création d’une table
Spécification d’une clé primaire
CREATE TABLE nom_table (

Nom_colonne1 type_données [NOT NULL],
…
Nom_colonne_ntype_données [NOT NULL],
[Constraint nom_contrainte]
[Primary key (nom_colonneA, nom_colonneB,…,nom_colonneX)]
);
nom_contrainte est un nom optionnel qui identifie la contrainte

nom_colonneA à nom_colonneX représentent les colonnes qui composent la clé
primaire de la table.
Exemple :
CREATE TABLE Ligne_Facture (

Numfact Number(5),
Codprod varchar2(5),
Qtefact Number(9,3) NOT NULL
Constraint CP_LIG_FACT
Primary key (Numfact, Codprod)) ;
Remarque :
La contrainte NOT NULL n’est pas utilisée pour les colonnes Numfact et Codprod car
la contrainte Primary Key remplace, entre autre, NOT NULL.
A.U 2007/2008 42/75

Spécification d’une clé étrangère
CREATE TABLE nom_table (

Spécification_colonne1,
…
Spécification_colonneN,
[Constraint nom_contrainte_CE Foreign Key (nom_colonneF1,…,nom_colonneFN)
references table_référence (nom_colonneP1,…,nom_colonnePN),]
[Constraint nom_contrainte_CP]
[Primary key (nom_colonneA, nom_colonneB,…,nom_colonneX)]
);
Spécification_colonne1 à spécificatin_colonneN sont les spécifications des colonnes

valides (décrites ci-après en détail).
nom_contrainte_CE est le nom optionnel de la contrainte de clé étrangère.
nom_colonneF1 à nom_colonneFN représentent les colonnes qui composent la clé
étrangère.
table_référence représente la table à laquelle se réfère la déclaration de la clé
étrangère.
Nom_colonneP1 à nom_colonnePN représentent la clé primaire de la table référencée.
La syntaxe pour spécification colonne est la suivante :
nom_colonne type_données [DEFAULT valeur_par_défaut]
[Constraint nom_contrainte] [NULL] | [NOT NULL] | [UNIQUE] | CHECK (condition)
valeur_par_défaul est une valeur affectée à la colonne lors d’une insertion.

Nom_contrainte désigne le nom de la contrainte.
Condition est un condition booléenne que doit vérifier les valeurs affectées à la
colonne.
Exemple:
CREATE TABLE Facture (

Numfact Number(5) ,
Datefact date default SYSDATE,
Mode_paie varchar2(10) Constraint CK_mode CHECK (mode_paie IN
(‘cheque’,’espèce’)),
Codcli varchar2(5),
Constraint CP_FACT Primary key (Numfact),
Constraint CE_CODCLI Foreign Key (Codcli) references Client(codcli)) ;
7.4 L’order ALTER TABLE :

Permet de modifier la définition d’une table par ajout (option ADD) ou par
modification(option MODIFY).
Exemple :ajouter aux employés un attribut indiquant leur adresse :
Réponse :
SQL> ALTER TABLE emp
A.U 2007/2008 43/75

ADD (adresse varchar2(50)) ;

Exemple : modifier la taille de nom des employés
Réponse :
ALTER TABLE emp
MODIFY (ename varchar2(30)) ;
8. Langage de contrôle de données LCD
8.1 Les transactions dans SQL : COMMIT et ROLLBACK
Dans la norme SQL, une transaction commence au début d'une session de travail ou juste
après la _n de la transaction précédente. Elle se termine par un ordre explicite de validation
(commit) ou d'annulation (rollback).
Certains SGBD ne respectent pas la norme et demandent une commande explicite pour
démarrer une transaction.
L'utilisateur peut à tout moment valider (et terminer) la transaction en cours par la commande
COMMIT. Les modifications deviennent alors définitives et visibles à toutes les autres
transactions.
L'utilisateur peut annuler (et terminer) la transaction en cours par la commande ROLLBACK.
Toutes les modifications depuis le début de la transaction sont annulées.
A.U 2007/2008 44/75

Chapitre 4 : La langage PL/SQL
1- Introduction
SQL est un langage complet pour travailler sur une base de donnée relationnelle,
mais il ne comporte pas des instructions procédurales. PL/SQL comprend quant à
lui :
La partie LID (Langage d’Interrogation des données) de SQL (Select),
la partie LMD (Langage de Manipulation des Données) de SQL (Update,
Insert,…)
la gestion des transaction (Commit, Rollback…)
les fonctions standard de SQL
plus une partie procédurale (IF, WHILE,…)
REMARQUE : PL/SQL ne comporte pas d’instructions de LDD (Create, Alter…)
2- Structure d’un bloc PL/SQL

PL/SQL n'interprète pas une commande, mais un ensemble de commandes
contenues dans un programme ou bloc PL/SQL. La structure d’un bloc est la
suivante:
DECLARE
Déclarations de variables, constantes, exception;
BEGIN
Section obligatoire contenant des instructions SQL et PL/SQL ou des blocs fils
(Possibilités d’imbrication de blocs)
EXCEPTION
Traitement des exceptions (gestion des erreurs)
END;
REMARQUES :
Les sections DECLARE et Exception sont optionnelles
Chaque instruction de n’importe quel section doit se terminer par un ‘ ;’
A.U 2007/2008 45/75

Exemple d’un bloc PL/SQL :
DECLARE
qte_stock number(5);
BEGIN
Select quantite into qte_stock from PRODUITS
where codprod= ‘p1’;
-- contrôle du stock suffisant
If qte_stock > 0
then update produits set quantite=quantite-1
where codprod= ‘p1’;
Insert into achat values (‘p1', SYSDATE)
else
Insert into acheter values ('Plus de p1',SYSDATE);
end If, commit ; END;
3- Les déclarations PL/SQL
La partie déclarative dans un bloc PL/SQL, peut comporter trois types de
déclarations. Elle
est délimitée par les mots-clé :
DECLARE, qui spécifie le début et
BEGIN, qui signifie la fin de la déclaration et le début de la partie des
commandes.
Les types de déclarations possibles dans cette partie sont les suivants :
déclaration des variables et des constantes,
déclaration de curseurs,
déclaration des exceptions.
3.1 Types de données

Chaque variable ou constante utilisée dans un bloc PL/SQL, possède un type de
données.
PL/SQL offre deux variétés de types de données prédéfinies : scalaire et composé.
• Les types scalaires :
Number : un numérique
Positive : entiers positifs
Decimal , float, integer, real sont des sous-types de number
Char : chaîne de caractère à taille fixe allant jusqu’à 32 767 caractère (au lieu de
255 dans la
définition des colonnes des tables)
Varchar2 : est une chaîne de caractère de longueur variable allant jusqu’à 32 767
(au lieu de
2000 dans la définition des colonnes des tables)
A.U 2007/2008 46/75

Boolean : type booléen ses valeurs possibles sont TRUE, FALSE, NULL
Date : type date d’Oracle
• Les types Composés :
Record : c’est le type enregistrement
Table : c’est le type tableau
3.2 Variables et constantes

La déclaration d'une variable consiste à allouer un espace pour stocker et modifier une valeur.
elle est typée et peut recevoir une valeur par défaut et/ou un statut NOT NULL. Une constante
est définie comme une variable, mais l'utilisateur ne peut pas modifier son contenu.
3.2.1. La définition des variables en PL/SQL
Les variables se définissent dans la partie DECLARE, du bloc PL/SQL en utilisant

la syntaxe suivante :
nomvariable [CONSTANT]
{type | variable%TYPE | colonne_de_table.%ROWTYPE}
[{ :=|DEFAULT valeur]
Remarques :
L'attribut CONSTANT permet de figer l'affectation d'une variable.
On peut faire référence à une colonne d'une table par la déclaration :
♦ nom_variable TABLE.COLONNE%TYPE,
On peut faire référence à une ligne d'une table par la déclaration
♦ Nom_variable TABLE%ROWTYPE,
L'initialisation d'une variable se fait par l'opérateur ‘ :=’ suivi d'une constante, d'une
expression PL/SQL, d'une fonction PL/SQL.
Exemples de déclaration de variables :
Total NUMBER(9,3);
Nom CHAR(4) := ‘ISET’;
Longeur NUMBER NOT NULL := LENGTH (Nom)*2;
Date_Création DATE;
Numéro EMPLOYE.EMPNO%TYPE;
Dpt DEPARTEMENT%ROWTYPE;
Prénom Nom%TYPE;
Pi CONSTANT NUMBER:= 3.14;3.2.2 L’affectation des variables PL/SOL
Deux possibilités d’affectation ou d’assignement sont disponibles:

- par l'opérateur d'affectation: ':='
- par la clause Select .. Into…
La difficulté dans l'utilisation de la clause Select résulte du nombre de lignes ou d'occurrences
retourné.
Si le Select retourne une et une seule valeur l'affectation s'effectue correctement. Par contre
Si le SELECT ne retourne aucune ligne, l’erreur PL/SQL NO_DATA_FOUND sera générée.
A.U 2007/2008 47/75

Si le SELECT retourne plusieurs lignes : l’erreur TOO_MANY_ROWS sera générée.
3.4. Les enregistrements prédéfinis (record PL/SQL)

La restriction posée par l'utilisation du type %ROWTYPE pour déclarer un enregistrement
réside dans le manque de spécification des types de données au niveau de l'enregistrement.
L'implémentation du nouveau type composé nommé RECORD a permis de lever cette
restriction.
3.4.1 La déclaration d'un enregistrement
Comme les tableaux PL/SQL, la déclaration d'un enregistrement se fait en deux étapes :
1. Déclaration du type de l'enregistrement
2. Déclaration de la variable du type défini.
On peut déclarer un Type RECORD dans la partie déclarative d'un bloc ou d'un sous-
programme en utilisant la syntaxe suivante:
TYPE nom_type IS RECORD
(champ {type_champ | table.colonne%TYPE [NOT NULL],

champ (type_champ | table.colonne%TYPE [NOT NULL],.. )
nomtype : utilisé ensuite dans la déclaration des enregistrements PL/SQL.

Type-champ : type de données comme CHAR, DATE ou NUMBER.
Lorsque le type est déclaré,On peut déclarer des enregistrements de ce type de la façon
suivante :
Nom_erg nom_type ;
3.4.2 L'accès aux champs d'un enregistrement

Pour accéder à un élément d'une variable de type record, il suffit d'utiliser la syntaxe suivante
Nom_erg.nom_champ
Pour affecter la valeur d'une expression PL/SQL à un élément de l'enregistrement, on doit
utiliser la syntaxe suivante :
Nom_erg.nom_champ := expression_pl/sql;
Exemple :
DECLARE
TYPE ADRESSE IS RECORD
(Numero positive,
Rue varchar2(35),
CodePost char(5),
Ville varchar2(25),
Pays varchar2(30) );
TYPE CLIENT IS RECORD
A.U 2007/2008 48/75

(NumCIi positive,
NomCli varchar2(40),
Adrcli ADRESSE,
CA number(12,3));
monclient CLIENT ;
BEGIN
monclient.NumCIi := 1234;
monclient.NomCIi := ‘TOTO’;
monclient.AdrCli.Numero := 10;
END ;
4-Structure de controle
4.1. Les traitements Conditionnels
IF condition_plsql
THEN commandes
[ELSE commandes]
[ELSIF condition_plsql
THEN commandes
[ELSE commandes]]
END IF;
La condition peut utiliser les variables définies ainsi que tous les opérateurs présents dans
SQL =,<,>,<=,>=,<>, IS NULL, IS NOT NULL.
Exemple :
DECLARE
vjob CHAR(10);
vnom employés.ename%type := ‘BEN SALAH’ ;
msg CHAR(30) ;
BEGIN
Select job into vjob from employés where ename = vnom;
--contrôle de la valeur de vjob
if vjob is NULL
then msg := vnom | ‘pas de travail';
elsif vjob = ‘Vendeur’ then
UPDATE employés set comm = 100 where ename=vnom ;
Msg := vnom || ‘a 100 dinars de commission’ ;
Else
UPDATE employés set comm = 0 where ename=vnom ;
Msg := vnom || ‘n’a pas de commission’ ;
End if ;
DBMS_OUTPUT.PUT_LINE(msg) ;
commit;
A.U 2007/2008 49/75

END ;
4.2 Les Traitements.Répétitifs

4.2.1. l’instruction LOOP
LOOP permet de répéter une séquence de commandes. Cette séquence est comprise entre le
mot-clé LOOP, indiquant le début d’une boucle et END LOOP, spécifiant sa fin.
Syntaxe :
LOOP
instructions
END LOOP ;
Les commandes EXIT,EXIT WHEN condition permettent de quitter la boucle.
Exemple :
DECLARE
somme number(10) := 0 ;
nombre number(5);
BEGIN
nombre:=0;
LOOP
Nombre:=nombre+1 ;
somme := somme + nombre ;
if nombre>=10
then EXIT;
end if ;
END LOOP;
DBMS_OUTPUT.PUT_LINE(‘la somme des 10 premiers entiers est ‘ ||
to_char(somme));
END;
4.2.2. L'instruction FOR …LOOP

FOR compteur IN [REVERSE] var_debut.. var_fin LOOP
instructions
END LOOP ;
Compteur : est une variable de type entier, locale à la boucle. Sa valeur de départ est égale
par défaut à la valeur de l'expression entière de gauche (var_debut). Elle s'incrémente de 1,
après chaque traitement du contenu de la boucle, jusqu'à ce qu'elle atteigne la valeur de droite
(var_fin).
A.U 2007/2008 50/75

5. LES CURSEURS EN PL/SQL

Pour traiter une commande SQL, PL/SQL ouvre une zone de contexte pour exécuter les
commandes et stocker les informations.
5.1. Définition
Le curseur permet de nommer cette zone de contexte, d'accéder aux informations et
éventuellement de contrôler le traitement. Cette zone de contexte est une mémoire de taille
fixe, utilisée par le noyau pour analyser et interpréter tout ordre SQL.
5.2. Les types de curseurs

Le curseur explicite
Il est créé et géré par l'utilisateur pour traiter un ordre Select qui ramène plusieurs
lignes. Le traitement du select se fera ligne par ligne.
Le curseur implicite
Il est généré et géré par le noyau pour les autres commandes SQL.
5.3. Les étapes d'utilisation d'un curseur explicite

Pour traiter une requête qui retourne plusieurs lignes, l'utilisateur doit définir un curseur qui
lui permet d’extraire la totalité des lignes sélectionnées. L’utilisation d'un curseur pour traiter
un ordre Select ramenant plusieurs lignes, nécessite 4 étapes:
1. Déclaration du curseur
2. Ouverture du curseur
3. Traitement des lignes
4. Fermeture du curseur.
5.3.1. La déclaration d'un curseur

La déclaration du curseur permet de stocker l'ordre Select dans le curseur. La Syntaxe de
définition..
Le curseur se définit dans la partie DECALRE d'un bloc PL/SQL.
Cursor nomcurseur [(nompararn type [,nomparam type, .. )]
IS Commande_SELECT
Exemple :
Declare
Cursor DEPT_10 is
select ename, sal from emp where depno = 10;
5.3.2. L'ouverture et la fermeture d’un curseur

L'étape d'ouverture permet d'effectuer:
1. l'allocation mémoire du curseur,
2. l'analyse sémantique et syntaxique de l'ordre
3. le positionnement de verrous éventuels (si select for update.. )
A.U 2007/2008 51/75

L'étape de fermeture permet de libérer la place mémoire réservé.

La syntaxe :
OPEN nomcurseur [(nomparam1[,nomparam2 , . .)]

/* traitement des lignes */
CLOSE nomcurseur
Exemple :
Begin
…
OPEN DEPT_10
/* traitement des lignes*/
CLOSE DEPT_10
5.3.3. Le traitement des lignes

Il faut traiter les lignes une par une et renseigner les variables réceptrices définies dans la
partie DECLARE du bloc.
La syntaxe :
Dans la partie traitement du bloc.PL/Sql, il faut commencer par ouvrir le curseur puis
FETCH nomcurseur {nomvariable [

INTO nomvariable |
nomrecord
A.U 2007/2008 52/75

L’ordre fetch ne ramène qu’une seule ligne à la fois. De ce fait il faut recommencer l’ordre
pour traiter la ligne suivante.
Exemple :
Declare
Cursor DEPT_10 is
select ename, sal from emp where depno = 10;
Vnom emp.name%TYPE ;
Vsalaire emp.sal%TYPE ;
Begin
OPEN DEPT_10;
LOOP
FETCH DEPT10 into vnom,vsalaire ;
--Traitement ligne
END LOOP ;
CLOSE DEPT_10;
End;
5.4 Les attributs d’un curseur

Les attributs d’un curseur nous fournissent des informations sur l’exécution d’un ordre. Ils
sont conservés par PL/SQL après l’exécution du curseur (implicite ou explicite)
Ces attributs permettent de tester directement le résultat de l’exécution. Ils sont résumés dans
le tableau suivant :
Curseurs implicites Curseurs explicites

Sql%Found Nomcurseur%Found
Sql%Notfound Nomcurseur %Notfound
Sql%Isopen Nomcurseur %Isopen
Sql%Rowcount Nomcurseur %Rowcount
Sql%Rowtype Nomcurseur %Rowtype
5.4.1 l’attribut %Found

Cet attribut est de type booléen (vrai ou faux)
Pour les curseurs implicites, cet attribut est vrai si les instructions insert, update, delete
traitent au moins une ligne. Pour les curseurs explicites, il est vrai si le fetch ramène au moins une
ligne.
Exemple :
Declare
CURSOR num_cur1 IS SELECT num from tab1 ;
A.U 2007/2008 53/75


Num1 number ;
Num2 number ;
somme number := 0;
Begin
OPEN num_cur1 ;
OPEN num_cur2 ;
LOOP
FFTCH num_cur1 INTO num1 ;
FFTCH num_cur2 INTO num2;
IF (num_cur1%Found) AND (num_cur2%Found) THEN
somme:= num1 + num2 ;
INSERT INTO sum_tab VALUES (somme);
ELSE
Exit ;
END IF;
END LOOP;
CLOSE numl_cur1 ;
CLOSE mun_cur2 ;
COMMIT;
END;
5.4.2. L'attribut %NotFound

cet attribut est de type booléen (vrai ou faux)
Pour les curseurs implicites, cet attribut est vrai si les instructions insert, update, delete ne
traitent aucune ligne. Pour les curseurs explicites, il est vrai si le fetch ne ramène plus de
ligne.
Exemple :
Declare
Num1 number ;
Num2 number ;
somme number := 0;
Begin
OPEN num_cur1 ;
OPEN num_cur2 ;
LOOP
FFTCH num_cur1 INTO num1 ;
FFTCH num_cur2 INTO num2;
EXIT WHEN (num_cur1%NotFound) OR (num_cur2%NotFound) ;
somme:= num1 + num2 ;
INSERT INTO sum_tab VALUES (somme);
END LOOP;
CLOSE numl_cur1 ;
A.U 2007/2008 54/75

CLOSE mun_cur2 ;
END;
5.4.3. L'attribut %IsOpen

Cet attribut est de type booléen soit vrai, soit faux.
Le curseur implicite est toujours faux car Oracle referme toujours les curseurs qu'il
ouvre
après chaque utilisation.
Le curseur explicite est vrai si le curseur est ouvert.
Exemple :
Declare
Cursor Dept10 is
Select ename, sal from emp where deptno=10;
Begin
If not (Dept10%lsopen) then
open Dept10 ;
End if,
Fetch Dept10 into …
--traitement
End ;
5.4.4.'L'attribut %RowCount
Cet attribut est de type numérique. Le curseur implicite indique le nombre de lignes traités par
les ordres insert, update, delete.
Le curseur explicite est incrémenté à chaque ordre fetch, donc cet attribut traduit la nième
ligne traitée.
Exemple
Declare
cursor C1 is
select ename, empno, sal from emp order by sal desc ;
nom char(10);
numero number(4);
salaire number(7,2);
Begin
Open Cl;
Loop .
Fetch cl into nom, numéro, salaire ;
exit when (c1%rowcount > 25) or (cl%notfound);
insert into temp values (salaire, numéro, nom);
End Loop;
Close C1 ;
commit ;
End;
A.U 2007/2008 55/75

5.4.5. L'attribut %Rowtype
Cet attribut permet la déclaration implicite d'une structure dont les éléments sont d'un type
identique aux colonnes ramenées par le curseur.
Syntaxe :
Dans la partie déclarative du bloc.
CURSOR nomcurseur IS ordre select;

nomrecord nomcurseur%Rowtype;
Les éléments de la structure sont identifiés par: nomrecord.nomcolonne

La structure est renseignée par le Fetch : Fetch nomcurseur into nomrecord;
Exemple
Declare
/* la fonction nvl permet de tester la valeur Null d'une colonne si comm=NULL alors nvl
retourne 0 sinon nvl retourne la valeur de comm */
cursor c1 is select sal + nvl(comm) saltot, ename from emp;
/* l'enregistrement comporte deux colonnes: saltot, ename
c1_record c1%Rowtype;
Begin
open c1;
Loop
Fetch c1 into c1_record;
Exit when c1 %notfound ;
if c1_record.saltot > 2000 then
insert into temp values (c1_record.saltot, c1_record.ename);
end if,
End Loop;
close c1;
End;
5.5. Les boucles et les curseurs

L'objectif est de fournir au programmeur une structure simple et efficace pour utiliser les
structures de boucle et les curseurs.
Declare
Cursor nomcurseur is ordre_select ;
Begin
For nomrecord in nomcurseur Loop
/* traitement
End Loop;
End;
A.U 2007/2008 56/75

Le bloc PL/SQL ci-dessu permet d'obtenir une génération implicite de la structure suivante :
Declare
Cursor nomcurseur is ordre select;
nomrecord nomcurseur%rowtype;
Begin
Open nomcurseur ;
Loop
Fetch nomcurseur into nomrecord ;
Exit when nomcurseur%notfound ;
/* traitement
End Loop;
Close nomcurseur;
End;
5.6. Le curseur paramètré

Il permet d'utiliser des variables dans le curseur. Principalement dans la clause where.
Il faut pour cela spécifier les noms et les types des paramètres dans la déclaration du curseur.
Cursor nomcurseur (paraml type, param2 type,...)
is select ordre_select ,
L'ordre_select utilise les paramètres.

Les types possibles sont : char, number, date, boolean sans spécifier la longueur.
Begin
Open nomcurseur (valeurl , vaieur2, ... ) ;
Exemple :
Declare
cursor c1 (depart number)
is select sal, nvl(comm,0) commi
from emp where deptno=depart ;
total number(11,2) := 0 ;
sal_sup number(4):=0 ;
comm_sup number(4):=0;
Begin
for c1_rec in c1(20) Loop
total:= total+ c1_rec.sal + c1_rec.commi ;
if c1_rec.sal > 4000
then sal_sup := sal_sup + 1 ;
end if ;
if c1_rec.commi > 3000
then commi_sup:=commi_sup+1 ;
end if;
A.U 2007/2008 57/75

End Loop;
insert into temp
values (sal_Sup, comm_sup, 'total salaire’| to_Char(total));
commit ;
End;
5.7. La clause "current of…"

Cette clause permet d'accéder directement à la ligne ramenée par l'ordre Fetch afin de la
traiter (update, delete).
Il faut se réserver la ligne lors de la déclaration du curseur par le positionnement d'un
verrou d'intention : (For update of nom_colonne)
Il faut spécifier que l'on veut traiter la ligne courante au Fetch par la clause :(Where
current of nom_curseur)
Exemple :
Declare
Cursor cl is select ename, sal from emp
for update of sal ;
Begin
For c1_record in c1 Loop
If c1_ record.sal > 1500 then
insert into resultat values (c1_record.sal, c1_record.sal*1.3, c1_record.ename);
update emp set sal = sal * 1.3 where current of c1 ;
end if,
End loop ;
Commit;
End ;
6 Utilisation de sous-programmes
PL/SQL accepte aussi l’utilisation de sous-programmes, nommés procédures et fonctions.
Une procédure PL/SQL exécute certaines actions et peut accepter des paramètres optionnels.
Une fonction PL/SQL retourne une valeur d’un certain type et peut aussi accepter des
paramètres optionnels.
6.1 Déclaration d’une procédure

La syntaxe de déclaration d’une procédure est :
PROCEDURE nom_procédure [(paramètre1 … [, pramètreN ] IS
[déclaration des variables locales]
BEGIN
Instructions PL/SQL
[section_exception ]
END [nom_procédure]
• Paramètre1 à paramètreN représentent la déclaration des paramètres de la
procédure.
• déclaration des variables locales représentent les déclarations optionnelles de
variables,
A.U 2007/2008 58/75

de constantes, de fonctions et de procédures locales à la procédure.

• section_exception est la section optionnelle de gestion des exceptions de la
procédure.
Exemple :
Declare
Vpatient_ID Patient.Patient_ID%type ;
Fièvre_elevée constant real := 42 ;
Procedure enregistrer_Temp_Deg_C_Patient (patient_ID varchar2,
Temp_Corps_Deg_C real) is
Temp_Deg_F real ;
Begin
Temp_Deg_F := (9/5)* Temp_Corps_Deg_C + 32 ;
Insert into Patient (Patient_ID, Temp_Corps_Deg_F)
Values
(patient_ID, Tem_Deg_F) ;
Commit ;
End ;
Begin
Vpatient_ID := ‘ES8888’ ;
enregistrer_Temp_Deg_C_Patient (Vpatient_ID, Fièvre_elevée) ;
End ;
6.2 Déclaration d’une fonction

La syntaxe de déclaration d’une fonction est :
FUNCTION nom_fonction[(paramètre1 … [, pramètreN ]
RETURN type_données_fonction IS
[déclaration des variables locales]
BEGIN
Instructions PL/SQL
RETURN val_à_retournée
[section_exception ]
END [nom_fonction]
Exemple :
Soit l’extrait suivant d’une base de données relationnelle d’une application de gestion de
scolarité d’une université :
Etudiant(codetu, nometu,adretu)
Matière(codmat, description_mat, coefmat)
Moyenne(codetu #, codmat #, moyenne_mat)
La fonction meilleur_étu_mat retourne le code du meilleur étudiant d’une matière donnée.
Declare
Codmatière Matière.codmat%type;
Vcode_etu etudiant.codetu%type;
FUNCTION meilleur_étu_mat (pcodmat varchar2) RETURN varchar2 IS
Vcodetu etudiant.codeetu%type ;
A.U 2007/2008 59/75

BEGIN
Select codetu into Vcodetu
From Moyenne M
Where M.moyenne_mat in (Select max(moyenne_mat from Moyenne M
Where M.codmat=pcodmat);
Return Vcodetu;
End ;
Begin
Codmatière := ‘M001’;
Vcode_etu := meilleur_étu_mat(Codmatière);
DBMS_OUTPUT.PUT_LINE(‘Le meilleur étudiant de la matière’ ||
Codmatière | ‘est
: ‘ || Vcode_etu);
End ;
7. GESTION DES ERREURS

Le mécanisme de gestion d'erreurs dans PL/SQL est appelé gestionnaire des exceptions. Il
permet au programmeur de planifier sa gestion et d'abandonner ou de continuer le traitement
en présence d'une erreur.
Il faut affecter un traitement approprié aux erreurs apparues dans un bloc PL/SQL. C'est
pourquoi on distingue 2 types d'erreurs ou d'exceptions :
1. Erreur interne Oracle (Sqlcode <= 0) : dans ce cas la main est rendue directement au
système environnant.
2. Anomalie déterminée par 1'utilisateur.
La solution :
1. Donner un nom à l'erreur (si elle n'est pas déjà prédéfinie),
2. Définir les anomalies utilisateurs, leur associer un nom,
3. Définir le traitement à effectuer.
7.1. Les exceptions internes

Une erreur interne est produite quand un bloc PL/SQL viole une règle d'Oracle ou dépasse
une limite dépendant du système d'exploitation. Les erreurs Oracle générées par le noyau sont
numérotées, or le gestionnaire des exceptions de PL/SQL, ne sait que gérer des erreurs
nommées.
Pour cela PL/SQL a redéfini quelques erreurs Oracle comme des exceptions. Ainsi, pour gérer
d'autres erreurs Oracle, 1'utilisateur doit utiliser le gestionnaire OTHERS ou
EXCEPTION_INIT pour nommer ces erreurs.
A.U 2007/2008 60/75

Les exceptions fournies par Oracle sont regroupées dans ce tableau :
Nom d'exception Valeur SqlCode Erreur Oracle

CURSOR_ALREADY_OPEN -6511 ORA-06511
DUP_VAL_ON_INDEX -1 ORA-00001
INVALID_CURSOR -1001 ORA-01001
INVALID_NUMBER -1722 ORA-01722
LOGIN_DENIED -1017 ORA-01717
NO_DATA_FOUND -1403 ORA-01413
NOT_LOGGED_ON -1012 ORA-01012
PROGRAM_ERROR -6501 ORA-06501
STORAGE_ERROR -6500 ORA-06500
TIMEOUT_ON_RESOURCE -51 ORA-00051
TOO_MANY_ROWS -1422 ORA-01422
TR.ANSACTION_BACKED_OUT -61 ORA-00061
VALUE_ERROR -6502 ORA-06502
ZERO_DIVIDE -1476 ORA-01476
Pour gérer les exceptions, le programmeur doit écrire un gestionnaire des exceptions qui
prend le contrôle du déroulement du bloc PL/SQL en présence d'une exception.
Le gestionnaire d'exception fait partie du bloc PL/SQL et se trouve après les commandes Il
commence par le mot clé EXCEPTION et se termine avec le même END du bloc.
Chaque gestion d'exception consiste à spécifier son nom d'erreur après la clause WHEN et la
séquence de la commande à exécuter après le mot clé THEN, comme le montre l'exemple
suivant:
DECLARE
Wsal emp.sal%type;
BEGIN
select sal into wsal from emp;
EXCEPTION
WHEN TOO_MANY_ROWS then…
--gérer erreur trop de lignes
WHEN NO_DATA_FOUND then…
--gérer erreur pas de ligne
WHEN OTHERS then…
--gérer toutes les autres erreurs
END ;
A.U 2007/2008 61/75

7.2. Les exceptions utilisateur (externes)

PL/SQL permet à l'utilisateur de définir ses propres exceptions. La gestion des anomalies
utilisateur peut se faire dans un bloc PL/SQL en effectuant les opérations suivantes:
1. Nommer l'anomalie (type exception) dans la partie Déclare du bloc.
DECLARE
Nom_ano Exception;
2. Déterminer l’erreur et passer la main au traitement approprié par la commande
Raise.
BEGIN
…
If (condition_anomalie) then raise Nom_ano
3. Effectuer Ie traitement défini dans la partie EXCEPTION du Bloc.
EXCEPTION
WHEN (Nom_ano) then (traitement);
Exemple :
DECLARE
wsal emp.sal%type ;
sal_zero Exception ;
BEGIN
Select sal into wsal from emp where empno=5;
If wsal=0 then
Raise sal_zero;
EXCEPTION
WHEN sal_zero then…
-- gérer erreur salaire
WHEN TOO_MANY_ROWS then...
--gérer erreur trop de lignes
WHEN_NO_DATA_FOUND then ...
-- gérer erreur pas de ligne
WHEN OTRERS then ...
--gérer toutes les autres erreurs
END;
A.U 2007/2008 62/75

Annexe1 : Complément de cours : les fonctions
Expressions et fonctions
Une expression est un ensemble de variables (contenu d'une colonne), de constantes et de

fonctions combinées au moyen d'opérateurs. Les fonctions prennent une valeur dépendant de
leurs arguments qui peuvent être eux-mêmes des expressions.
Les expressions peuvent figurer :
• en tant que colonne résultat d'un SELECT,
• dans une clause WHERE,
• dans une clause ORDER BY.
Il existe trois types d'expressions correspondant chacun à un type de données de SQL :
arithmétique, chaîne de caractère, date. A chaque type correspondent des opérateurs et des
fonctions spécifiques.
SQL autorise les mélanges de types dans les expressions et effectuera les conversions
nécessaires : dans une expression mélangeant dates et chaînes de caractères, les chaînes de
caractères seront
converties en dates, dans une expression mélangeant nombres et chaînes de caractères, les
chaînes de caractères seront converties en nombre.
1- Expressions et fonctions arithmétiques

Une expression arithmétique peut contenir :
• des noms de colonnes
• des constantes
• des fonctions arithmétiques
combinés au moyen des opérateurs arithmétiques.
1.1 Opérateurs arithmétiques

Les opérateurs arithmétiques présents dans sql sont les suivants :
• + addition ou + unaire
• - soustraction ou - unaire
• * multiplication
• / division
Remarque : la division par 0 provoque une fin avec code d'erreur.
1.2 Priorité des opérateurs

Une expression arithmétique peut comporter plusieurs opérateurs. Dans ce cas, le résultat de
l'expression peut varier selon l'ordre dans lequel sont effectuées les opérations. Les opérateurs
de
multiplication et de division sont prioritaires par rapport aux opérateurs d'addition et de
soustraction. Des parenthèses peuvent être utilisées pour forcer l'évaluation de l'expression
dans un ordre différent de celui découlant de la priorité des opérateurs.
1.3 Fonctions arithmétiques

Dans ce paragraphe, ont été regroupées les fonctions ayant un ou plusieurs nombres comme
arguments, et renvoyant une valeur numérique. [ROUND(n ,m )]
ABS(nb)
A.U 2007/2008 63/75

Renvoie la valeur absolue de nb.

CEIL(nb)
Renvoie le plus petit entier supérieur ou égal à nb.
COS(n)
Renvoie le cosinus de n, n étant un angle exprimé en radians.
COSH(n)
Renvoie le cosinus hyperbolique de n.
EXP(n)
Renvoie e puissance n.
FLOOR(nb)
Renvoie le plus grand entier inférieur ou égal à nb.
LN(n)
Renvoie le logarithme népérien de n qui doit être un entier strictement positif.
LOG(m,n)
Renvoie le logarithme en base m de n. m doit être un entier strictement supérieur à 1,
et n un entier strictement positif.
MOD(m,n)
Renvoie le reste de la division entière de m par n, si n vaut 0 alors renvoie m.
Attention, utilisée avec au moins un de ses arguments négatifs, cette fonction donne
des résultats qui peuvent être différents d'un modulo classique. Cette fonction ne
donne pas toujours un résultat dont le signe du diviseur.
POWER(m,n)
Renvoie m puissance n, m et n peuvent être des nombres quelconques entiers ou réels
mais si m est négatif n doit être un entier.
ROUND(n[,m])
Si m est positif, renvoie n arrondi (et non pas tronqué) à m chiffres après la virgule. Si
m est négatif, renvoie n arrondi à m chiffres avant la virgule. m doit être un entier et il
vaut 0 par défaut.
SIGN(nb)
Renvoie -1 si nb est négatif, 0 si nb est nul, 1 si nb est positif.
SIN(n)
Renvoie le sinus de n, n étant un angle exprimé en radians.
SINH(n)
Renvoie le sinus hyperbolique de n.
SQRT(nb)
Renvoie la racine carrée de nb qui doit être un entier positif ou nul.
TAN(n)
Renvoie la tangente de n, n étant un angle exprimé en radians.
TANH(n)
Renvoie la tangente hyperbolique de n.
TRUNC(n[,m])
Si m est positif, renvoie n arrondi tronqué à m chiffres après la virgule. Si m est
négatif, renvoie n tronqué à m chiffres avant la virgule. m doit être un entier et il vaut
0 par défaut.
2- Expressions et fonctions sur les chaînes de caractères

2.1 Opérateur sur les chaînes de caractères
Il existe un seul opérateur sur les chaînes de caractères : la concaténation. Cet opérateur se
note au moyen de deux caractères |(barre verticale) accolés. Le résultat d'une concaténation
A.U 2007/2008 64/75

est une chaîne de caractères obtenue en écrivant d'abord la chaîne à gauche de || puis celle à
droite de ||.
2.2 Fonctions sur les chaînes de caractères

Le paragraphe suivant contient les fonctions travaillant sur les chaînes de caractères et
renvoyant
des chaînes de caractères.
CONCAT(chaîne1,chaîne2)
Renvoie la chaîne obtenue en concaténant chaîne1 à chaîne2. Cette fonction est
équivalente à l'opérateur de concaténation | |.
INITCAP(chaîne)
Renvoie chaîne en ayant mis la première lettre de chaque mot en majuscule et toutes
les autres en minuscule. Les séparateurs de mots sont les espaces et les caractères non
alphanumériques.
LOWER(chaîne)
Renvoie chaîne en ayant mis toutes ses lettres en minuscules.
LPAD(chaîne, long,[char])
Renvoie la chaîne obtenue en complétant, ou en tronquant, chaîne pour qu'elle ait
comme longueur long en ajoutant éventuellement à gauche le caractère (ou la chaîne
de caractères) char. La valeur par défaut de char est un espace.
LTRIM(chaîne[,ens])
Renvoie la chaîne obtenue en parcourant à partir de la gauche chaîne et en
supprimant tous les caractères qui sont dans ens. On s'arrête quand on trouve un
caractère qui n'est pas dans ens. La valeur de défaut de ens est un espace.
REPLACE(chaîne, avant, après)
Renvoie chaîne dans laquelle toutes les occurrences de la chaîne de caractères avant
ont été remplacés par la chaîne de caractères après.
RPAD(chaîne, n,[char])
Renvoie la chaîne obtenue en complétant, ou en tronquant, chaîne pour qu'elle ait
comme longueur long en ajoutant éventuellement à droite le caractère (ou la chaîne
de caractères) char.La valeur par défaut de char est un espace.
RTRIM(chaîne[,ens])
Renvoie la chaîne obtenue en parcourant à partir de la droite chaîne et en supprimant
tous les caractères qui sont dans ens. On s'arrête quand on trouve un caractère qui n'est
pas dans ens. La valeur de défaut de ens est un espace.
SOUNDEX(chaîne)
Renvoie la chaîne de caractères constituée de la représentation phonétique des mots de
chaîne.
SUBSTR(chaîne, m[,n])
Renvoie la partie de chaîne commençant au caractère m et ayant une longueur de n.
TRANSLATE(chaîne, avant, après)
Renvoie une chaîne de caractères en remplaçant chaque caractère de chaîne présent
dans avant par le caractère situé à la même position dans après. Les caractères de
chaîne non présents dans avant ne sont pas modifiés. avant peut contenir plus de
caractères que après, dans ce cas les caractères de avant sans correspondants dans
après seront supprimés de chaîne .
UPPER(chaîne)
Renvoie chaîne en ayant mis toutes ses lettres en majuscules.
Le paragraphe suivant contient les fonctions travaillant sur les chaînes de caractères et
renvoyant des entiers.
INSTR(chaîne, sous-chaîne, début, occ)
A.U 2007/2008 65/75

Renvoie la position du premier caractère de chaîne correspondant à l’occurrence occ

de souschaîne en commençant la recherche à la position début.
LENGTH(chaîne)
Renvoie la longueur de chaîne, exprimée en nombre de caractères.
3- Expressions et fonctions sur les dates

3.1 Opérateurs sur les dates
Au moyen des opérateurs arithmétiques + et - il est possible de construire les expressions
suivantes :
• date +/- nombre : le résultat est une date obtenue en ajoutant le nombre de jours nombre
à
la date date.
• date2 - date1 : le résultat est le nombre de jours entre les deux dates.
3.2 Fonctions sur les dates

ADD_MONTHS(date, n)
Renvoie la date obtenue en ajoutant n mois à date. n peut être un entier quelconque.
Si le mois
obtenu a moins de jours que le jour de date, le jour obtenu est le dernier du mois.
LAST_DAY(date)
Renvoie la date du dernier jour du mois de date.
MONTHS_BETWEEN(date2, date1)
Renvoie le nombre de mois entre date2 et date1, si date2 est après date1 le
résultat est positif, sinon le résultat est négatif. Si les jours date2 et date1 sont les
mêmes, ou si ce sont les derniers jours du mois, le résultat est un entier. La partie
fractionnaire est calculée en considérant chaque jour comme 1/31ème de mois
NEXT_DAY(date, nom_du_jour)
Renvoie la date du prochain jour de la semaine dont le nom est nom_de_jour.
ROUND(date[,précision])
Renvoie date arrondie à l'unité spécifiée dans précision. L'unité de précision est
indiquée en utilisant un des masques de mise en forme de la date. On peut ainsi
arrondir une date à l'année, au mois, à la minute,... Par défaut la précision est le jour.
SYSDATE
Renvoie la date et l'heure courantes du système d'exploitation hôte.
TRUNC(date[,précision])
Renvoie date tronquée à l'unité spécifiée dans précision. Les paramètres sont
analogues à ceux de la fonction ROUND.
4- Fonctions de conversion
ASCII(chaîne)
Renvoie le nombre correspondant au code ascii du premier caractère de chaîne.
CHR(nombre)
Renvoie le caractère dont nombre est le code ascii.
TO_CHAR(nombre, format)
Renvoie la chaîne de caractères en obtenue en convertissant nombre en fonction de
format.
Format est une chaîne de caractères pouvant contenir les caractères suivants :
A.U 2007/2008 66/75

9 représente un chiffre (non représenté si non significatif)

0 représente un chiffre (représenté même si non significatif)
. point décimal apparent
V définit la position du point décimal non apparent
, une virgule apparaîtra à cet endroit
$ un $ précédera le premier chiffre significatif
B le nombre sera représenté par des blancs s'il vaut 0
EEEE le nombre sera représenté avec un exposant (le spécifier avant MI ou PR)
MI le signe négatif sera à droite
PR un nombre négatif sera entre <>
TO_CHAR(date, format)
Renvoie conversion d'une date en chaîne de caractères. Le format indique quelle partie
de la date doit apparaître, c'est une combinaison des codes suivants :
Scc siècle avec signe
Cc siècle
sy,yyy année (avec signe et virgule)
y,yyy année( avec virgule)
yyyy année
yyy 3 derniers chiffres de l'année
yy 2 derniers chiffres de l'année
y dernier chiffre de l'année
q numéro du trimestre dans l'année
ww numéro de la semaine dans l'année
w numéro de la semaine dans le mois
mm numéro du mois
ddd numéro du jour dans l'année
dd numéro du jour dans le mois
d numéro du jour dans la semaine
hh ou hh12 heure (sur 12 heures)
hh24 heure sur 24 heures
mi minutes
ss secondes
sssss secondes après minuit
j jour du calendrier julien
Les formats suivants permettent d'obtenir des dates en lettres ( en anglais) :
syear ou year année en toutes lettres
month nom du mois
mon nom du mois abrégé sur 3 lettres
day nom du jour
dy nom du jour abrégé sur 3 lettres
am ou pm indication am ou pm
bc ou ad indication avant ou aprèsjésus christ
Les suffixes suivants modifient la présentation du nombre auquel ils sont accolés :
Th ajout du suffixe ordinat st, nd, rd, th
Sp nombre en toutes lettres
Tout caractère spécial inséré dans le format sera reproduit tel quel dans la chaîne
de
caractères résultat.
TO_DATE(chaîne, format)
A.U 2007/2008 67/75

Permet de convertir une chaîne de caractères en donnée de type date. Le format est
identique à celui de la fonction TO_CHAR.
TO_NUMBER(chaîne)
Convertit chaîne en sa valeur numérique.
Remarque : On peut également insérer dans le format une chaîne de caractères
quelconque, à condition de la placer entre guillemets"".
5- Autres fonctions
GREATEST(expr1, expr2,...)
Renvoie la plus grande des valeurs expr1, expr2,.... Toutes les expressions sont
converties au format de expr1 avant comparaison.
LEAST
Renvoie la plus petite des valeurs expr1, expr2,.... Toutes les expressions sont
converties au format de expr1 avant comparaison.
NVL(expr_1, expr_2)
Prend la valeur expr_1, sauf si expr_1 est NULL auquel cas NVL prend la valeur
expr_2.
Une valeur NULL en SQL est une valeur non définie.
Lorsque l'un des termes d'une expression a la valeur NULL, l'expression entière prend la
valeur NULL.
D'autre part, un prédicat comportant une comparaison avec une expression ayant la
valeur NULL prendra toujours la valeur faux. La fonction NVL permet de remplacer
une valeur NULL par une valeur significative.
DECODE(crit, val_1, res_1 [, val_2, res_2 ...], def)
Cette fonction permet de choisir une valeur parmi une liste d'expressions, en fonction
de la
A.U 2007/2008 68/75

Annexe 2 : Gestion des utilisateurs et des privilèges
L’introduction d’un nouvel utilisateur nécessite de créer l’utilisateur par l’ordre CREATE
USER puis de lui allouer des prévileges par GRANT et ALTER USER. Ensuite il est à tout
moment possible de modifier ses allocations de ressources par l’exécution d’un nouvel ordre
GRANT ou ALTER USER ou par exécution d’un ordre REVOKE .
I-Gestion des utilisateurs :
1-Création d’un utilisateur :

s’effectue par l’ordre CREATE USER, de syntaxe :
CREATE USER nom_utilisateur
IDENTIFIED {BY mot de passe | EXTERNALLY }
[DEFAULT TABLESPACE nom_tablespace ]
[TEMPORARY TABLESPACE nom_tablespace]
[QUOTA [nombre/UNLIMITED] ON nom_tablespace]
[PASSWORD EXPIRE]
[ACCOUNT { LOCK | UNLOCK} ]
La vue DBA_USERS du dictionnaire de données permet de consulter la liste des

caractéristiques des utilisateurs de la base de données.
A la ctréation de la BD, deux utilisateurs préviligés, SYS et SYSTEM, sont automatiquement
crées.
La connexion au compte SYSTEM permet de créer les autres utilisateurs.L’utilisateur SYS est
propriétaire de la majorité des tables de dictionnaire ainsi que des vues céees sur ces tables.
• EXTERNALLY : permet de créer un utilisateur qui a memes noms et mot de passe

qu’un utilisateur défini au niveau système d’exploitation.Cette possibilité évite la
saisie de mot de passe lors des connexions à Oracle. Le nom de l’utilisateur pour la
comande CREATE USER, est alors composé de préfixes OP$$ suivi du nom de
l’utilisateur au niveau système
• DEFAULT TABLESPACE nom_tablespace: définit le tablespace qui sera utilisé par
défaut lors de la création d’une table par l’utilisateur (ordre CREATE TABLE). SI
cette clause n’est pas utilisée, les tables sont par défaut crées dans le tablespace
SYSTEM.
• TEMPORARY TABLESPACE nom_tablespace: définit le tablespace qui sera utilisé
par défaut lorsque le système aura besoin d’espace de travail.Sii cette clause n’est pas
utilisée, les zones de travail temporaires sont implantée dans le tablespace SYSTEM.
A.U 2007/2008 69/75

• QUOTA [nombre/UNLIMITED] ON nom_tablespace :permet de limiter(nombre)

ou non(UNLIMITED) l’espace qui pourra etre alloué pour les tables de l’utilisateur
dans le tablespace . La valeur peut etre exprimée en KO ou en MO.
• PASSWORD EXPIRE : demande le changement de mot de passe.
• ACCOUNT :{LOCK|UNLOCK} :verrouillée ou active.
2-Modification d’un utilisateur :

La clause ALTER USER de syntaxe :
ALTER USER nom_utilisateur …
IDENTIFIED {BY mot de passe | EXTERNALLY }
[DEFAULT TABLESPACE nom_tablespace ]
[TEMPORARY TABLESPACE nom_tablespace]
[QUOTA [nombre/UNLIMITED] ON nom_tablespace]
[PASSWORD EXPIRE]
[ACCOUNT { LOCK | UNLOCK} ]
Qui permet de modifier :

Le mot de passe
Le tablespace utilisé par défaut lors de création d’un objet
etc….
3-Suppression d’un utilisateur

DROP USER schéma [CASCADE] ;
Sans l’option CASCADE, l’utilisateur n’est pas supprimé s’il est propriétaire d’objets. Avec
l’option CASCADE, l’utilisateur est toujours supprimé et tous les objets dont il est le
propriétaire sont aussi supprimés.
II-Gestion des privilèges :
1-Gestion des privilèges au niveau système :

a-Attribution d’un privilège:
Un privilège au niveau système , ou un role, peut etre attribué à un utilisateur par l’ordre
GRANT de syntaxe :
GRANT privilège système [, privilège système . ..]
TO nom_utilisateur , nom_utilisateur2, | PUBLIC
[WITH ADMIN OPTION]
WITH ADMIN OPTION autorise celui qui a recu le privilège à le transmettre à un autre
utilisateur.
PUBLIC : permet d’affecter le privilège à tous les utilisateurs
A.U 2007/2008 70/75

b- Suppression d’un système :

Un privilège peut etre enlevé à un utilisateur par l’ordre REVOKE de syntaxe :
REVOKE privilège1, privilège2..
FROM utilisateur, utilisateur | PUBLIC
c- Exemple de privilège système :

ALTER SESSION, ALTER USER, CREATE TABLE, DROP USER, UPDATE
ANY TABLE,
2-Gestion de privilèges objets

a-Attribution de privilèges :
Un utilisateur (créateur) qui crée un objet tous les droits sur celui ci, les autres utilisateurs
(sauf DBA) n’ont aucun droit. Le crétaeur peut donnner des droits soit de facon selective à
quelques utilisateurs, soit à tous les utilisateurs.
L’attribution d’un privilège objet se fait par l’ordre GRANT, de syntaxe :
GRANT privilège objet [, privilège objet,…]

ON [shema .] objet
TO nom_utilisateur,nom_utilisateur..| PUBLIC
[WITH GRANT OPTION]
Ou « objet » peut etre un nom de : table, vue, procédure fonction.
b-suppression de privilège :
Tout droit accordé peut etre supprimé par l’ordre REVOKE , selon la syntaxe :
REVOKE privilège objet, [ ; privilège objet..] | ALL PRIVILEGES

ON object
FROM utilisateur ; | PUBLIC
c- exemple de privilèges objets

SELECT, INSERT, UPDATE , ALTER, ALL……
A.U 2007/2008 71/75

Annexe 3 : Gestion d’une base de données
1- Création d’une base de données:

i- L’ordre CREATE DATABASE
Lors de l’installation d’Oracle, une base par défaut peut être créer .IL est ensuite possible soit
de modifier la structure ce cette base pour l’adapter à des besoins spécifiques, soit de créer
une autre base. Après installation de logiciel, la création de la BD se fait par l’ordre CREATE
DATABASE selon la syntaxe :
CREATE DATABASE nom_base

[CONTROLFILE REUSE]
[LOGFILE, fichier [,fichier] … ]
[MAXLOGFILES valeur]
[MAXLOGMEMBERS valeur]
[MAXLOGHISTORY valeur]
[DATAFILES fichier [,fichier] …]
[MAXDATAFILES valeur]
[MAXINSTANCES valeur]
[ARCHIVLOG | NOARCHIVELOG]
Exemple :
Création d’une bd de nom « airbase » sous Windows avec un seul fichier de données
de 50 MO et deux fichiers de reprise de 1 MO chacun :
create database airbase
datafile ‘c:\orahome\data\airbus\df.dbf’ size 50 M
maxdatafiles 5
logfiles ‘c:\orahome\log\logfile1airbus.dbf’ size 1 M
‘c:\orahome\log\logfile2airbus.dbf’ size 1 M
maxlogfiles 10 ;
2i- Paramètres de l’ordre CREATE DATABASE :
* nom_base : le nom donnée à la BD,

* CONTROLFILE REUSE : utilisé uniquement en cas de création d’une base suite à la
suppression d’une base existante ; permet de réutiliser les fichiers de contrôle de la base
précédente .
* LOGFILE fichier : Définit les fichiers de reprise( redo log file), qui enregistrent toutes les
modifications effectuées sur les données de la base aucours d’une transaction.Ceci permet de
redémarrer après un incident (CPU, mémoire, disque).
* MAXLOGFILES valeur : définit le nombre maximal de fichiers de reprise qui peuvent etre
associés à la base.
* MAXLOGMEMBERS valeur : définit le nombre maximal de copies pour un fichier de
reprise.
A.U 2007/2008 72/75

* MAXLOGHISTORY valeur : définit le nombre maximal de fichiers archive pour les

fichiers de reprise.
* DATAFILES fichier : définit le ou les fichiers contenant les données de la base.
* MAXDATAFILES valeur : nombre maximal de fichiers de données qui peuvent tere
associés à la base.
* MAXINSTANCES valuer : nombre maximal d’instances pouvant accéder simultannément
à la base. Cette valeur dépend de système d’exploitation.
* ARCHIVLOG : positionne la fonctionnement de la base en mode archivage. Suppose
l’utilisation d’au moins deux fichiers de reprise : pendant que l’un est utilisé en jounalisation,
le second est automatiquement archivé sur un autre support avant sa réutilisation.
* NOARCHIVLOG : positionne le fonctionnement de la base en mode sans archivage.
2- Démarrage de la base :
La mise en ouvre d’une BD s’effectue en trois étapes, au moyen des commandes STARTUP
et ALTER DATABASE ::
• démarrage d’une instance, qui consiste à initialiser l’environnement de la BD en
allouant les ressources nécessaires. La base est alors dans l’état « démarrée non
montée » (NOMOUNT).
• démarrage de la base : qui consiste à associer une base à l’instance crée à l’étape
précédente. La base passe à l’état « démarrée et montée » (MOUNT). Elle est alors
accessible en mode INTERNAL aux utilisateurs qui ont le privilège
d’administration qui peuvent effectuer des opérations de maintenance tel que
renommer les fichiers de la base ou gérer les fichiers de reprise.
• Ouverture de la base : qui consiste à rendre les données de la base accessibles aux
utilisateurs. La base passe à l’état « ouverte » (OPEN).
Exemples :
Création de l’instance :
SQL> startup nomount ;
Démarrage de la base :
SQL>connect internal ;
SQL>alter database airbase mount ;
Ouverture de la base
SQL>alter database airbase open ;
3- Arrêt de la base :
Pour fermer une base de données, il faut successivement déconnecter les utilisateurs, détacher
la base de l’instance puis arreter l’instance.
Lors de la fermeture, le serveur enregistre dans les fichiers de reprise toutes les informations
nécessaires à un redémarrage sans erreur.
Pour arreter une base, il faut avoir un prévilege de niveau administrateur et utiliser l’ordre
SHUTDOWN. Cet ordre comporte trois options :
SHUTDOWN [ ABORT | IMMEDIATE | NORMAL]
A.U 2007/2008 73/75

Avec l’option NORMAL,aucune nouvelle connexion ,n’est plus admise. L’arrêt se produit
lorsque le dernier utilisateur se déconnecte. Toutes les transactions sont terminées
normalement.
Avec l’option IMMEDIATE, l’arrêt est immédiat ,sans attente de la fin des transactions en
cours, qui sont alors annulées.
Avec l’option ABORT , l’arrêt est immédiat , sans détachement de la base ni déconnexion
préalable des utilisateurs. Il s’agit du mode de fermeture le plus rapide. En revanche, une
procédure de reprise est nécessaire lors de redémarrage de la base .Cette solution n’est à
utiliser qu’en cas de problème grave.
A.U 2007/2008 74/75

Bibliographie
• Oracle Corporation Documentation
• NETG Documentation Skill Builder

Network Education Training Group
• Pack OCP DBA Oracle 9i EXAM

Edition : Oracle Press
• Les bases de données Oracle 8i

Développement, administration ,optimisation
Auteur :Roger Chapuis
Edition DUNOD
• Bases de données Objet et Relationnel

Auteur :Georges Gardarin
Edition EYROLLES
• SGBD avancés : Bases de données objets, déductives, réparties.

Auteurs :G.Gardarin, P.valduriez
Edition EYROLLES
Netographie
• www.developpez.com/cours/sql-Oracle
• www.oracle.com
• www.otn.com

2015 01 04 Cours SGBD

Transféré par

Informations du document

Description :

Titre original

Copyright

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Description :

Droits d'auteur :

2015 01 04 Cours SGBD

Titre original :

Transféré par

Description :

Droits d'auteur :

Direction Générale Institut Supérieur des

Des Etudes Technologiques Etudes

Niveau : Quatrième niveau en Informatique

Chapitre 1 : Introduction aux bases de données...................................4

• NETG Documentation Skill Builder

• Pack OCP DBA Oracle 9i EXAM

• Les bases de données Oracle 8i

• Bases de données Objet et Relationnel

• SGBD avancés : Bases de données objets, déductives, réparties.

Chapitre 1 : Introduction aux bases de données

3-Architecture ANSI/SPARC d’un SGBD :

Figure 1 : Architecture ANSI/SPARC

A.U 2007/2008 4/75

4-Historique des SGBD

5-Propriétés des bases de données relationnels

A.U 2007/2008 5/75

b- Un ensemble d’opérateurs appliqués à des relations, constituant l’algèbre

c-Un ensemble de contraintes sémantiques définit les états cohérents de la base de

• la première est l’unicité de clé, qui spécifie qu’un ou plusieurs

A.U 2007/2008 6/75

Chapitre 2 : Installation de Oracle 9i

Si l'autorun ne démarre pas, lançons manuellement setup.exe

A.U 2007/2008 7/75

A.U 2007/2008 8/75

A.U 2007/2008 9/75

Choisissons l'installation standard afin de ne pas se priver du plaisir de configurer la couche

Voici donc le résumé des options choisies

A.U 2007/2008 10/75

A.U 2007/2008 11/75

Et c'est parti : le temps d'une bonne pause café...

L'installation du logiciel s'est apparemment bien déroulée.

3-Création d'une première base de données

A.U 2007/2008 12/75

Nous voulons créer une base. Choisissons donc la 1ère option.

A.U 2007/2008 13/75

Pour permettre à l'assistant de configurer la base de données le plus correctement possible, un

A.U 2007/2008 14/75

A.U 2007/2008 15/75

A.U 2007/2008 16/75

A.U 2007/2008 17/75

A.U 2007/2008 18/75

A.U 2007/2008 19/75

A.U 2007/2008 20/75

Déterminons un nom pour ce module d'écoute.

A.U 2007/2008 21/75

Pour l'instant, un seul module nous suffit.

Choisissons maintenant une méthode de résolution de noms.

A.U 2007/2008 22/75

A.U 2007/2008 23/75

A.U 2007/2008 24/75

A.U 2007/2008 25/75

A.U 2007/2008 26/75

Visiblement, tout est en ordre maintenant.

A.U 2007/2008 27/75

Voilà! La configuration de la couche réseau est faite.

Exemple de fichier de réponses

A.U 2007/2008 28/75

Des exemples de fichiers similaires se trouvent sous le CD d'installation 1, dans le répertoire

C:\>setup -responsefile c:\temp\monInstallO9i.res

5-Ma première connexion

SQL*Plus: Release 9.2.0.1.0 - Production on Ma Fev 3 14:02:15 2004

Copyright (c) 1982, 2002, Oracle Corporation. All rights reserved.