Vues: définition. Vues: avantages. Vues: inconvénients. Vues: exemple. Vues: syntaxe 08/12/2009

15  Download (0)

Full text

(1)08/12/2009. Vues: définition  Table virtuelle de la base de données dont le contenu est défini par un requête  La vue n’existe pas en tant qu’ensemble de données stockées sur le disque  seule la requête décrivant la vue est stockée. 2. Vues: avantages. Vues: inconvénients.  indépendance logique.  performance. exemple:. . infoDepartement_vue(idDept, nomDept, Loc, nbEmp, SalTot);.  simplification de requêtes département de plus de 10 employés et dont la masse salariale est inférieure à 20 K€ ?. la traduction de la requête peut être longue.  restriction des mises à jour . possibilité de mise à jour qu’à partir de vues simples.  isolation des modifications - - emp sans indiquer le salaire emp_vue(idEmp, nom, prénom, job, idDept).  sécurité  intégrité des données 4. 3. Vues: exemple. Vues: syntaxe. CREATE VIEW emp_recherche AS SELECT * FROM emp, dpt WHERE emp.idEmp = dpt.idDept AND nomDept=’Recherche’ ;. CREATE [OR REPLACE] VIEW nomvue [col,…] AS SELECT syntaxe select [WITH CHECK OPTION [CONSTRAINT] nom];. DROP VIEW nomvue;. SELECT * FROM emp_recherche ;. RENAME ancien_nom TO nouveau_nom;. 5. 6. 1.

(2) 08/12/2009. Vues: mise à jour. Vues : contrôle d’intégrité.  Conditions. CHECK OPTION : cette clause permet d’interdire d’insérer ou de modifier à travers la vue des n-uplets qui ne satisferaient pas à la définition de la vue..  construite sur une seule table  possible sur vue comportant une jointure si les modifications/suppressions/insertions ne concernent qu’une table de la jointure  pas de GROUP BY  les colonnes résultats doivent être des colonnes réelles de la. table (non calculées).  la vue contient toutes les colonnes NOT NULL de la table.  Permet  d’insérer à travers la vue de nouveaux n-uplets  de supprimer des n-uplets de la table à partir de la vue  de mettre à jour la table par l’intermédiaire de la vue 7. 8. Check Option: exemple. Vue matérialisée. > CREATE OR REPLACE VIEW empInge AS SELECT * from emp WHERE job= ‘Ingenieur’ WITH CHECK OPTION CONSTRAINT Check_inge;.  Vue physique d'une table (SNAPSHOT)  Duplication des données => nécessité de synchroniser les données. > UPDATE empInge SET job=’manager’ WHERE idEmp=’1123’ ;. => à n’utiliser que pour des requêtes particulièrement lourdes. > ORA-01402: view WITH CHECK OPTION clause violation.  La fréquence des mises à jour de la vue matérialisée est à préciser 9. Vue matérialisée: syntaxe. 10. Vue matérialisée: mode de rafraichissement Modes de refresh:  sur commit : clause ON COMMIT. CREATE MATERIALIZED VIEW <nomVue> REFRESH <précisions mise à jour> AS <requête>;. . à la demande (asynchrone, mode par defaut): clause ON DEMAND (utilise des procédures du package standard DBMS_MVIEW). execute DBMS_REFRESH.MAKE('group_vue’, ‘vueMat1’); execute DBMS_REFRESH.REFRESH('group_vue');. Les données de la table sont copiées dans la vue matérialisée à sa création. 11. . périodique : clauses START WITH et NEXT, qui précise une date de début et une période de temps intermédiaire CREATE MATERIALIZED VIEW vueMat1 REFRESH START WITH SYSDATE NEXT SYSDATE + 1 AS SELECT * FROM emp WHERE job = ‘ANALYST’; 12. 2.

