DESS IGSI Formation continue

INGENIERIE ET GESTION DES SYSTEMES D'INFORMATION

P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation continue
Bases de donnes
PARTIE I : Lenvironnement dOracle ................................................................................... 3
TD 2 ................... Traduction de rgles de gestion l'aide de dclencheurs Bases de Donnes
3
Objectifs ..............................................................................................................................................3
Environnement ...................................................................................................................................3
Actions ................................................................................................................................................3
PARTIE II : Dveloppement dapplications clientes avec Developper 2000 ......................... 7
TD 3 ................................................................ Le concept de formulaire dans Developer 2000
7
1 Rappel : Les trois principaux objets dun module ......................................................................7
Bloc (Block) ................................................................................................................................................... 7
Elment (Item) ............................................................................................................................................... 7
Canevas (Canvas) ........................................................................................................................................... 7
2 Cration d'un formulaire basique .................................................................................................8
3 Cration dun formulaire comportant un sous formulaire ........................................................9
4 Exercice ..........................................................................................................................................10
TD 4 .............. Dclencheurs d'applications et listes de valeurs Cration de boutons et de
dclencheurs associs crits en PL/SQL .......................................................................................... 12
1 Rappel : la gestion des cls trangres ........................................................................................12
2. Exercice 1 : cration dun formulaire exploitant une LOV .....................................................12
Action 1 : ..................................................................................................................................................... 12
Action 2 : ..................................................................................................................................................... 13
Action 3 : ..................................................................................................................................................... 14
3. Exercice 2 : amliorer l'utilisation d'une LOV .........................................................................14
4. Rappel : Les dclencheurs (triggers) .........................................................................................15
Exemple : Contrler laffichage dune LOV dans un formulaire ................................................................ 16
5. Exercice 3 : gestion de laffichage automatique dune LOV ...................................................16
Solution 1 : ................................................................................................................................................... 16
Solution 2 : ................................................................................................................................................... 16
Solution 3 : ................................................................................................................................................... 17
6. Exercice 4 : gestion de LOV dynamiques ..................................................................................17
TD 5 .............. Synchronisations entre les Blocs de donnes (FORMS) et la Base de Donnes
19
Rappel : notion de Bloc bas / non bas .........................................................................................19
1 Remplir le tableau dun Bloc avec des donnes stockes dans la Base de donnes .................................. 19
2 Modifier la Base de donnes via le tableau dun Bloc .............................................................................. 20
Exercice I : Contrler laffichage des valeurs dans un bloc ........................................................20
Exercice II : Cration dun bloc non bas avec les boutons Valider et Annuler .......................21
Execercie III : Afficher des donnes calcules dans un Elment non bas ................................22
Solution 1 : ................................................................................................................................................... 22
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
2
Solution 2 : ................................................................................................................................................... 23
Exercice IV : Slectionner dynamiquement les lments affichs dans un Bloc .......................23
Exercice V : Utilisation d'alertes ....................................................................................................24
Exercice VI : Gestion dune contrainte dintgrit au niveau de lapplication .........................24
Exercice VII : cration dune contrainte sur un item ..................................................................26
Exercice VIII : question de cours ...................................................................................................26
TD 6 ... Gestion spcifique des blocs matre/dtail lorsqu'il n'y a pas de jointure directe
entre les blocs. Gestion du remplissage des blocs dtails l'aide de dclencheurs crits en
PL/SQL .............................................................................................................................................. 27
I Cration dun bloc non bas affichant des donnes ...................................................................27
II Ajout d'lments calculs ............................................................................................................30

P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
3
PARTIE I : Lenvironnement dOracle

TD 2 Traduction de rgles de gestion l'aide de
dclencheurs Bases de Donnes

Objectifs
Pratique du langage PL/SQL
Conception de dclencheurs Bases de Donnes
Environnement
Voici le schma Oracle simplifi de la base de donnes relatif la Coupe du Monde de football
1998, modifi :
EQUIPES ( NE, NATIONALITE, PALMARES )
JOUEURS ( NJ, NOM, PRENOM, POSITION, MAILLOT, NE, NB_MATCH_EXPULSE
)
MATCHS ( NM, LIEU, DATE_R, NE_ RECEVANTE, NE_DEPLACANTE, ENJEU,
SCORE_RECEVANTE, SCORE_ DEPLACANTE,
SCORE_VALIDE)
PARTICIPANTS (NJ, NM, NB_BUTS, CARTON_JAUNE, CARTON_ROUGE )
Rgles de gestion
Lorsqu'un joueur obtient 2 cartons jaunes au cours d'un match, il reoit un carton rouge.
Lorsqu'un joueur reoit un carton rouge, il est expuls pour les deux matchs venir.
Evidemment, un joueur expuls ne doit pas pouvoir tre slectionn pour participer un match.
Afin de faire respecter ces rgles, les deux attributs suivants ont t rajouts respectivement
dans les tables JOUEURS et MATCHS :
NB_MATCH_EXPULSE indique tout moment pour combien de matchs le joueur est encore
expuls depuis le dernier match effectivement jou (le score est valid) par sont quipe.
SCORE_VALIDE vaut 1 si le match a t effectivement jou.
Actions
Proposez les dclencheurs ncessaires pour faire respecter ces rgles de gestion.
1. Crez sous votre compte votre propre base de donne l'image du schma ci-dessus.
2. Utilisez le Schema Manager pour crer vos dclencheurs.
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
4
Nous vous conseillons d'excuter la requte SQL gnre (create or replace trigger) sous le
Worksheet pour dtecter les ventuelles erreurs de syntaxe.
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
5
Solution
Action 3.1 :
Il faut crer quatre dclencheurs.
Le premier est associ la table PARTICIPANTS sur mise jour du nombre de cartons
jaunes. Si ce nombre atteint 2, le nombre de cartons rouges est mis 1.
Le deuxime dclencheur est associ la table PARTICIPANTS sur mise jour du nombre de
cartons rouges. Si ce nombre atteint 1, l'attribut NB_MATCH_EXPULSE de la table JOUEURS est
mis 3 pour le joueur en question.
Le troisime dclencheurs est associ la table MATCHS. Lorsque l'attribut
SCORE_VALIDE prend la valeur 1, on dcrmente de 1 l'attribut NB_MATCH_EXPULSE pour
tous les joueurs expulss des deux quipes participantes.
Le quatrime dclencheurs est associ la table PARTICIPANTS. Lorsque l'on tente d'insrer
une ligne dans cette table, l'insertion est refuse si le joueur en question est expuls.
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
6
Action 3.2 :

