support de cours « sgbd - · pdf filedonnée en utilisant merise. leurs travaux...

Direction Générale Institut Supérieur des Des Etudes Technologiques Etudes ******** DGET ******* Technologiques du Kef

Niveau : Quatrième niveau en Informatique Option : Informatique de gestion, Réseaux informatique Version : 1.0

Support de cours « SGBD »

Réalisé par :

BOUKCHIM Mosaab (AT-Iset de Kef)

HOSNI Anis (AT-Iset de Kef)

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 cara ctè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 utilité autant que règles de gestion.

PRIMARY KEY FOREIGN KEY UNIQUE CHECK NOT NULL

Comment créer une base de données, ses tables et comment les modifiés (LDD de SQL).

- CREATE DATABASE - CREATE TABLE - ALTER TABLE

Savoir interroger une BD en vue d’extraire et d’afficher des informations spécifiques.

L’ordre SELECT Les fonctions de groupe Les jointures Les sous interrogations Les opérateurs ensemblistes

Connaître les commandes nécessaires de mise à jour de données (LMD de SQL).

INSERT 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 fonctions stockés.

CREATE PROCEDURE 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 donnés

COMMIT 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

A.U 2007/2008 4/75

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 :

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.

Niveau externe

Niveau conceptuel

Niveau interne


A.U 2007/2008 5/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 6/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 7/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

Installation Taille (sous 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 8/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 9/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 10/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 11/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 12/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 13/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 14/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 15/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 16/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 17/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 18/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 19/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 20/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 21/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 22/75

Pour l'instant, un seul module nous suffit.

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


A.U 2007/2008 23/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 24/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 25/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 26/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 27/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 28/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 29/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 - Pro duction 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 30/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 31/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 32/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 »

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

empno … job … sal

1100 ….. CLERK 500 …

1110 SALESMAN 600

…….

…..

Le plus grand salaire ???

MAX(sal)


A.U 2007/2008 33/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 34/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 : le salaire moyen par département 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 ;

empno … job … sal

1100 ….. CLERK 500 …

1110 SALESMAN 600

…….

…..

Deptno AVG(sal) 10 1500 20 1300 30 1350


A.U 2007/2008 35/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 (m onoligne) 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 (m ultiligne) Une sous-interrogation peut ramener plusieurs lignes à condition que l'opérateur de comparaison


A.U 2007/2008 36/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'interroga tion 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 37/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 Where job = (select job From emp Where empno=7800) AND Sal > (select sal From emp Where empno = 7654) ;

Réponse 2 : SQL> Select ename

From emp Where job = (select job 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 38/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 39/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 40/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 41/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 42/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 ta ble 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 43/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 44/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 45/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 46/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 47/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 48/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 49/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 50/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 51/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 explicit e

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 52/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

INTO nomvariable |

nomrecord

{nomvariable [


A.U 2007/2008 53/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 :

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 ;

Curseurs implicites Sql%Found Sql%Notfound Sql%Isopen Sql%Rowcount Sql%Rowtype

Curseurs explicites Nomcurseur%Found Nomcurseur %Notfound Nomcurseur %Isopen Nomcurseur %Rowcount Nomcurseur %Rowtype


A.U 2007/2008 54/75

CURSOR num_cur2 IS SELECT num from tab2 ; 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 CURSOR num_cur1 IS SELECT num from tab1 ; CURSOR num_cur2 IS SELECT num from tab2 ; 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 55/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 56/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 57/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 58/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 59/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 60/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 61/75

Les exceptions fournies par Oracle sont regroupées dans ce tableau : Nom d'exception Valeur SqlCode CURSOR_ALREADY_OPEN -6511 DUP_VAL_ON_INDEX -1 INVALID_CURSOR -1001 INVALID_NUMBER -1722 LOGIN_DENIED -1017 NO_DATA_FOUND -1403 NOT_LOGGED_ON -1012 PROGRAM_ERROR -6501 STORAGE_ERROR -6500 TIMEOUT_ON_RESOURCE -51 TOO_MANY_ROWS -1422 TR.ANSACTION_BACKED_OUT -61 VALUE_ERROR -6502 ZERO_DIVIDE -1476

Erreur Oracle ORA-06511 ORA-00001 ORA-01001 ORA-01722 ORA-01717 ORA-01413 ORA-01012 ORA-06501 ORA-06500 ORA-00051 ORA-01422 ORA-00061 ORA-06502 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 62/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 63/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 64/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 cara ctè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 65/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 66/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 67/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ès jé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 68/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 69/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 70/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 71/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 72/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 73/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 74/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.

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

support de cours « sgbd - · pdf filedonnée en utilisant merise. leurs travaux...

Documents