(3) 08/12/2009. Embedded SQL  Les manques de SQL:  structures de programme  structures de contrôle  structures de données  facilités pour les entrées/sortie  problème pour développer des applications  Approche « Embedded SQL »  Insertion de SQL dans un langage de programmation  technique de pré-compilation  normalisation (Pascal, C, …) . Pro*C/C++ pour Oracle.  Inconvénients  deux systèmes de types  correspondance ensembliste/unaire  deux styles de programmation 13. Exemple: JDBC. 14. Exemple: SQLJ (préprocesseur SQL). // Exemple de programme JAVA qui utilise le pilote JDBC OCI8 d'Oracle // pour insérer une ligne dans la table Client // Il faut importer le paquetage java.sql pour utiliser JDBC. // Définition de la classe IteratorClient avec liaison par nom #sql iterator IteratorClient(int noClient, String nomClient);. import java.sql.*; class ClientInsertJDBC { public static void main (String args []) throws SQLException, ClassNotFoundException, java.io.IOException { // Charger le pilote JDBC d'Oracle Class.forName ("oracle.jdbc.driver.OracleDriver");. // Création d'un objet itérateur IteratorClient unIteratorClient; // Liaison de l'énoncé SELECT de l'itérateur #sql unIteratorClient = { SELECT idClient, nomClient FROM Client WHERE idClient > 40};. // Connexion à une BD Connection uneConnection = DriverManager.getConnection ("jdbc:oracle:oci8:@", "Scott", "Tiger");. // Accès au résultat du SELECT par itération sur les lignes while (unIteratorClient.next()){ System.out.println("Numéro du client : " + unIteratorClient.idClient()); System.out.println("Nom du client : " + unIteratorClient.nomClient()); }. // Création d'un énoncé associé à la Connection Statement unEnoncéSQL = uneConnection.createStatement (); // Insertion d'une ligne dans la table Client int n = unEnoncéSQL.executeUpdate. // Fermer l'itérateur unIteratorClient.close();. ("INSERT INTO CLIENT " + "VALUES (100, 'Smith', '911')"); System.out.println ("Nombre de lignes inserees:" + n); // Fermeture de l'énoncé et de la connexion unEnoncéSQL.close(); uneConnection.close(); } }. 15. Annexe: SQL intégré dans un langage de programmation => LINQ (.net). 16. Extensions procédurales SQL Principe:  ajout à SQL de structures de contrôle => SQL + outils procéduraux => notion de « procédures stockées ». var ensemblePays = new Pays[]{ new Pays("France", 60000000, 550000), new Pays("Turquie", 70000000, 750000), new Pays("Chine", 1300000000, 9600000), new Pays("USA", 300000000, 9000000), new Pays("Maroc", 31000000, 450000), new Pays("Suisse", 7500000, 40000) }; var grosPays = from p in ensemblePays where p.Superficie > 1000000 select p;. Standardisation: PSM (Persistent Stored Modules)  Exemples:. ….  MySQL: SQL/PSM. foreach (var p in grosPays) { Console.WriteLine(p); }.  Oracle: PL/SQL  PostgreSQL: PL/PSM et PLpgSQL 17. 18. 3.

(4) 08/12/2009. PL/SQL • • • •. Extension de SQL Langage de programmation procédural (PSM)‫‏‬ Clauses SQL intégrées dans le code procédural PL/SQL est donc un langage de programmation propre à Oracle (PL/SQLg existe aussi pour postgreSQL) : • • •. intégre directement les clauses SQL d’interrogation, de manipulation (généralement pas de définition des données) permet l’encapsulation des données dans du code gestion des exceptions. 19. Environnement PL/SQL. 20. Bénéfices de PL/SQL. SQL. Application. SQL SQL. • PL/SQL regroupe les requêtes SQL en un seul bloc qui est. SGBD. envoyé au serveur en un seul appel => amélioration des performances (moins de communications sur le réseau)‫‏‬. SQL. SQL IF . . . THEN SQL ELSE SQL END IF ; SQL. Application. Oracle PL/SQL. • Permet de créer des bibliothèques de code réutilisable. => programmation de fonctions, procédures, packages. Bloc PL/SQL 21. Caractéristiques de PL/SQL •. • Bloc anonyme :. Structures de contrôle. •. Utilisation des curseurs. – – – – – –. bloc PL/SQL imbriqué dans une application ou créé interactivement. variables locales variables d’environnement extérieures à PL/SQL. •. •. Environnement PL/SQL. Gestion des variables – –. traitements conditionnels traitements répétitifs. • Procédure enregistrée :. bloc nommé enregistré dans le serveur Oracle et qui peut être invoqué par son nom. définition utilisation de curseurs explicites attributs des curseurs modification des valeurs d’un curseur. • Package :. module PL/SQL qui regroupe un ensemble de procédures. Gestion des erreurs – – –. 22. anomalies programme utilisateur erreurs Oracle erreurs prédéfinies. • Trigger :. bloc associé à une table et déclenché automatiquement lors d’une requête. 23. 24. 4.