CREATE OR REPLACE TRIGGER "MONDIAL"."EXPULSER_jaune"
BEFORE INSERT OR UPDATE OF "CARTON_JAUNE" ON "MONDIAL"."PARTICIPANTS"
REFERENCING OLD AS OLD NEW AS NEW
FOR EACH ROW
BEGIN
IF :new.carton_jaune = 2
THEN
:new.carton_rouge := 1;
virez_le(:new.nj);
/* dbms_output.put_line('joueur '||:o.nj||' expuls'); */
END IF;
END;


CREATE OR REPLACE TRIGGER "MONDIAL"."EXPULSER_rouge"
BEFORE INSERT OR UPDATE OF "CARTON_ROUGE" ON "MONDIAL"."PARTICIPANTS"
REFERENCING OLD AS OLD NEW AS NEW
FOR EACH ROW
WHEN (new.carton_rouge=1)
BEGIN
update joueurs
set NB_MATCH_EXPULSE = 3
where nj = :old.nj;
END;


CREATE TRIGGER "MONDIAL".Expuls_moins_un
AFTER UPDATE OF "SCORE_VALIDE" ON "MONDIAL"."MATCHS"
REFERENCING OLD AS OLD NEW AS NEW
FOR EACH ROW
WHEN (new.score_valide=1)
begin
update joueurs
set NB_MATCH_EXPULSE = NB_MATCH_EXPULSE - 1
where NB_MATCH_EXPULSE >= 1
and ne in (:new.ne_deplacante, :new.ne_recevante);
end;


CREATE or replace TRIGGER "MONDIAL".ne_peut_participer
BEFORE INSERT ON "MONDIAL"."PARTICIPANTS"
REFERENCING OLD AS OLD NEW AS NEW
FOR EACH ROW
declare
virer number := 0 ;
begin
select 1 into virer
from joueurs
where nj = :new.nj
and NB_MATCH_EXPULSE >= 1;
if virer = 1 then
raise_application_error(-20101, 'Ce joueur est exclu');
end if;
exception WHEN_NO_DATA_FOUND then
null;
end;

P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
7
PARTIE II : Dveloppement dapplications clientes
avec Developper 2000

TD 3 Le concept de formulaire dans Developer 2000

1 Rappel : Les trois principaux objets dun module
Un formulaire est un lment interactif qui permet dinsrer, consulter et/ou mettre jours des
n-uplets stocks dans une base de donnes. ORACLE propose un environnement de dveloppement
permettant de concevoir de tels formulaires appel Developer 2000, qui sappuie lui mme sur un
environnement de plus base niveau appel FORMS. Dans cet environnement, les formulaires sont
grs au travers de modules. Chaque module constitue un client du serveur base de donnes
ORACLE.
Developer 2000 propose trois outils appels Form Builder, Form Compiler et Forms
Runtime, permettant respectivement de concevoir des formulaires, gnrer le code permettant
dexcuter ces formulaires dans lenvironnement dun systme dexploitation donn (Windows,
Unix, IBM ...) et dexcuter ce code. Afin de faciliter le dveloppement, Forms Builder permet
dexcuter directement les formulaires en cours de conception, en vue de les tester. Nous utiliserons
donc principalement cet outil.
Un module est principalement constitu des 3 lments suivants :
Bloc (Block)
Un bloc est une structure logique laquelle peut tre associe une table ou une vue de la
base de donnes (dans ce cas on dit quil est bas). Un bloc est lui mme constitue ditems.
Il peut tre cr manuellement ou automatiquement. Un bloc peut tre dfinit en mono ou
en multi-lignes. Pour un bloc bas, Forms prend en charge toutes les interactions avec la
base.
Elment (Item)
Un Item sert prsenter des donnes ou dclencher des commandes Forms ou des Triggers
en fonction de son type. Par exemple, un item de type texte permet dafficher un attribut du
bloc auquel il appartient, si ce bloc est bas sur une table ; un item de type bouton permet de
dclencher des actions comme passer au n-uplet suivant dans le bloc courant. Un item de
type texte peut tre simplement consultable ou consultable et modifiable. De plus, un item
peut tre visible ou invisible. Pour tre visible, il doit tre localis sur un canevas.
Canevas (Canvas)
Un canevas est une surface sur laquelle sont positionns des items, graphiques ou textes
destins tre affichs lcran au travers dune fentre.
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
8
La figure 1 reprsente un formulaire basique permettant de consulter et modifier les n-uplets
de la table JOUEURS. Ce formulaire est gr au travers du module MODULE11 constitu dun
bloc appel JOUEURS bas sur la table JOUEURS. Ce bloc comporte 4 items de type texte
permettant dafficher respectivement les N, Nom, Prnom et N dquipe des joueurs. Tous les
items sont localiss sur le canevas CANEVAS2, dont la fentre est reprsente sur la figure.
Ce formulaire a t gnr automatiquement, mais lemplacement des items peut tre modifi
directement en cliquant sur les objets reprsents dans la fentre du canevas. De mme les
proprits des lments du module ainsi gnr peuvent tre modifies au travers de la fentre
proprit. Par exemple pour interdire la misa jour des N des joueurs, on peut slectionner litem
NJ, puis cliquer sur le bouton de droite de la souris pour faire apparatre les proprits de cet item
comme illustr figure 2. La proprit interrogation seulement peut alors tre mise vrai.

Figure 1 : Un module et la fentre du canevas correspondant.
Figure 2 : proprits de litem NJ
2 Cration d'un formulaire basique
Le TD utilise la base de donne Mondial. Vous pouvez consulter son schma laide du
Schema Manager ou dans le Navigateur (Objets de la base de donnes) si vous tes connects..
Crer le formulaire permettant de consulter les joueurs et de les modifier.
Lancer Oracle/Forms and Reports/Form Builder et utiliser les assistants. Vous devez au
passage cliquer sur le bouton parcourir pour slectionner la table JOUEURS. Cette action va
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
9
dclencher une connexion ORACLE pour contrler que vous avez accs au schma de la base de
donnes. Choisissez les colonnes qui vous intressent puis demandez utiliser lassistant de
prsentation.
Cliquer sur le bouton feu vert pour gnrer et tester le code du nouveau module (client).
Cliquer sur le bouton excuter linterrogation pour visualiser les joueurs.
Modifier les proprits de litem NOM pour interdire la mise jour du nom des joueurs.
Jouer avec la fentre et le canevas.
3 Cration dun formulaire comportant un sous formulaire
Crer le formulaire permettant dafficher les quipes avec leurs joueurs respectifs. Le module
correspondant sera compos de deux blocs dont un bloc matre et un bloc esclave (voir figure 3). Le
bloc matre est le bloc EQUIPES. Il pilote laffichage des n-uplets dans le bloc esclave qui est le
bloc JOUEURS. En effet, le bloc JOUEURS ne doit afficher que les joueurs de lquipe en cours
dans le bloc EQUIPES. Ainsi les deux blocs sont relis par une relation dont le but est dexprimer
la condition de jointure entre les deux tables : EQUIPES.NE = JOUEURS.NE. Le bloc EQUIPES
est un bloc de type formulaire qui affiche un n-uplet la fois, tandis que le bloc JOUEURS est un
bloc de type table. On fera en sorte que ce dernier affiche 11 joueurs et possde un ascenseur.
Crer ce formulaire en utilisant les assistants comme suit. Crer tout dabord un bloc basique
pour la table EQUIPES comme prcdemment. Ajouter ensuite un bloc pour la table joueurs :
cliquer sur llment blocs de donnes pour le slectionner, puis cliquer sur le bouton + pour
ajouter un bloc et demander utiliser lassistant. Noubliez pas de slectionner la colonne NE la
cration du bloc Equipe sans quoi la jointure ne pourrait pas tre ralise. Par contre il nest pas
ncessaire dafficher cette colonne puisquelle est dj renseigne dans le bloc EQUIPES.
Si la liaison entre les deux blocs ne sest pas faite automatiquement, double cliquez sur le
composant relation du bloc EQUIPES, slectionnez le bloc joueurs comme bloc esclave et entrez la
condition de jointure comme sur la figure 4.
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
10

Figure 3 : formulaire avec un bloc matre et un bloc dtail Figure 4 : Cration de la relation entre 2
blocs
Remarquez la cration de deux dclencheurs destins la synchronisation de laffichage dans
les deux blocs.

Remarques :
Le dclencheur ON-POPULATE-DETAILS remplit le bloc dtail chaque changement de
ligne dans le bloc matre. Si le code de ce dclencheur est altr, la synchronisation entre
les deux blocs ne se fait plus. Dans ce cas, nous suggrons de supprimer la relation (ce qui
a pour effet de supprimer les dclencheurs associs), et de la recrer.
Le dclencheur PRE-DELETE excute un code redondant avec la contrainte dintgrit
rfrentielle dclare dans la base de donnes pour lattribut NE de la table JOUEURS.
Vous pouvez le supprimer.
4 Exercice
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
11
Concevoir des blocs simples de gestion pour chaque relation de votre base Mondial et de
gestion pour chaque relation de la base Mondial du compte Mondial. Vous disposerez ainsi de
moyens personnels pour consulter et mettre jour facilement les deux bases.
Concevoir des blocs Matres Dtails
- Equipes Joueurs (de chaque quipe) Participants (de chaque joueur)
- Matchs Participants (de chaque match)
- Equipes Matchs (que les quipes soient recevantes ou dplaantes) Participants (de
chaque match de chaque quipe)
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
12
TD 4
Dclencheurs d'applications et listes de valeurs
Cration de boutons et de dclencheurs associs
crits en PL/SQL

1 Rappel : la gestion des cls trangres
Les cls trangres sont utilises pour relier les tables entre elles. Les cls trangres posent
gnralement deux problmes lutilisateur final :
1- elles ne peuvent contenir que des valeurs existant dans la table rfrence (contrainte
dintgrit rfrentielle). En effet une cl trangre contenant une valeur qui nexiste pas
dans la table rfrence na pas de sens.
Par exemple : si lattribut NE de la table Joueurs contient une valeur qui nexiste pas dans la
table Equipes, cest quivalent dire que ce joueur appartient une quipe qui nexiste pas.
2- les cls sont souvent peu parlantes pour lutilisateur final.
Par exemple : quelle est la nationalit de lquipe 3 ? quelle est la nationalit de lquipe 2 ?
Dans le cas dun formulaire avec sous formulaire ces problmes sont souvent inexistants. Par
exemple, le formulaire Equipes_Joueurs cr au TD prcdent constitue le moyen idal pour saisir
une quipe avec tous ses joueurs. La cl trangre NE de la table JOUEURS est renseigne
automatiquement en fonction de la cl de lquipe courante dans le formulaire principal.
Dans le cas dun formulaire simple, ces deux problmes peuvent tre rsolus en utilisant un
objet "liste de valeurs" (LOV pour List Of Values) dans le module :
Une LOV est une interrogation permettant dafficher lensemble des valeurs possibles et den
slectionner une. De plus, une LOV permet dassocier ces valeurs des information plus parlantes
quune valeur de cl (par exemple, nationalit de lquipe).
2. Exercice 1 : cration dun formulaire exploitant une LOV
1. Crer au moyen des assistants un formulaire simple pour la table PARTICIPANTS.
Cette table contient deux cls trangres : NJ et NM.
2. Cration dune LOV pour NJ :
Double cliquez sur lobjet LOV de votre module pour crer la LOV et slectionnez lassistant.
Renommez la LOV cre LOV_NJ
Actions impliques par la cration dune LOV
Action 1 :
Cration dune requte associe la LOV. Cette requte permet de construire dynamiquement
les valeurs de cette liste lorsque la LOV est invoque. Cette requte est stocke dans un composant
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
13
du module appel groupe denregistrements(record group ou group dans la documentation). La
figure 1 illustre la cration dun groupe denregistrement. La requte associe slectionne les n des
joueurs de la table JOUEURS, mais aussi les noms et prnoms des joueurs, qui sont plus parlants
pour lutilisateur final.

Figure 1 : La requte associe une LOV
Action 2 :
Spcification des colonnes de la requte qui seront affectes un lment dun bloc du
module. Cette spcification se fait au moyen de la proprit de "correspondance de colonne" du
composant LOV en cours de cration. Vous pouvez consulter ou modifier cette spcification en
cliquant sur le bouton "Suite" de cette proprit. Dans notre cas, il faut associez la colonne NJ de la
LOV llment NJ du bloc (voir Figure 2).



Figure 2 : Association de la colonne NJ de la liste llment NJ du bloc
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
14
Action 3 :
Association de la LOV llment rcepteur du bloc. Cela se fait au moyen de la proprit
LOV de llment. Dans notre cas, la proprit LOV de litem NJ a t modifie pour signaler
quune LOV est associe cet item (voir Figure 3).

Figure 3 : affecter une LOV un Item
3. Tester le module. Lorsque lon clique sur litem NJ, la barre dtat indique quune liste de
valeurs est disponible. Pour afficher cette liste appuyez sur la touche fonction F9.

Remarque
Pour connatre les touches fonction de Forms et leur rle, activez le menu Aides/Touches.
3. Exercice 2 : amliorer l'utilisation d'une LOV
Vous pouvez remarquer que la LOV cre pour NJ n'est pars facile exploiter par l'utilisateur
final. En effet, pour slectionner un joueur par son nom, il faut faire dfiler toute la liste avec un
ascenseur. Or, la fentre d'affichage d'une LOV comporte un outil de recherche. Cet outil
s'applique exclusivement la premire colonne affiche dans la LOV. Ainsi, il serait souhaitable de
rcrire la requte associe la LOV afin d'afficher en premier le nom du joueur. La requte
modifie et la LOV associe sont affichs ci-dessous. Attention, il est ncessaire de trier le rsultat,
pour que les outils de recherche fonctionnent.
SELECT ALL JOUEURS.NOM, JOUEURS.PRENOM, JOUEURS.NE, JOUEURS.NJ
FROM JOUEURS
ORDER BY 1