(5) 08/12/2009. Bloc PL/SQL. Bloc PL/SQL.  Tout bloc PL/SQL est composé de 3 sections 1. DECLARE (optionel)‫‏‬ • variables, constantes, curseurs. 2. BEGIN (obligatoire)‫‏‬ • clauses SQL • instructions PL/SQL. 3. EXCEPTION (optionel)‫‏‬ • actions à réaliser quand une exception est levée END;. Exemple de bloc PL/SQL: DECLARE salaire_v NUMBER(5); BEGIN SELECT INTO FROM. (obligatoire)‫‏‬. salaire salaire_v emp ;. EXCEPTION WHEN exception_e THEN ... END;. Un bloc peut contenir un ou plusieurs autres blocs 25. 26. Variables dans PL/SQL. Exécution Bloc PL/SQL Fichier monfichier.sql BEGIN dbms_output.put_line(‘Hello World’) ; Bloc anonyme END ; / Permet l’affichage Pour que le bloc sur la console soit exécuté dans SQLPlus (dbms_output) SQL> set serveroutput on ; Charge le contenu SQL> @C:\Mes Documents\monfichier.sql de monfichier.sql SQL > Hello World. Utiliser les variables pour : • L’enregistrement temporaire des donnéees comme dans tout langage de programmation procédural. •. La manipulation de données enregistrées afin de réaliser des calculs et autres manipulations sans accéder à la base de données. •. La réutilisabilité: une fois déclarée, une variable peut être utilisée plusieurs fois dans une application.. •. La facilité de maintenance: en utilisant %TYPE et %ROWTYPE (présenté plus tard), on déclare des variables ayant le même type que des attributs de tables, si la définition de la table change, le type de la variable change de même. => réduction des coûts de maintenance. 27. Types de variables. 28. Déclaration de variables • Syntaxe :. • Scalaires valeurs simples, les principaux types sont ceux de SQL. <nom> [CONSTANT] <type> [NOT NULL] [ := | DEFAULT <expression> ] ; • Exemple :. • Composites les enregistrements permettent de définir des données structurées. DECLARE dateEmprunt_v noDept _v lieu_v taux_c. DATE ; NUMBER(2) NOT NULL := 10 ; VARCHAR2(13) := ‘Paris’ ; CONSTANT NUMBER := 20 ;. • Note : constantes et variables NOT NULL doivent être. immédiatement affectées. 29. 30. 5.

(6) 08/12/2009. Convention. Affectation de valeurs dans une variable. • Toute variable doit être déclarée pour pouvoir être utilisée • Une variable au maximum déclarée par ligne • Les noms de variable doivent commencer par une lettre et ont 30 caractères au maximum • Portée de bloc pour les variables, masquage de variables. dans les sous-blocs. • Affectation d'une valeur à une variable :. <nom_de_variable> := <expression> • Stockage du résulat d'une requête :. • Nom des tables, attributes, ..., objets de la base ont la. priorité sur les noms de variables. SELECT . . . INTO <nom_de_variable> FROM . . . WHERE . . .. • Par convention, utiliser les suffixes :. ‘_c’ pour les constantes ‘_v’ pour les variables ‘_g’ pour les variables globales 31. Types scalaires PL/SQL. Types définis par l’utilisateur. • CHAR [(<taille_max>)] • • • • •. 32. •. chaînes de caractères de longueur fixe (max 32767) VARCHAR2 (<taille_max>) chaînes de caractères de longueur variable (max 32767)‫‏‬ NUMBER [(<p>, <s>)] nombres réels, p chiffres en tout, s après la virgule PLS_INTEGER prennent moins de place et sont plus rapides que les valeurs de type number et binary_integer DATE BOOLEAN trois valeurs possibles : TRUE, FALSE et NULL. Syntaxe : TYPE. •. <nom_type> IS RECORD ( <nomchamps> <type> [ [NOT NULL] [ := <expression> ] ], ... ) ;. Exemple : SQL> DECLARE TYPE client_t IS RECORD ( numero NUMBER(4), nom CHAR(20) , adresse CHAR(20) ) ; client1_v client_t ; BEGIN client1_v.numero := 2516 ; ... END ; /. 33. L’attribut %TYPE et %ROWTYPE. Type tableau •. Syntaxe :. •. Exemple :. •. TYPE <nom_type> IS. VARRAY (<size>) OF <type>. %TYPE : permet d’identifier dynamiquement le type d’un variable à partir de : – la définition d’un attribut de table – la définition d’une autre variable déclarée précédemment Remarque: les contraintes NOT NULL de la définition des attributs de tables ne sont pas conservées avec %TYPE. DECLARE TYPE tab_emp IS VARRAY(10) OF VARCHAR2(64); tab1 tab_emp; BEGIN tab1 := tab_emp(); tab1.EXTEND(3); tab1(1) := ‘CLARK’; tab1(2) := ‘STONE’; ... END ; /. 34. Exemple : nomEmploye_v solde_v soldeMinimal_v •. employe.nomEmp%TYPE ; NUMBER(7, 2) ; solde_v%TYPE := 2000 ;. %ROWTYPE: identifie dynamiquement le type (structuré) d’un n-uplet d’une table Exemple : dateCommande_v Commande.dateCommande%TYPE ; commande_v Commande%ROWTYPE ;. DBMS_OUTPUT.PUT_LINE( tab1(1) ) ;. 35. 36. 6.

(7) 08/12/2009. Opérateurs. Exemples. • Arithmétique: +, -, *, /, **. • Incrémenter l’index d’une boucle compte_v := compte_v + 1;. • Concaténation de chaîne: ||. • Affectation de la valeur d’un drapeau booléen egales_v := (n1_v = n2_v);. • Parenthèse pour contrôler les priorités des opérations • Affectation. := • Rechercher si une variable a une valeur affecte_v := (nemp_v IS NOT NULL). • Comparaison =, <>, <, >, <=, >=, IS NULL, LIKE, BETWEEN, IN • Logique: AND, OR, NOT 37. 38. Structures de contrôle. Branchement conditionnel. • Branchements conditionnels. Syntaxe : IF <condition> THEN commandes ; [ELSIF <condition> THEN commandes ; ]* [ELSE commandes ; ] END IF ;. – IF - THEN - END IF – IF - THEN - ELSE - END IF – IF - THEN - ELSIF - END IF – CASE. • Boucles – LOOP - END LOOP – FOR - END LOOP. Note : vous pouvez utiliser l’expression IS NULL dans les conditions. – WHILE - END LOOP – Note : la commande EXIT permet de sortir de tout type de boucle 39. 40. Branchement conditionnel. CASE. Exemple:. Syntaxe:. IF nomEmploye_v = ‘Tiger’ THEN salaire_v := salaire_v * 3 ; ELSIF nomEmploye_v = ‘Scott’ THEN salaire_v := salaire_v * 2.5 ; ELSE salaire_v := salaire_v * 2 ; END IF;. CASE expression WHEN expr1 THEN instruction 1; WHEN expr2 THEN instruction 2; … ELSE instructionsN; END CASE;. 41. 42. 7.

(8) 08/12/2009. Boucle LOOP. Boucle LOOP Exemple :. Syntaxe : LOOP commandes ; . . . EXIT [WHEN <condition>] ; END LOOP ;. DECLARE numEmp_v NUMBER (3) := 1; BEGIN LOOP INSERT INTO Emp (numEmp, nomEmp, jobEmp, numDpt) VALUES (numEmp_v, ‘Analyste’ || to_char(numEmp), ‘Analyste’, 10) ; numEmp_v := numEmp_v +1 ; EXIT WHEN numEmp >= 10 ; END LOOP ; END ;. Note : Sans commande EXIT, les boucles LOOP sont infinies. 43. Boucle FOR Syntaxe : FOR <compteur> IN [REVERSE] <limite_inf> .. <limite_sup> LOOP commandes ; . . . END LOOP. 44. Boucle WHILE Syntaxe : WHILE <condition> LOOP commandes ; . . . END LOOP ; Exemple :. Exemple :. DECLARE numEmp_v NUMBER (3); BEGIN numEmp_v := 1;. DECLARE numEmp_v NUMBER (3); BEGIN FOR numEmp_v IN 1 .. 10 LOOP INSERT INTO Employe (numEmp, nomEmp, jobEmp, numDpt) VALUES (numEmp_v, ‘Analyste’ || to_char(numEmp), ‘Analyste’, 10) ; END LOOP ; END ;. WHILE noEmp_v <= 10 LOOP INSERT INTO Employe (numEmp, nomEmp, jobEmp, numDpt) VALUES (numEmp_v, ‘Analyste’|| to_char(numEmp), ‘Analyste’, 10) ; numEmp_v := numEmp_v +1 ; END LOOP ; END ; 45. 46. Exemple. Inclure une requête SELECT dans PL/SQL DECLARE numDept_v NUMBER(2) ; loc_v VARCHAR2(15) ; BEGIN SELECT numDept, lieu INTO numDept_v, loc_v FROM Dept WHERE numDept = ‘Rech’ ; . . . END ;. DECLARE sommeSalaires_v Employe.salaire%TYPE ; numDept_v NUMBER NOT NULL := 10 ; BEGIN SELECT SUM(salaire) INTO sommeSalaires_v FROM Employe WHERE numDept = noDept_v ; ... END ;. ATTENTION : La requête doit retourner un et un seul n-uplet Si ce n’est pas le cas, les exceptions NO_DATA_FOUND ou TOO_MANY_ROWS sont levées 47. 48. 8.