4. Crez une LOV pour NM.
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
15
4. Rappel : Les dclencheurs (triggers)
Il existe plusieurs solutions pour contrler laffichage de la LOV associe un item (lment),
afin dviter lutilisateur non averti davoir utiliser la touche F9. Ces solutions utilisent toutes
des dclencheurs provoquant lexcution dun programme crit en PL/SQL lorsquun vnement
intervient.
Un dclencheur (trigger) est dfinit par trois principaux composants :
- son type (vnement associ) ;
- son code (bloc PL/SQL);
- son niveau de dfinition (objets auquel il est associ).
Les objets auxquels il est possible dassocier des dclencheurs sont les modules de type
"application forms", les blocs et les lments des blocs (items).
Les vnements permettant dactiver un dclencheur dpendent du type dobjet auquel est
associ le dclencheur (module, bloc ou item). Ces vnements sont classs en cinq catgories :
- PRE- se dclenche avant une action forms ;
- POST- se dclenche aprs une action forms ;
- WHEN- se dclenche au mme moment quune action forms (permet daugmenter les
fonctionnalits de forms) ;
- ON- se dclenche la place dune action forms ;
- KEY- se dclenche la place dune fonction touche standard.
Pour obtenir la liste de ces vnements avec leur signification prcise utiliser la commande
de laide de developper/2000 Aide/Form builder Rubrique daide/Rfrence PL/SQL /Dclencheurs.
Vous pouvez aussi passer par la commande rechercher du menu Aide/Form builder Rubrique
daide.
Rappelons que la structure dun bloc PL/SQL est la suivante :
[DECLARE]
- variables, constantes, curseurs, expressions utilisateurs
BEGIN
- Ordres SQL
- Instructions de contrle PL/SQL
[EXCEPTIONS]
- Traitements effectuer lors des erreurs
END ;
Chaque instruction lintrieurs du bloc se termine par un point virgule.
Comme indiqu ci-dessus, un bloc PL/SQL comporte 3 sections (DECLARE, BEGIN et
EXCEPTIONS) parmi lesquelles seule la section BEGIN est obligatoire. Dans le cas ou les blocs
DECLARE et EXCEPTIONS sont omis, les lignes BEGIN et END sont facultatives.

P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
16
Exemple : Contrler laffichage dune LOV dans un formulaire
DECLARE rep BOOLEAN;
BEGIN
IF :participants.nj is null THEN
bell;
rep := show_lov ('LOV4');
END IF;
END;
Dans le code ci-dessus, rappelons que dans lexpression :participants.nj les deux points
":" permettent de dsigner le bloc PARTICIPANTS et non la table PARTICIPANTS.
5. Exercice 3 : gestion de laffichage automatique dune LOV
Trois solutions vous sont proposes pour afficher la LOV associe NJ. Certaines
comportent des inconvnients.
Solution 1 :
Cration dun dclencheur WHEN-MOUSE-DOUBLECLICK pour litem NJ avec le code ci-
dessous. Pour crer ce dclencheur cliquez sur le + de litem NJ afin de faire apparatre lobjet
dclencheur. Double cliquez sur cet objet puis choisissez lvnement voulu dans la fentre du
dclencheur avant dentrer le code PL/SQL. Cliquez sur le bouton compiler de la fentre du
dclencheur pour tester la syntaxe de votre code.
DECLARE rep BOOLEAN;
BEGIN
bell;
rep := show_lov ('LOV_NJ'); /* LOV_NJ est le nom de la LOV */
END;
Remarque : show_lov est une commande trs utile de PL/SQL. Il en existe bien dautres de
ce type. Il est impossible de les connatre toutes par cur. Pour les retrouver et apprendre les
utiliser, exploitez la commande daide Aide/Form builder Rubrique daide/Rfrence
PL/SQL /Packages intgrs de Form Builder/Liste alphabtique.
Testez ce dclencheur. Linconvnient de cette solution est que lutilisateur doit connatre la
convention qui consiste double cliquer sur litem pour faire apparatre la LOV.
Solution 2 :
Cration dun dclencheur PRE-TEXT-ITEM avec le code ci-dessous.
declare
recstat VARCHAR2(20) := :System.record_status;
rep boolean;
BEGIN
IF ( recstat <> 'NEW' and recstat <> 'INSERT' ) THEN
RETURN;
END IF;
rep:=show_lov('LOV_NJ');
END;
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
17
Solution 3 :
Cration dun bouton pour afficher la liste, avec un dclencheur WHEN-BUTTON-PRESSED
qui contiendra le mme code que prcdemment.
Double cliquez sur lobjet lments, puis dans la proprit type dlment de ce nouvel
lment choisissez bouton de commande. Dans la proprit libell de cet lment introduisez la
chane '\/' (back-slach, slash). Renommez cet item Liste_Joueurs. Ajoutez le dclencheur.
Modifiez le canevas pour que le bouton prenne laspect dune bote liste ct de NJ.
Attention, pour que ce bouton puisse tre utilis, il faut que son item soit plac en premier
dans la liste des items du bloc. Observez les anomalies dutilisation de ce bouton. Ces anomalies
peuvent tre vites en positionnant la proprit obligatoire de NJ faux.
6. Exercice 4 : gestion de LOV dynamiques
En fonction du contexte de lapplication, il peut tre utile quune LOV naffiche que les
donnes pertinentes dune table. Par exemple, une fois le numro de match saisi dans une ligne du
formulaire de la table participants, il serait souhaitable que la LOV permettant de saisir un numro
de joueur restreigne laffichage aux joueurs dune des quipes participant au match choisi. Ainsi, la
requte associe cette LOV doit tre modifie automatiquement, chaque appel de la LOV, afin
de prendre en compte le numro de match saisi dans llment NM courant du bloc
( :PARTICIPANTS.NM). Pour cela, nous allons utiliser la fonction
POPULATE_GROUP_WITH_QUERY dcrite ci-dessous.
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
18

POPULATE_GROUP_WITH_QUERY :
Lorsque vous utilisez cette procdure interne, l'interrogation indique devient
l'interrogation par dfaut du groupe, et s'excute chaque fois que la procdure interne
POPULATE_GROUP est appele. Si l'instruction SELECT choue, Form Builder retourne
un numro d'erreur ORACLE. Si l'interrogation russit, cette procdure interne retourne 0
(zro). Les lignes extraites remplacent les lignes du groupe d'enregistrements.
Syntaxe
FUNCTION POPULATE_GROUP_WITH_QUERY
(id_groupeenreg RecordGroup,
interrogation VARCHAR2);