(9) 08/12/2009. Contrôler les transactions dans PL/SQL •. La première commande INSERT/UPDATE/DELETE/CREATE/DROP d’un bloc entame une nouvelle transaction. •. La fin du bloc ne termine pas la transaction. •. Pour terminer explicitement une transaction, utiliser les commandes SQL :. Contrôler les transactions dans PL/SQL DECLARE numDpt_v emp.numDept%TYPE := 10 ; majorationSalaire_v emp.salaire%TYPE := 2000 ; BEGIN COMMIT ;. COMMIT => valide les modifications faites depuis le début de la transaction en cours, et entame une nouvelle transaction – ROLLBACK => annule toutes les modifications faites depuis le début de la transaction en cours , et entame une nouvelle transaction –. •. Note : Une transaction doit être un ensemble homogène de manipulations de la base de données => il faut réflechir à tous les endroits où il est légitime de mettre un COMMIT. DELETE FROM Emp WHERE numDpt = numDpt_v ; UPDATE Emp SET salaire = salaire + majorationSalaire_v WHERE job = ‘Analyste’ ; COMMIT ; END ;. 49. Requête retournant plus d’une ligne résulat. 50. Qu’est-ce qu’un curseur. • Nécessite l’utilisation de curseur. • Jusqu’à présent, l’utilisation de l’instruction SELECT est. limitée aux requêtes renvoyant une et une seule valeur Toute requête renvoyant un résultat de cardinalité différente de 1 aboutit à un échec. => les curseurs sont des zones de travail privées, utilisées pour stocker le résultat d’une requête et qu’il est possible de parcourir. • Définition : un curseur est un mécanisme permettant. d’utiliser une instruction SELECT renvoyant un nombre quelconque de n-uplets • Note : à toute requête SQL exécutée par le serveur Oracle. est associé un curseur. 51. Qu’est-ce qu’un curseur. 52. Utilisation du curseur. • Un curseur peut être considéré comme une fenêtre sur l’ensemble des résultats d’une requête. • Les curseurs doivent être utilisés lorsque l’on désire. parcourir la totalité du résultat d’une requête SELECT. NumVille. Date. Température. A512 A512 A512 A512 A512 A512. 25-MAR-1997 26-MAR-1997 27-MAR-1997 28-MAR-1997 30-MAR-1997 01-APR-1997. 26 28 29 40 27 25. Curseur. • En particulier si cette requête renvoie un résultat de. cardinalité > 1. • Le curseur pointe toujours sur une valeur du résultat de la. requête à laquelle il est associé. • Un curseur permet :. • On distingue deux types de curseurs :. – – –. – curseurs implicites : déclarés implicitement par PL/SQL lors de tout SELECT – curseurs explicites : créés par le programmeur. 53. de garder trace d’une requête SELECT de parcourir n-uplet par n-uplet le résultat d’un SELECT d’accéder à la totalité du résultat d’un SELECT 54. 9.

(10) 08/12/2009. Déclaration d’un curseur. Comment utiliser un curseur. • Syntaxe : CURSOR <nom de curseur> IS <instruction SELECT> ;. • Protocole d’utilisation : – – – –. Déclaration Ouverture Utilisation Fermeture. • Notes : – ne pas utiliser de clause INTO dans l’instruction SELECT. • Attributs associés aux curseurs • Fonctions associées aux curseurs • Parcours de curseurs. – si vous voulez manipuler les n-uplets dans un ordre spécifique, utilisez la. clause ORDER BY dans la requête. – on peut déclarer autant de curseurs que l’on souhaite – le contenu du curseur n’est pas calculé au moment de sa déclaration, mais. au moment de son ouverture. 55. Attributs associés aux curseurs •. Exemple. Exemple :. supprimer des n-uplets de la table Employe, imprimer le nombre de n-uplets supprimés. BEGIN DELETE FROM emp WHERE nomEmp='Tiger' ; IF (SQL%NOTFOUND) THEN dbms_output.put_line('Pas d’employé de ce nom'); END IF; END; / •. •. 56. DECLARE nbreNupletsSupp_v VARCHAR2(64); numDept_v Employe.noDept%TYPE := 10 ; BEGIN DELETE FROM emp WHERE numDept = numDept_v ;. Attributs des curseurs en utilisant les attributs de curseurs, vous pouvez tester le résultat de vos requêtes SQL – SQL%ROWCOUNT nombre de n-uplets affectés par la dernière requête SQL (entier)‫‏‬ – SQL%FOUND booléen, vaut TRUE si la dernière requête SQL a affecté au moins un tuple et faux sinon – SQL%NOTFOUND booléen, vaut TRUE si la dernière requête SQL n’a affecté aucun tuple et faux sinon – SQL%ISOPEN booléen indiquant si le curseur est ouvert ou fermé (par défaut, les curseurs implicites sont toujours fermés à la fin de la requête). nbreNupletsSupp_v := TO_CHAR(SQL%ROWCOUNT) || ‘ n-uplets supprimés’ ; DBMS_OUTPUT.PUT_LINE(nbreNupletsSupp_v) ; END ;. Note : à la place de ‘SQL’, utilisez le nom de votre curseur pour identifier l’état d’un curseur explicite 57. Fonctions associées aux curseurs Exemple :. •. 58. Fonctions associées aux curseurs - FETCH. DECLARE CURSOR departementVentes_curs IS SELECT * FROM dept WHERE nomDept = ‘Ventes’; unDepartement_row departementVentes_curs %ROWTYPE; BEGIN. • Syntaxe :. OPEN departementVentes_curs; LOOP FETCH departementVentes_curs INTO unDepartement_row; DBMS_OUTPUT.PUT_LINE(unDepartement_row.numDept); … END LOOP CLOSE departementVentes_curs; END;. •. Utiliser les fonctions associées aux curseurs pour accéder au contenu du résultat – OPEN <nom de curseur> ouverture du curseur, exécution la requête associée positionnement du pointeur juste avant le premier n-uplet du résultat si le résultat de la requête est vide, aucune erreur n’est levée – FETCH ... déplacement du pointeur vers le prochain n-uplet du curseur affectation du nouveau n-uplet pointé à une variable – CLOSE <nom de curseur> fermeture du curseur désallocation de la mémoire associée perte des données associées au curseur (=> fermer systématiquement les curseurs après utilisation)‫‏‬. FETCH <nom de curseur> INTO [[<varible1>, <varible2>, . . .] | <nom de record> ] ; Notes : – – – – – –. 59. seulement pour les curseurs explicites inclure le même nombre de variables dans la clause INTO qu’il y a d’attributs dans le SELECT associé au curseur mettre les variables dans le bon ordre Il est aussi possible d’utiliser un record (type correspondant à un n-uplet) ayant le type adapté utiliser le test %FOUND ou %NOTFOUND pour voir si la fonction FETCH a permit d’atteindre un nouveau n-uplet ou si l’on est à la fin du curseur avant le premier appel à la fonction FETCH, l’attribut %NOTFOUND du curseur vaut NULL => a prendre en compte pour éviter des boucles infinies. 60. 10.