FUNCTION POPULATE_GROUP_WITH_QUERY
(nom_groupeenreg VARCHAR2,
interrogation VARCHAR2);

5. Modifiez le code du dclencheur associ au bouton de la LOV LOV_NJ comme suit :
DECLARE
rep boolean;
BEGIN
/* L'exemple ci-dessous montre comment remplacer linterrogation
** dun groupe d'enregistrements lors de l'excution : */
IF (Populate_Group_With_Query
('LOV_NJ',
'SELECT NOM, PRENOM, NE, NJ
FROM JOUEURS
where ne in (select ne_recevante
from matchs
where nm = :participants.nm
union
select ne_deplacante
from matchs
where nm = :participants.nm)
order by 1 '))
<> 0 THEN
RAISE form_trigger_failure;
END IF;
rep:=show_lov('LOV_NJ');
END;
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
19
TD 5 Synchronisations entre les Blocs de donnes
(FORMS) et la Base de Donnes

Rappel : notion de Bloc bas / non bas
Un Bloc bas est destin permettre la consultation et/ou la mise jours de donnes issues
d'une table stocke dans la base de donnes ou d'une vue. Le nom de la source de donnes est une
des proprits Base de donnes du Bloc. Au niveau du client Form, le bloc se comporte comme un
tableau de lignes, les enregistrements (records), capables d'accueillir des n-uplets issues de la source
de donnes. La structure de ces n-uplets est dcrite par les lments bass du bloc, ceux dont la
proprit Elment base de donnes la valeur Oui.
1 Remplir le tableau dun Bloc avec des donnes stockes dans la Base de donnes
Au dmarrage de l'application cliente, ce tableau d'enregistrements est vide. La procdure
prdfinie "EXECUTE_QUERY" permet d'extraire les donnes de la source pour remplir le tableau
du bloc actif. Cette procdure peut tre active par l'utilisateur en utilisant l'un des moyens suivants
: la commande du menu "Interrogation/Excuter" ; le bouton "excuter interrogation" ; la touche
"F8". Elle peut aussi tre appele dans un dclencheur d'application.
Par dfaut, l'interrogation permettant d'instancier le tableau d'un bloc a la structure suivante :

SELECT ALL E1, E2,,En
INTO :E1, :E2,, :En
FROM source ;
o :E1, :E2,, :En sont les noms des Elments bass du Bloc et source est le nom de la
source de donnes (table ou vue) du Bloc.
Cette requte porte sur une seule table. Elle peut comporter une clause "WHERE" si
l'utilisateur a utilis l'un des moyens suivants : la commande du menu "Interrogation/Entrer" ; le
bouton "entrer interrogation" ou la touche "F7", avant d'excuter l'interrogation. Il est aussi possible
de spcifier une clause "WHERE" par dfaut pour un Bloc, via la proprit Base de donnes du bloc
nomme "WHERE". Cette proprit peut tre modifie par programmation dans un dclencheur en
utilisant la procdure "SET_BLOCK_PROPERTY spcifie ci-dessous :

SET_BLOCK_PROPERTY ('NOM_DU_BLOC', DEFAULT_WHERE,
'prdicat');
Il peut arriver que laction EXECUTE_QUERY retourne le message d'erreur suivant :
"Excution de l'interrogation impossible". Cela peut tre du au fait que l'un des Elments bass du
Bloc porte un nom ne correspondant pas un attribut de la source de donnes. Cela peut aussi tre
du une erreur dans la clause WHERE. Pour voir le texte de la requte qui a t envoye au serveur
base de donnes, appeler la commande du menu "Aide/Afficher erreur".
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
20
2 Modifier la Base de donnes via le tableau dun Bloc
Par dfaut, lutilisateur a le droit de modifier, insrer ou supprimer des lignes dans le tableau
correspondant un Bloc de donnes. Il est possible de restreindre les droits de mise jour dun
utilisateur, au niveau de lapplication Form, via les proprits Base de donnes Insertion autorise,
Mise jour autorise et Suppression autorise. Ces proprits peuvent tre rgles au niveau du
Bloc ou de ses Elments.
Si l'application lui en donne l'autorisation, l'utilisateur peut insrer, modifier des lignes dans le
tableau d'un bloc. La procdure prdfinie "COMMIT_FORM" permet de transfrer les donnes
modifies du tableau du bloc vers la source de donnes (dans la base de donnes). Cette procdure
peut tre active par l'utilisateur en utilisant l'un des moyens suivants : la commande du menu
"Action/Enregister" ; le bouton "Enregister" ; la touche "F10". Elle peut aussi tre appele dans un
dclencheur d'application.
Etant donn que les mises jours dans le tableau du bloc, sont effectues indpendamment de
la Base de donnes, la commande transactionnelle ROLLBACK ne peut pas fonctionner pour
annuler les mises jour effectues au travers d'une application Form. La seule solution pour
annuler les mises jour, consiste vider le tableau du Bloc puis r-excuter linterrogation du
Bloc. Form Builder propose les procdures suivantes permettant respectivement de vider tous les
Blocs, vider le Bloc actif, vider lenregistrement actif, vider lElment actif :
CLEAR_FORM (mode_commit) ;
CLEAR_BLOCK (mode_commit) ;
CLEAR_RECORD ;
CLEAR_ITEM ;
mode_commit admet plusieurs options (cf. documentation). Loption NO_VALIDATE permet
de vider le ou les blocs sans transmettre les mises jour la base de donnes.

Exercice I : Contrler laffichage des valeurs dans un bloc
Ouvrir lapplication Equipes_Joueurs comportant un bloc matre pour la table EQUIPES et un
bloc esclave pour la table JOUEURS (cf. TD prcdents).
Crer un dclencheur WHEN-NEW-FORM-INSTANCE affect au module. Ce bloc
contiendra le code suivant :

BEGIN
EXECUTE_QUERY;
/* REMARQUE
** Il aurait t possible de Simuler l'action sur la touche F8 en
** utilisant la rocdure interne : DO_KEY.
** Exemple :
** Do_Key('EXECUTE_QUERY');
*/
END;
Excuter la forme. Que se passe-t-il ?
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
21
Il se peut que le Bloc actif ne soit pas le bloc EQUIPES au moment ou l'application Form
dmarre. Le Bloc actif louverture de lapplication est le premier Bloc qui apparat dans la liste
des Blocs de donnes du module Form. Deux solutions sont possibles pour activer en premier le
Bloc EQUIPES :
a) Le mettre en premier dans llment Blocs de donnes en le faisant glisser avec la souris.
b) Ajouter dans le dclencheur WHEN-NEW-FORM-INSTANCE la commande :
Go_Block('EQUIPES');
avant la commande :
EXECUTE_QUERY;
Tester les deux solutions.
A titre dexercice, mettez un prdicat erron (ex : trurlututu) dans la proprit Clause
WHERE ou Clause ORDER BY dun Bloc, puis observez la requte SQL envoye au serveur via la
commande du menu "Aide/Afficher erreur".
Exercice II : Cration dun bloc non bas avec les boutons Valider et Annuler
Objectif : crer deux boutons valider et annuler pour les blocs imbriqus EQUIPES et
JOUEURS.
Crer un bloc appel "COMMANDES" sans utiliser les assistants. Signaler quil ne sagit pas
dun bloc bas sur la base de donnes (cf. Figure 1 ). Y ajouter deux boutons dots chacun d'un
dclencheur WHEN_BUTTON_PRESSED permettant respectivement de valider une transaction
avec ses mises jour ou dabandonner la transaction. Affecter ces boutons des libells appropris.
Utiliser la commande daide pour trouver les instructions PL/SQL que le bouton VALIDER doit
excuter. Noubliez pas dafficher ces boutons dans le canevas (ou longlet) courant.
Figure 1 : Cration dun bloc non bas
Le code que doit excuter le bouton ANNULER est le suivant :
message('abandon des mises jour');
--rollback; /* ne marche pas dans un dclencheur Form*/
--raise form_trigger_failure; /* ne marche pas dans ce cas */
Go_Block ('EQUIPES');
Clear_Block(No_validate);
Go_Block ('EQUIPES');
Execute_Query;
Remarque 1 :
La commande MESSAGE permet d'afficher un message l'utilisateur. L'inconvnient de cette
commande est le suivant : selon le contexte, le message s'affiche soit en bas de l'cran dans la barre
d'tats, soit dans une fentre spcifique avec un bouton OK. La deuxime solution est prfrable,
mais on ne peut pas l'imposer.
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
22
Une autre solution consiste donc utiliser la notion d'alerte pour envoyer des messages
l'utilisateur (cf. Exercice V infra).
Remarque 2 :
Aprs une mise jour dans le Bloc JOUEURS, le bouton Annuler gnre un message
"Voulez-vous enregistrer les mises jours". Ce message provient du fait des synchronisations
matre/dtail avec le Bloc EQUIPES. Le mme message s'affiche aprs une mise jour dans le Bloc
JOUEURS puis un changement d'quipe dans le Bloc matre. Pour viter cet inconvnient, il faut
utiliser l'instruction Clear_Form qui ne contraint pas l'application revenir dans le Bloc EQUIPES.
Par contre, cette instruction a pour effet de vider aussi les Blocs des autres onglets.

Clear_form (no_validate); /* vide le bloc */
Go_Block('EQUIPES'); /* se positionnne sur le bloc matre*/
Execute_Query;

Execercie III : Afficher des donnes calcules dans un Elment non bas
Ajouter au bloc JOUEURS un nouvel Elment non bas (i.e. avec la proprit "Elment de
base de donnes" positionne FAUX). Renommer cet Elment "CALCULE" et initialiser
correctement ses proprits Canevas et Page d'onglet. Placer cet item au bon endroit dans le
canevas et lui affecter une tiquette.
Affecter cet item un dclencheur WHEN_MOUSE_CLICK avec le code suivant :
select sum(nb_buts) into :joueurs.calcule
from participants
where nj = :joueurs.nj;
Remarque :
Si l'lment CALCULE tait bas, ce dclencheur effectuerait une mise jour dans la Base de
donnes.
Pensez ajouter des buts dans la table PARTICIPANTS pour tester votre code.
Malheureusement, avec ce dclencheur, il faut cliquer sur litem calcul pour afficher son
contenu. Pour que toutes les instances de l'Elment CALCULE se remplissent automatiquement, il
faut excuter linstruction SELECT pour chaque enregistrement du bloc JOUEURS.
Solution 1 :
La solution la plus simple consiste utiliser le dclencheur Post-Query dont la spcification
est rappele ci-dessous :
Lorsqu'une interrogation est ouverte dans le bloc, le dclencheur Post-Query est activ chaque
fois que Form Builder extrait un enregistrement d'un bloc. Il est activ une fois par enregistrement
plac dans le tableau des enregistrements du bloc.
Pour cet exemple, le dclencheur Post-Query doit tre dclar au niveau du bloc EQUIPES
avec le mme code que le dclencheur prcdent.
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
23
Solution 2 :
Du fait de la relation "Matre Dtail" entre les blocs EQUIPES et JOUEURS, le bloc
JOUEURS est rempli par un dclencheur ON-POPULATE-DETAILS associ au bloc EQUIPES,
qui est activ chaque changement dquipe. Modifier ce dclencheur comme suit pour remplir les
items calculs de JOUEURS :
--
-- Begin default relation declare section
--
DECLARE
recstat VARCHAR2(20) := :System.record_status;
startitm VARCHAR2(61) := :System.cursor_item;
rel_id Relation;
--
-- End default relation declare section
--
-- Begin default relation program section
--
BEGIN
IF ( recstat = 'NEW' or recstat = 'INSERT' ) THEN
RETURN;
END IF;
--
-- Begin JOUEURS detail program section
--
IF ( (:EQUIPES.NE is not null) ) THEN
rel_id := Find_Relation('EQUIPES.EQUIPES_JOUEURS');
Query_Master_Details(rel_id, 'JOUEURS');

/* debut ajout lment calcul */
Go_Block ('JOUEURS');
First_Record;
WHILE :System.Last_Record <> 'TRUE' LOOP
select sum(nb_buts) into :joueurs.calcule
from participants
where nj = :joueurs.nj;
Next_Record;
END LOOP;
/* fin ajout lment calcul */

END IF;
--
-- End JOUEURS detail program section
--
IF ( :System.cursor_item <> startitm ) THEN
Go_Item(startitm);
Check_Package_Failure;
END IF;
END;
-- End default relation program section
Profitez de cet exercice pour observer les autres dclencheurs associs la relation matre
dtail entre EQUIPES et JOUEURS.
Exercice IV : Slectionner dynamiquement les lments affichs dans un Bloc
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
24
Avant de faire cet exercice, assurez-vous que votre module possde un onglet permettant
dafficher les participants dun match. Si ce nest pas le cas, ouvrez le module PARTICIPANTS
cr au cours du TD concernant les LOV.
Objectif : restreindre dynamiquement laffichage dans le bloc PARTICIPANTS.
Crer un bloc non bas appel RESTRICTION comportant un Elment (Text Item) permettant
lutilisateur de saisir un n de match et deux boutons RESTREINDRE et TOUT_AFFICHER
permettant respectivement, sur un simple clic, de nafficher que les participants du match choisi par
lutilisateur ou de tout afficher.
Renommez lElment de saisie "NM".
Le code du dclencheur WHEN-BUTTON-PRESSED associ au bouton "RESTREINDRE"
est donn ci-dessous :
begin
if :restriction.nm is null then
bell;
message('Vous n''avez pas slectionn de match !');
message('Vous n''avez pas slectionn de match !');
else
SET_BLOCK_PROPERTY ('PARTICIPANTS', DEFAULT_WHERE,
'NM = '||:restriction.nm);
Go_Block ('PARTICIPANTS');
Execute_Query;
end if;
end;
Le code du dclencheur WHEN-BUTTON-PRESSED associ au bouton
"TOUT_AFFICHER" est donn ci-dessous :
begin
SET_BLOCK_PROPERTY ('PARTICIPANTS', DEFAULT_WHERE'');
Go_Block ('PARTICIPANTS');
Execute_Query;
end;
Exercice V : Utilisation d'alertes
Une alerte est un objet rattach un module, permettant d'afficher un message dans une bote
de dialogue. Ainsi, une alerte est dote de la proprit message destine recevoir le message qui
doit tre affich dans la bote de dialogue. Vous pouvez changer un message d'alerte lors de
l'excution en lanant la procdure interne SET_ALERT_PROPERTY. Cette option vous permet de
rutiliser le mme objet alerte, mais d'afficher un message diffrent chaque fois qu'il est appel.
Enfin, la fonction ci-dessous permet de d'afficher la bote de dialogue d'une alerte :
reponse := Show_Alert ('NOM_DE_L_ALERTE'); /* reponse est de type
numerique */
Crer une alerte gnrique appele ALERTE_GENERIQUE. Y associer le message 'Coucou'.
Crer un bouton permettant d'afficher ce message.
Exercice VI : Gestion dune contrainte dintgrit au niveau de lapplication
Ouvrir lapplication EQUIPES_JOUEURS.
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
25
Objectif : introduire une contrainte qui interdit linsertion de plus de 14 joueurs pour une
quipe.
Crez deux dclencheurs associs au module, le premier de type PRE-COMMIT et le second
de type POST-FORMS-COMMIT.
Leur associer le code :
Declare
V_ne number (11);
V_nbj number;
reponse number;

Begin
V_ne := :EQUIPES.NE;

select count(nj) into V_nbj
from joueurs
where ne = V_ne;

Set_Alert_Property('ALERTE_GENERIQUE',ALERT_MESSAGE_TEXT,'Prcomit :
'||V_nbj);
reponse := Show_Alert('ALERTE_GENERIQUE');
End ;
Excutez le module, insrer 2 joueurs une quipe et observez les messages :
les joueurs ne sont pas encore insrs dans la BD au moment de l'excution du "pr-
commit".
Modifiez le dclencheur POST-FORMS-COMMIT pour quil excute le code suivant :
Declare
V_ne number (11);
V_nbj number;
trop_joueurs Exception;

Begin
V_ne := :EQUIPES.NE;

select count(nj)
into V_nbj
from joueurs
where ne = V_ne;

If v_nbj > 14 Then
raise trop_joueurs;
End If;

Exception
When trop_joueurs Then
message ('plus de 14 joueurs');
bell; bell;
--ROLLBACK; /* Rappel : pas possible ici. */
Raise form_trigger_failure;
End;
Remarques :
a) Avec ce code, les joueurs insrs en trop restent affichs. Lutilisateur peut supprimer
quelques joueurs, puis tenter de revalider sa transaction.
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
26
b) Si l'on insre des joueurs dans une quipe, puis on essaie de changer dquipe pour insrer
dautres joueurs, Form force la validation de la transaction.
Le code ci-dessus est correct. En effet, si la transaction ntait pas valide chaque
changement dquipe, le comptage du nombre de joueurs pour lquipe en cours ne
serait pas suffisant.
Exercice VII : cration dune contrainte sur un item
Ouvrir lapplication PARTICIPANTS.
Objectif : introduire une contrainte qui interdit de diminuer le nombre de buts marqus par
un joueur.
Crer un dclencheur associ llment NB_BUTS de type WHEN-VALIDATE-ITEM et lui
associer le code :
Declare
old_nb_buts number;