(11) 08/12/2009. Parcours d’un curseur - Exemple. Parcours d’un curseur. DECLARE CURSOR departementVentes_curs IS SELECT * FROM Departement WHERE nomDept = ‘VENTE’ ; compteur_v number := 0 ;. • Syntaxe :. FOR <nom de record> IN <nom de curseur> LOOP <instructions> . . . END LOOP ;. • Notes : –. Il n’est pas nécessaire de déclarer le record, il est implicitement déclaré ne pas ouvrir ni fermer le curseur, les fonctions OPEN, FETCH et CLOSE sont appelés implicitement (au premier passage dans la boucle, à chaque passage, à la sortie de la boucle) – il est possible de mettre directement la requête à la place du nom de curseur, dans ce cas, il n’est plus utile de déclarer de curseur –. BEGIN FOR chaqueDepartement_row IN departementVentes_curs LOOP ... DBMS_OUTPUT.PUT_LINE(chaqueDepartement_row.numDept); compteur_v := compteur_v +1 ; ... END LOOP ; ... END ;. 61. Curseurs paramétrés. Parcours d’un curseur - Exemple DECLARE compteur_v. 62. Syntaxe :. number := 0 ;. – Déclaration. CURSOR <nom de curseur> ( [<nom de paramètre> [IN] <type> [:= <valeur>] ]* ) IS <instruction SELECT utilisant les paramètres> ; – Ouverture OPEN <nom de curseur> (<valeur1>, <valeur2>, . . . ) – Boucle FOR <nom de record> IN <nom de curseur> (<valeur1>, <valeur2>, . . . ) LOOP <instructions> . . . END LOOP ; – Fermeture CLOSE <nom de curseur>. BEGIN FOR chaqueDepartement_v IN ( SELECT * FROM Departement WHERE nomDept = ‘VENTES’ ) LOOP ... compteur_v := compteur_v +1 ; ... END LOOP ; ... END ;. 63. Curseurs paramétrés - Exemple DECLARE CURSOR departement_curs (nomDept_p SELECT * FROM Departement WHERE nomDept = nomDept_p ; compteur_v number := 0 ;. 64. SELECT … FOR UPDATE • SELECT classique : non verrouillé. varchar2) IS. • Problème: modification des n-uplets possible entre le. moment de l’interrogation (SELECT) et celui des opérations de modification (UPDATE). BEGIN FOR chaqueDepartement_row IN departement_curs (‘VENTE’) LOOP ... compteur_v := compteur_v +1 ; ... END LOOP ; ... END ;. • Solution : SELECT … FOR UPDATE  permet de verrouiller tous les n-uplets jusqu’au. prochain commit (et donc jusqu’à leur modification)  permet de garantir qu’aucun autre utilisateur modifiera les données entre le SELECT et l’ UPDATE/DELETE/INSERT correspondant. 65. 66. 11.