Begin
Select nb_buts
Into old_nb_buts
From participants
Where nj = :participants.nj and nm = :participants.nm;

If :participants.nb_buts < old_nb_buts Then
message('le nombre de buts doit augmenter');
raise form_trigger_failure;
End If;
End;
Tester si la nouvelle contrainte est bien applique.
Exercice VIII : question de cours
Peut-on remplacer les deux contraintes d'application cres dans les exercices VI et VII par
des contraintes d'intgrit dclares au niveau du schma de la base de donnes ? Quels sont les
avantages et inconvnients des deux solutions ?
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
27
TD 6
Gestion spcifique des blocs matre/dtail lorsqu'il
n'y a pas de jointure directe entre les blocs.
Gestion du remplissage des blocs dtails l'aide de
dclencheurs crits en PL/SQL

I Cration dun bloc non bas affichant des donnes
On souhaite produire le formulaire de la figure 1, qui prsente chaque match avec les deux
quipes impliques et la liste des participants de chaque quipe :

Figure 1 : un formulaire non standard
Ce formulaire est constitu de 5 Blocs de donnes et de 2 Relations Matre-Dtails :
le bloc MATCHS est bas sur la table Matchs,
les blocs EQUIPE_REC et EQUIPE_DEP sont bass sur la table Equipes et sont en relation
Matre Dtails avec MATCHS avec les conditions respectives :
"Matchs.ne_recevante=Equipe_rec.ne" et "Matchs.ne_deplacante=Equipe_dep.ne".
les blocs PARTICIPANTS_REC et PARTICIPANTS_DEP sont bass sur la table Participants
et ne sont en relation avec aucun autre bloc.
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
28
Le remplissage dans des blocs PARTICIPANTS_REC et PARTICIPANTS_DEP ne peut tre
gr par une Relation Matre-Dtails car il n'y a pas de condition de jointure directe entre le bloc
MATCHS et ces 2 blocs. Il n'est pas non plus possible de crer une relation Dtails-Dtails entre les
blocs EQUIPE_REC et PARTICIPANTS_REC (resp EQUIPE_DEP et PARTICIPANTS_DEP). La
solution consiste remplir ces 2 blocs par programmation dans le dclencheur ON-POPULATE-
DETAILS du block MATCHS, en le compltant de la faon suivante :
-- Note : le code en italique correspond au code gnr par Form_Builder pour les
-- deux relations : 'MATCHS.MATCHS_EQUIPE_REC' et 'MATCHS.MATCHS_EQUIPE_DEP'
--
-- Begin EQUIPES_REC detail program section
--
IF ( (:MATCHS.NE_RECEVANTE is not null) ) THEN
rel_id := Find_Relation('MATCHS.MATCHS_EQUIPE_REC');
Query_Master_Details(rel_id, 'EQUIPE_REC');
--
-- Dbut du Code ajouter au dclencheur
--
Set_Block_Property('PARTICIPANTS_REC',DEFAULT_WHERE,
'nj in (select nj from joueurs where ne = '
||:MATCHS.NE_RECEVANTE
||') and nm = '
||:MATCHS.NM);
go_block('PARTICIPANTS_REC');
execute_query;
--
-- Fin du Code ajouter au dclencheur
--
END IF;
--
-- End EQUIPES_REC detail program section
--
--
-- Begin EQUIPES_DEP detail program section
--
IF ( (:MATCHS.NE_DEPLACANTE is not null) ) THEN
rel_id := Find_Relation('MATCHS.MATCHS_EQUIPE_DEP');
Query_Master_Details(rel_id, 'EQUIPE_DEP');
--
-- Dbut du Code ajouter au dclencheur
--
Set_Block_Property('PARTICIPANTS_DEP',DEFAULT_WHERE,
'nj in (select nj from joueurs where ne = '
||:MATCHS.NE_DEPLACANTE
||') and nm = '
||:MATCHS.NM);
go_block('PARTICIPANTS_DEP');
execute_query;
--
-- Fin du Code ajouter au dclencheur
--
END IF;
--
-- End EQUIPES_DEP detail program section
--
REMARQUES :
Cette solution est base sur l'utilisation de l'instruction EXECUTE_QUERY pour
remplir les lments des blocs PARTICIPANTS_REC et PARTICIPANTS_DEP avec les valeurs
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
29
stockes dans la base de donnes. Dans la logique de Form Builder, c'est la seule solution possible
pour remplir des blocs bass.
Une autre solution consiste dbaser les blocs PARTICIPANTS_REC et
PARTICIPANTS_DEP et remplir ces blocs par programmation en envoyant des requtes SQL
la Base de donnes. Attention, les blocs tant non-bass, les mises jours ralises par
l'utilisateur ne sont pas prises en compte automatiquement par Form. A titre d'illustration, le
code correspondant est le suivant :
--
-- Begin default relation declare section
--
DECLARE
recstat VARCHAR2(20) := :System.record_status; -- tat du record courant
startitm VARCHAR2(61) := :System.cursor_item; -- lment "actif"coutant
rel_id Relation;
--
-- Dbut des dclarations des nouvelles variables pour le remplissage des
-- blocs PARTICIPANTS_REC et PARTICIPANTS_DEP
CURSOR c_rec is
SELECT p.nj, nb_buts, carton_jaune, carton_rouge
FROM participants p, joueurs j
where p.nj=j.nj
and j.ne= :matchs.ne_recevante
and p.nm = :matchs.nm
ORDER BY p.nj ;