(12) 08/12/2009. Modification à partir d’un curseur. Les différents types de blocs Anonyme. Exemple :. [DECLARE]. DECLARE CURSOR departements_curs (nomDept_p varchar2) IS SELECT * FROMDepartement WHERE nomDept = nomDept_p FOR UPDATE departement;. BEGIN ... [EXCEPTION] ... END;. BEGIN FOR chaqueDepartement_v IN departements_curs (‘VENTE’) LOOP UPDATE departement SET nomDept = ‘SALES’ WHERE CURRENT OF departements_curs ; END LOOP ;. Procédure PROCEDURE <nom> IS ... BEGIN ... [EXCEPTION] ... END;. Fonction FUNCTION <nom> RETURN <type> IS ... BEGIN ... RETURN <valeur> ; [EXCEPTION] ... END;. END ; •. Commentaires : -- commentaires sur une ligne /* commentaires sur plusieurs lignes */. Notes : – ne pas oublier le ‘FOR UPDATE’ pour verrouiller les données lues – utiliser la clause ‘UPDATE . . . WHERE’ pour effectuer la modification. 67. 68. Procédure stockée. Types paramètres. SQL> CREATE PROCEDURE modifierQuantitéObjet 2 ( un_produit Produit.idProduit%TYPE, 3 nouvelleQuantite Produit.quantite%TYPE ) IS 4 BEGIN 5 UPDATE Produit 6 SET quantité = nouvelleQuantite 7 WHERE idProduit = un_produit; 8 END; 9 /. Create or replace NomProcedureOufunction [(paramètre1 IN | OUT | IN OUT type [,paramètre2 IN | OUT | IN OUT type]*, ... )]  IN (valeur par défaut) indique que le paramètre transmis par le programme. appelant n'est pas modifiable par la fonction. Procedure created..  OUT indique que le paramètre est modifiable par la procédure SQL> EXECUTE modifierQuantitéObjet(10,20);.  IN OUT indique que le paramètre est transmis par le programme appelant. et renseigné par la fonction. PL/SQL procedure successfully completed.. APPEL D’UNE PROCEDURE OU D’UNE FONCTION :. SQL> SELECT * FROM produit WHERE idProduit = 20;. EXECUTE Nom_Procédure(...) ; SELECT ..., Nom_Fonction(...), ... FROM ...; Variable := Nom_Fonction(...) ;. IDPRODUIT DESCRIPTION PRIXUNITAIRE QUANTITÉ ---------- -------------------- ------------ --------------20 vis35 2.25 20. 69. Déboguage du code PL/SQL. Procédures et fonctions. •. • •. Par défaut, seul le résultat de la compilation de la procédure/fonction est affiché (échec ou réussite) SHOW ERRORS sous SQL*plus permet de demander l’affichage des erreurs de compilation Package DBMS_OUTPUT Table USER_PROCEDURES, USER_SOURCE dans le dictionnaire. SQL> 2 3 4. SELECT text FROM USER_SOURCE WHERE name = 'FQUANTITÉENSTOCK' AND type = 'FUNCTION' ORDER BY line;. •. Suppression de procédures ou de fonctions – DROP PROCEDURE nom_procedure – DROP FUNCTION. 70. nom_fonction. TEXT -------------------------------------------------------------------------------FUNCTION fQuantitéEnStock (unNoArticle Article.noArticle%TYPE) RETURN Article. quantitéEnStock%TYPE IS uneQuantitéEnStock Article.quantitéEnStock%TYPE; BEGIN SELECT quantitéEnStock INTO uneQuantitéEnStock FROM Article WHERE noArticle = unNoArticle; RETURN uneQuantitéEnStock; TEXT -------------------------------------------------------------------------------END fQuantitéEnStock;. 71. 13 rows selected. 72. 12.

(13) 08/12/2009. Traitement d'exceptions (EXCEPTION, RAISE)‫‏‬. Les exceptions et erreurs • STORAGE_ERROR. • Déclarer: nomException EXCEPTION;. Dépassement de capacité mémoire • ZERO_DIVIDE. Division par zéro. • Soulever: RAISE nomException;. • NO_DATA_FOUND SELECT INTO ne retourne aucune ligne. • Capturer (dans le bloc exception): WHEN nomException THEN .... • TOO_MANY_ROWS SELECT INTO ne retourne plusieurs lignes • Fonction RAISE_APPLICATION_ERROR – Permet de retourner un message d’erreur – Numéro d’erreur entre -20000 et -20999 73. 74. Accès aux valeurs modifiées. Déclencheur (trigger)‫‏‬ • Automatiser des actions lors de certains événements du. • Utilisation des variables new et old. type : (AFTER | BEFORE) (INSERT | DELETE | UPDATE). • Si nous ajoutons/modifions un client nous pouvons. accéder/modifier le nom de ce client à partir de la variable :new.nom. • Syntaxe :. CREATE OR REPLACE TRIGGER nom_trigger Evénement [OF liste colonne] ON nom_table WHEN (condition) [FOR EACH ROW] Instructions PL/SQL. • Dans le cas de suppression ou modification, les anciennes valeurs sont dans la variable :old.nom. 75. 76. Package PL/SQL‫‏‬  Un package est constitué d’une signature/spécification (partie publique) et d’un corps. (implémentation du package)‫‏‬  La signature du package contient des éléments (prototypes de fonctions, variables) accessibles. à tous les utilisateurs du paquetage.  Le corps du package contient l’implémentation des fonctions et la partie privée du package. (fonctions et variables locales).  Droit d’exécution d'un package: accès à la spécification mais pas au corps (nécessite droit de. modification).  La surcharge de fonction est possible (plusieurs procédures ou fonctions de même nom, avec. des signatures différentes).  Chaque session qui utilise le package possède une instance du package (il n’y a donc pas. partage des variables)‫‏‬. 77. 78. 13.

(14) 08/12/2009. Corps du package. Signature du package La‫‏‬signature‫‏‬d’un‫‏‬package‫‏‬contient:. Le‫‏‬corps‫‏‏‬d’un‫‏‬package‫‏‬contient:.  Prototypes des procédures et des fonctions du package  Constantes et variables  Curseurs  Définitions d'exceptions.  Le corps des procédures et fonctions dont le prototype a été défini dans la signature  D'autre procédure, fonctions, variables, ... privés  Bloc d'initialisation possible. 79. Package PL/SQL. 80. Exemple: Signature Package PL/SQL create or replace package Func_Geom is. CREATE PACKAGE nomPaquetage AS listeDesSignaturesDesFonctions&Procédures END nomPaquetage ;. PI number := 3.1416;. CREATE PACKAGE BODY nomPaquetage AS délaration [déclaration]… BEGIN séquenceÉnoncésInitialisation END nomPaquetage;. function Perimetre(rayon in number) return number; function Surface(rayon in number) return number; ... end; /* package Func_Geom */. nomPaquetage.nomObjet. /. 81. 82. Utilisation de fonctions du package. Exemple: Corps Package PL/SQL create or replace package body Func_Geom is /* Implementation du package */. Dans une fonction: ... BEGIN val = Func_Geom.surface(2); ... END;. val_approx number := 4; /* Private variable */ function Perimetre(rayon in number) return number is begin return 2*PI*rayon; end; function Surface(rayon in number) return number is begin return PI*rayon*rayon; end; end Func_Geom; /. Dans une requête SQL: SELECT Func_Geom.surface(rayon) FROM Information_Place; 83. 84. 14.

(15) 08/12/2009. DBMS_OUTPUT. UTL_FILE Lecture et écriture dans des fichiers coté serveur (TEXT_IO coté client). Ecriture de texte dans un tampon. Utilisé pour le debugage, suivi du déroulement d'un programme.. Les fichiers ne peuvent être créés que dans les répertoires déclarés dans la base. Pour ajouter un répertoire, le droit create directory est nécessaire). Exemples de fonctions: Ecriture sur le tampon DBMS_OUTPUT.PUT(val [NUMBER|VARCHAR2|DATE]); DBMS_OUTPUT.NEW_LINE() DBMS_OUTPUT.PUT_LINE(val[NUMBER|VARCHAR2|DATE]); Lecture sur le tampon DBMS_OUPUT.GET_LINE(line varchar2, status out integer). Exemples de fonctions: Manipulation fichier FOPEN(location varchar2, filename varchar2, open_mode varchar2 /*rwa*/) return UTL_FILE.FILE_TYPE /* desc fich */; IS_OPEN (file FILE_TYPE) FCLOSE(file FILE_TYPE) Ecriture UTL_FILE.PUT(file FILE_TYPE, buffer VARCHAR2); Lecture UTL_FILE.GET_LINE(file FILE_TYPE, buffer out VARCHAR2). 85. 86. DBMS_LOB. Autres package. DBMS_LOB permet la manipulation de grands objets, en particulier leur lecture et écriture. Plus de 150 packages:. BLOB: Binary LOB BFILE: Binary file (stocké en dehors de la base, read-only) CLOB: Character LOB NCLOB: CLOB Multibyte character. DBMS_FLASHBACK: restauration de la base vers une version précédente DBMS_SCHEDULER: ordonnancement de tache (tache périodique). Exemples de fonctions:. DBMS_SQL: SQL généré dynamiquement. APPEND (dest BLOB, src BLOB) COPY COMPARE INSTR ... READ WRITE. DBMS_STATS: statistiques sur la base UTL_HTTP, UTL_MAIL (définition mail), UTL_SMTP (envoie de mail) 87. 88. SQL dynamique. SQL dynamique Le SQL dynamique permet de construire dans un programme une requête SQL avant de l’exécuter.. /* Tableaux */ /* Using pour passer les valeurs d'une chaine dynamique*/. CREATE OR REPLACE PROCEDURE del(tableName_p varchar2, condition_p varchar2) IS where_clause varchar2(256); BEGIN IF condition_p IS NOT NULL THEN where_clause= ' where ' || condition_p; END IF;. DECLARE TYPE NumList IS TABLE OF NUMBER; empids NumList; BEGIN empids := NumList(101,102,103,104,105); FORALL i IN 1..5 EXECUTE IMMEDIATE 'UPDATE employees SET salary = salary * 1.04 WHERE employee_id = :1' USING empids(i); ... END; /. execute immediate 'delete from' || table_name_p || where_clause; END / exec del(emp); exec del(dpt, 'idDpt >= 20'); 89. 90. 15.

(16)

Figure

Updating...

References

Related subjects :