CURSOR c_dep is
SELECT p.nj, nb_buts, carton_jaune, carton_rouge
FROM participants p, joueurs j
where p.nj=j.nj
and j.ne= :matchs.ne_deplacante
and p.nm = :matchs.nm
ORDER BY p.nj ;
--
-- Fin des dclarations de variables ajoutes au dclencheur
--
-- End default relation declare section
--
--
-- Begin default relation program section
--
BEGIN
IF ( recstat = 'NEW' or recstat = 'INSERT' ) THEN
RETURN;
END IF;
--
-- Begin EQUIPES detail program section
--
IF ( (:MATCHS.NE_RECEVANTE is not null) ) THEN
rel_id := Find_Relation('MATCHS.MATCHS_EQUIPES');
Query_Master_Details(rel_id, 'EQUIPES');
--
-- Dbut du Code ajouter au dclencheur pour afficher PATCICIPANTS
--
Go_Block ('PARTICIPANTS_REC');
Clear_Block;
First_Record;
OPEN c_rec;
Fetch c_rec
into :participants.nj,
:participants_rec.nb_buts,
:participants_rec.carton_jaune,
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
30
:participants_rec.carton_rouge;
While c_rec%found Loop
Next_Record;
Fetch c_rec into :participants_rec.nj,
:participants_rec.nb_buts,
:participants_rec.carton_jaune,
:participants_rec.carton_rouge;
End Loop;
Close c_rec;
--
-- Fin du Code ajouter au dclencheur
--
END IF;
--
-- End EQUIPES detail program section
--
--
-- Begin EQUIPES1 detail program section
--
IF ( (:MATCHS.NE_DEPLACANTE is not null) ) THEN
rel_id := Find_Relation('MATCHS.MATCHS_EQUIPES1');
Query_Master_Details(rel_id, 'EQUIPES1');
--
-- Dbut du Code ajouter au dclencheur pour afficher PATCICIPANTS1
--
Go_Block ('PARTICIPANTS1');
Clear_Block;
First_Record;
Open c_dep;
-- message('ne = '||:matchs.ne_recevante);
-- message('nm = '||:matchs.nm);
Fetch c_dep into :participants1.nj,
:participants_dep.nb_buts,
:participants_dep.carton_jaune,
:participants_dep.carton_rouge;
While c_dep%found Loop
Next_Record;
Fetch c_dep into :participants_dep.nj,
:participants_dep.nb_buts,
:participants_dep.carton_jaune,
:participants_dep.carton_rouge;
End Loop;
Close c_dep;
--
-- Fin du Code ajouter au dvlencheur
--
END IF;
--
-- End EQUIPES1 detail program section
--

IF ( :System.cursor_item <> startitm ) THEN
Go_Item(startitm);
Check_Package_Failure;
END IF;
END;
--
-- End default relation program section
--


II Ajout d'lments calculs
P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
31
Modifier le module pour que :
1. le module prsente les noms des joueurs comme sur la figure 2,
2. on puisse inscrire de nouveaux joueurs dans chacune des 2 quipes, en utilisant une LOV sur
chaque bouton "inscrire".
On modifiera la proprit Visible des lments masquer et on ajoutera le code suivant un
dclencheur POST-QUERY attach aux 2 blocs PARTICIPANTS_DEP et PARTICIPANTS_REC
-- pour le bloc PARTICIPANTS_DEP

select nom
into :participants_dep.nomj - "nomj" prsente les noms des joueurs
from joueurs
where :participants_dep.nj=nj;


Figure 2 : formulaire permettant de saisir "intelligemment" les participants d'un match

P.-J. Charrel & J.-M. Thvenin, Universit Toulouse 1, DESS IGSI Formation Continue
32