Advanfr

Sybase®
PowerAMC
Documentation utilisateur
avancée
Version 10.0
DC20013-01-1000-01
Dernière révision : Janvier 2004
Copyright © 1991–2004 Sybase, Inc. Tous droits réservés.
Les informations contenues dans ce document pourront faire l’objet de modifications sans préavis et ne constituent aucun engagement
de la part de Sybase, Inc. et de ses filiales.
Sybase, Inc. fournit le logiciel décrit dans ce manuel sous Contrat de licence Sybase. Le logiciel ne peut être utilisé que conformément
aux termes de ce contrat.
Tout ou partie de cette publication ne peut être reproduit, transmis ou traduit, sous quelque forme ou par quelque moyen que ce soit
(électronique, mécanique, manuel, optique ou autre) sans l'accord écrit préalable de Sybase, Inc.
Sybase, SYBASE (logo), AccelaTrade, ADA Workbench, Adaptable Windowing Environment, Adaptive Component Architecture,
Adaptive Server, Adaptive Server Anywhere, Adaptive Server Enterprise, Adaptive Server Enterprise Monitor, Adaptive Server
Enterprise Replication, Adaptive Server Everywhere, Adaptive Server IQ, Adaptive Warehouse, AnswerBase, Anywhere Studio,
Application Manager, AppModeler, APT Workbench, APT-Build, APT-Edit, APT-Execute, APT-Translator, APT-Library, ASEP,
AvantGo, AvantGo Application Alerts, AvantGo Mobile Document Viewer, AvantGo Mobile Delivery, AvantGo Mobile Inspection,
AvantGo Mobile Marketing Channel, AvantGo Mobile Pharma, AvantGo Mobile Sales, AvantGo Pylon, AvantGo Pylon Application
Server, AvantGo Pylon Conduit, AvantGo Pylon PIM Server, AvantGo Pylon Pro, Backup Server, BayCam, Bit-Wise, BizTracker,
Certified PowerBuilder Developer, Certified SYBASE Professional, Certified SYBASE Professional Logo, ClearConnect, Client-
Library, Client Services, CodeBank, Column Design, ComponentPack, Connection Manager, Convoy/DM, Copernicus, CSP, Data
Pipeline, Data Workbench, DataArchitect, Database Analyzer, DataExpress, DataServer, DataWindow, DB-Library, dbQueue,
Developers Workbench, Direct Connect Anywhere, DirectConnect, Distribution Director, Dynamic Mobility Model, e-ADK, E-
Anywhere, e-Biz Integrator, E-Whatever, EC Gateway, ECMAP, ECRTP, eFulfillment Accelerator, Electronic Case Management,
Embedded SQL, EMS, Enterprise Application Studio, Enterprise Client/Server, Enterprise Connect, Enterprise Data Studio, Enterprise
Manager, Enterprise Portal (logo), Enterprise SQL Server Manager, Enterprise Work Architecture, Enterprise Work Designer,
Enterprise Work Modeler, eProcurement Accelerator, eremote, Everything Works Better When Everything Works Together, EWA,
Financial Fusion, Financial Fusion (and design), Financial Fusion Server, Formula One, Fusion Powered e-Finance, Fusion Powered
Financial Destinations, Fusion Powered STP, Gateway Manager, GeoPoint, GlobalFIX, iAnywhere, iAnywhere Solutions, ImpactNow,
Industry Warehouse Studio, InfoMaker, Information Anywhere, Information Everywhere, InformationConnect, InstaHelp, Intelligent
Self-Care, InternetBuilder, iremote, iScript, Jaguar CTS, jConnect for JDBC, KnowledgeBase, Logical Memory Manager, M-Business
Channel, M-Business Network, M-Business Server, Mail Anywhere Studio, MainframeConnect, Maintenance Express, Manage
Anywhere Studio, MAP, MDI Access Server, MDI Database Gateway, media.splash, Message Anywhere Server, MetaWorks,
MethodSet, ML Query, MobiCATS, My AvantGo, My AvantGo Media Channel, My AvantGo Mobile Marketing, MySupport, Net-
Gateway, Net-Library, New Era of Networks, Next Generation Learning, Next Generation Learning Studio, O DEVICE, OASiS,
OASiS logo, ObjectConnect, ObjectCycle, OmniConnect, OmniSQL Access Module, OmniSQL Toolkit, Open Biz, Open Business
Interchange, Open Client, Open ClientConnect, Open Client/Server, Open Client/Server Interfaces, Open Gateway, Open Server, Open
ServerConnect, Open Solutions, Optima++, Orchestration Studio, Partnerships that Work, PB-Gen, PC APT Execute, PC DB-Net, PC
Net Library, PhysicalArchitect, Pocket PowerBuilder, PocketBuilder, Power++, Power Through Knowledge, power.stop, PowerAMC,
PowerBuilder, PowerBuilder Foundation Class Library, PowerDesigner, PowerDimensions, PowerDynamo, Powering the New
Economy, PowerJ, PowerScript, PowerSite, PowerSocket, Powersoft, PowerStage, PowerStudio, PowerTips, Powersoft Portfolio,
Powersoft Professional, PowerWare Desktop, PowerWare Enterprise, ProcessAnalyst, QAnywhere, Rapport, Relational Beans,
RepConnector, Report Workbench, Report-Execute, Replication Agent, Replication Driver, Replication Server, Replication Server
Manager, Replication Toolkit, Resource Manager, RW-DisplayLib, RW-Library, SAFE, SAFE/PRO, SDF, Secure SQL Server, Secure
SQL Toolset, Security Guardian, SKILS, smart.partners, smart.parts, smart.script, SQL Advantage, SQL Anywhere, SQL Anywhere
Studio, SQL Code Checker, SQL Debug, SQL Edit, SQL Edit/TPU, SQL Everywhere, SQL Modeler, SQL Remote, SQL Server, SQL
Server Manager, SQL SMART, SQL Toolset, SQL Server/CFT, SQL Server/DBM, SQL Server SNMP SubAgent, SQL Station, SQLJ,
Stage III Engineering, Startup.Com, STEP, SupportNow, S.W.I.F.T. Message Format Libraries, Sybase Central, Sybase Client/Server
Interfaces, Sybase Development Framework, Sybase Financial Server, Sybase Gateways, Sybase Learning Connection, Sybase MPP,
Sybase SQL Desktop, Sybase SQL Lifecycle, Sybase SQL Workgroup, Sybase Synergy Program, Sybase Virtual Server Architecture,
Sybase User Workbench, SybaseWare, Syber Financial, SyberAssist, SybMD, SyBooks, System 10, System 11, System XI (logo),
SystemTools, Tabular Data Stream, The Enterprise Client/Server Company, The Extensible Software Platform, The Future Is Wide
Open, The Learning Connection, The Model For Client/Server Solutions, The Online Information Center, The Power of One, TotalFix,
TradeForce, Transact-SQL, Translation Toolkit, Turning Imagination Into Reality, UltraLite, UltraLite.NET, UNIBOM, Unilib, Uninull,
Unisep, Unistring, URK Runtime Kit for UniCode, Versacore, Viewer, VisualWriter, VQL, WarehouseArchitect, Warehouse Control
Center, Warehouse Studio, Warehouse WORKS, Watcom, Watcom SQL, Watcom SQL Server, Web Deployment Kit, Web.PB,
Web.SQL, WebSights, WebViewer, WorkGroup SQL Server, XA-Library, XA-Server and XP Server sont des marques de Sybase, Inc.
ou ses filiales.
Unicode et le logo Unicode sont des marques déposées de Unicode, Inc.
Tous les autres noms de produit, société ou marque peuvent appartenir à des tiers.
Table des matières
1 Guide de référence du SGBD ............................................1

Présentation du fichier de définition de SGBD.......................... 2
Editeur de SGBD ...................................................................... 4
Notions de base relatives aux catégories de SGBD................. 5
Feuille de propriétés de SGBD........................................... 5
Catégorie General .............................................................. 6
Catégorie Script et ODBC .................................................. 6
Catégorie Transformation profile...................................... 11
Catégorie Profile............................................................... 12
Gestion de la génération et du reverse engineering ............... 18
Mode de fonctionnement.................................................. 18
Notions de base relatives aux instructions et requêtes .... 19
Génération de script ......................................................... 21
Reverse engineering de script.......................................... 24
Génération ODBC ............................................................ 25
Reverse engineering ODBC............................................. 25
Syntaxe dans les instructions SQL................................... 36
Définition d'options physiques................................................. 47
Définition d'options physiques spécifiées par une valeur . 49
Syntaxe pour une option physique sans nom................... 51
Définition d'une valeur par défaut pour une option
physique ........................................................................... 51
Définition d'une liste de valeurs pour une option
physique ........................................................................... 52
Définition d'une option physique correspondant à un
tablespace ou à un storage .............................................. 52
Syntaxe d'option physique composite .............................. 53
Répétitions d'options ........................................................ 55
Changements d'interface utilisateur ................................. 56
Catégorie General................................................................... 57
EnableCheck .................................................................... 57
EnableIntegrity.................................................................. 57
Documentation utilisateur avancée iii

EnableMultiCheck ............................................................ 58
EnableConstname............................................................ 58
SqlSupport........................................................................ 58
UniqConstName............................................................... 59
Catégories Script ou ODBC.................................................... 60
Catégorie SQL ........................................................................ 61
Syntax .............................................................................. 61
Format.............................................................................. 63
File.................................................................................... 67
Keywords.......................................................................... 72
Catégorie Objects ................................................................... 75
Entrées communes aux différents objets......................... 75
Table ................................................................................ 79
Column ............................................................................. 87
Index............................................................................... 101
Pkey ............................................................................... 109
Key ................................................................................. 112
Reference....................................................................... 117
View................................................................................ 123
Tablespace..................................................................... 126
Storage........................................................................... 128
Database ........................................................................ 130
Domain ........................................................................... 132
Abstract Data Type......................................................... 136
Abstract Data Type Attribute .......................................... 138
User................................................................................ 140
Rule ................................................................................ 142
Procedure....................................................................... 145
Trigger ............................................................................ 149
Group ............................................................................. 153
Role ................................................................................ 155
Privilege.......................................................................... 157
Permission ..................................................................... 158
Default ............................................................................ 159
Join index ....................................................................... 161
Qualifier .......................................................................... 164
Sequence ....................................................................... 164
Synonym......................................................................... 166
DB Package ................................................................... 168
DB Package Procedure.................................................. 170
DB Package Variable ..................................................... 171
DB Package Type .......................................................... 172
DB Package Cursor ....................................................... 172
DB Package Exception .................................................. 173
DB Package Parameter ................................................. 173
DB Package Pragma...................................................... 174
iv PowerAMC
Commandes pour tous les objets ......................................... 175
MaxConstLen ................................................................. 175
EnableOption.................................................................. 175
Catégorie Data type .............................................................. 177
AmcdDataType............................................................... 177
PhysDataType ................................................................ 178
PhysDttpSize .................................................................. 178
OdbcPhysDataType ....................................................... 179
PhysOdbcDataType ....................................................... 180
PhysLogADTType .......................................................... 180
LogPhysADTType .......................................................... 180
AllowedADT.................................................................... 181
HostDataType ................................................................ 181
Variables de MPD ................................................................. 182
Variables pour la génération de base de données,
ainsi que celle des triggers et procedures...................... 182
Variables pour le reverse engineering............................ 183
Variables pour la synchronisation de base de données . 184
Variables pour la sécurité dans la base de données...... 184
Variables pour les métadonnées.................................... 185
Variables communes pour tous les objets nommés ...... 185
Variables communes pour les objets ............................. 185
Variables relatives aux SGBD, options de base de
données.......................................................................... 186
Variables pour les tables ................................................ 186
Variables pour vérifications sur les domaines et sur les
colonnes ......................................................................... 187
Variables pour les colonnes ........................................... 188
Variables pour les types de données abstraits............... 188
Variable pour les attributs de types de données
abstraites........................................................................ 189
Variable pour les domaines............................................ 189
Variables pour les règles................................................ 189
Variables pour ASE & SQL Server ................................. 190
Variables pour les séquences ........................................ 190
Variables pour les index ................................................. 190
Variables pour les join indexes (IQ) ............................... 191
Variables pour les colonnes d'index ............................... 191
Variables pour les références......................................... 191
Variables de colonnes de référence............................... 193
Variables pour les clés ................................................... 193
Variables pour les vues .................................................. 194
Variables pour les triggers.............................................. 194
Variables pour les procédures........................................ 195
Documentation utilisateur avancée v

2 Gestion des profils ........................................................ 197
Notions de base relatives au concept de profil ..................... 198
Qu'est-ce qu'un profil ? .................................................. 198
Extensions disponibles................................................... 199
Ajout d'une métaclasse dans un profil ........................... 202
Exclusion d'une métaclasse d'un modèle ...................... 205
Définition d'un stéréotype ..................................................... 206
Propriétés de stéréotype ................................................ 206
Création d'un stéréotype ................................................ 207
Utilisation d'un stéréotype comme métaclasse .............. 208
Attacher une icône à un stéréotype................................ 209
Affectation d'un outil à un stéréotype ............................. 210
Définition de noms par défaut pour des objets
stéréotypés..................................................................... 211
Définition d'un critère ............................................................ 213
Définition d'un symbole personnalisé dans un profil............. 215
Personnalisation d'un symbole....................................... 215
Définition d'un symbole personnalisé............................. 216
Définition d'attributs étendus dans un profil .......................... 218
Création d'un type d'attribut étendu................................ 218
Création d'un attribut étendu .......................................... 219
Définition d'une vérification personnalisée dans un profil ..... 221
Propriétés de vérification personnalisée ........................ 222
Définition du script d'une vérification personnalisée ...... 223
Définition du script d'une correction automatique .......... 225
Utilisation du script global............................................... 227
Dépannage d'erreurs VB................................................ 228
Exécution d'une vérification personnalisée .................... 228
Définition de templates et de fichiers générés dans un profil229
Création d'un template ................................................... 229
Création d'un fichier généré ........................................... 231
Définition d'une collection étendue dans un profil................. 234
Propriétés d'une collection étendue ............................... 234
Création d'une collection étendue .................................. 235
Définition d'une méthode dans un profil ............................... 237
Propriétés d'une méthode .............................................. 237
Création d'une méthode ................................................. 238
Définition des transformations dans un profil ....................... 241
Propriétés d'une transformation ..................................... 241
Création d'une transformation ........................................ 243
Méthodes helper de script pour les transformations ...... 245
Définition d'un gestionnaire d'événement dans un profil ...... 247
Notions de base relatives aux gestionnaires
d'événement................................................................... 247
Ajout d'un gestionnaire d'événement à une métaclasse
ou à un stéréotype.......................................................... 250
vi PowerAMC
Définition de menus dans un profil ....................................... 252
Propriétés d'un menu ..................................................... 253
Création d'un menu ........................................................ 254
Utilisation de profils : une étude de cas ................................ 256
Scénario ......................................................................... 257
Attachement d'une nouvelle définition étendue de
modèle au modèle.......................................................... 257
Création de stéréotypes d'objet...................................... 260
Définition de symboles personnalisés pour les
stéréotypes ..................................................................... 262
Création de liens entre objets et de messages entre
objets.............................................................................. 266
Création de vérifications personnalisées sur les liens
d'instance ....................................................................... 267
Génération d'une description sous forme de texte des
messages ....................................................................... 274
3 Guide de référence du langage objet............................283

Présentation du langage objet .............................................. 284
Notions de base relatives à l'éditeur de langage objet ......... 285
Propriétés d'un langage objet......................................... 286
Catégorie Settings .......................................................... 288
Catégorie Generation ..................................................... 291
Catégorie Transformation profile.................................... 300
Catégorie Profile............................................................. 300
4 Guide de référence du langage de processus .............311

Présentation du langage de processus ................................ 312
Notions de base relatives à l'éditeur de langage de
processus ............................................................................. 314
Propriétés d'un langage de processus ........................... 315
5 Guide de référence du langage XML.............................329

Présentation du langage XML............................................... 330
Notions de base relatives à l'éditeur de langage XML.......... 331
Propriétés d'un langage XML ......................................... 332
Documentation utilisateur avancée vii

6 Guide de référence des définitions étendues de
modèle ............................................................................ 341
Gestion des définitions étendues de modèle........................ 342
Création d'une définition étendue de modèle................. 343
Importation d'attributs étendus depuis les versions
antérieures ..................................................................... 348
Importation d'une définition étendue de modèle dans
un modèle....................................................................... 350
Exportation d'une définition étendue de modèle ............ 351
Utilisation des définitions étendues de modèle..................... 353
Propriétés d'une définition étendue de modèle .............. 354
Génération pour une définition étendue de modèle.............. 366
7 Guide de référence de la génération ............................ 367

Définition du langage de génération par template (GTL)...... 368
Définition des concepts utilisés dans le langage de
génération par template........................................................ 370
Définition de templates................................................... 370
Définition des variables .................................................. 372
Définition de la portée de la conversion ......................... 379
Conversion d'un raccourci.............................................. 380
Définition d'un héritage................................................... 381
Redéfinition d'un template.............................................. 381
Définition du polymorphisme .......................................... 382
Définition d'une surcharge de template.......................... 383
Définition des séquences d'échappement ..................... 383
Utilisation de macros ...................................................... 384
Définition de blocs conditionnels .................................... 406
Définition de messages d'erreur .................................... 406
Conseils et techniques de génération................................... 409
Partage de templates ..................................................... 409
Utilisation des variables d'environnement ...................... 410
Utilisation de nouvelles lignes dans la chaîne d'en-tête
et de fin........................................................................... 410
Utilisation du passage de paramètres............................ 414
8 Métamodèle public PowerAMC ..................................... 417

Qu'est-ce que le métamodèle public PowerAMC ? .............. 418
Concepts relatifs au métamodèle ......................................... 419
Noms publics.................................................................. 419
Classes........................................................................... 419
Associations et collections ............................................. 420
viii PowerAMC
Généralisations .............................................................. 421
Commentaires et notes sur les objets............................ 421
Notions de base relatives à la structure du métamodèle...... 422
Organisation générale .................................................... 422
Contenu de PdCommon................................................. 423
Contenu des autres packages de bibliothèque .............. 423
Navigation dans le métamodèle ..................................... 423
Utilisation du métamodèle avec VBS.................................... 426
Utilisation du métamodèle à l'aide du langage de
génération par template (GTL) ............................................. 428
Attributs calculés ............................................................ 429
Collections calculées...................................................... 431
Utilisation du métamodèle pour comprendre le format
de fichier XML de PowerAMC............................................... 432
9 Spécification du format de fichier PowerAMC .............433

Format de fichier XML .......................................................... 434
Structure et contenu des fichiers XML ........................... 434
Notions de base relatives aux format XML .................... 438
Etude de cas .................................................................. 438
Modification d'un fichier XML ................................................ 442
Modification d'un fichier XML à l'aide d'un éditeur
standard ......................................................................... 442
Modification d'un fichier XML à l'aide d'un éditeur XML . 444
Visualisation d'un fichier XML à l'aide d'une visionneuse
XML ................................................................................ 445
Index .........................................................................................447
Documentation utilisateur avancée ix

x PowerAMC
C H A P I T R E 1
Guide de référence du SGBD
Sujet Ce document décrit la structure et le contenu d'un fichier de définition de

SGBD PowerAMC. Ce guide constitue une référence pour travailler avec les
SGBD pris en charge par PowerAMC. Vous y trouverez une présentation
globale de l'utilisation des fichiers de définition de SGBD ne prenant pas en
compte les spécificités de chaque SGBD.
Sommaire
Section Page
Présentation du fichier de définition de SGBD 2

Editeur de SGBD 4
Notions de base relatives aux catégories de SGBD 5
Gestion de la génération et du reverse engineering 18
Définition d'options physiques 47
Catégorie General 57
Catégories Script ou ODBC 60
Catégorie SQL 61
Catégorie Objects 75
Commandes pour tous les objets 175
Catégorie Data type 177
Variables de MPD 182
Avant de Les modifications apportées à un fichier de définition de SGBD peuvent

commencer changer la façon dont se comportent les fonctions de PowerAMC, tout
particulièrement lors de la génération de scripts. Créez des copies de
sauvegarde de vos définitions de bases de données, et testez scrupuleusement
chaque script généré avant de l'exécuter.
Documentation utilisateur avancée 1

Présentation du fichier de définition de SGBD
Présentation du fichier de définition de SGBD
PowerAMC peut être utilisé avec de nombreux SGBD différents. Pour

chacun de ces SGBD, un fichier de définition standard est inclus et fournit
une interface entre PowerAMC et le SGBD afin d'établir les meilleures
relations possibles entre ces deux éléments.
Attention
Ne modifiez pas les fichiers de SGBD fournis avec PowerAMC. Pour
chaque SGBD que vous souhaitez modifier, créez un nouveau SGBD
correspondant. Pour ce faire, créez le nouveau SGBD à partir de la boîte
de dialogue Liste des SGBD, définissez un nom, puis sélectionnez le SGBD
d'origine dans la liste déroulante Copier depuis. Cette méthode permet de
créer un nouveau SGBD identique au fichier d'origine, à la différence du
nom près.
Pour plus d'informations sur la création d'une nouvelle définition de

SGBD à partir d'un SGBD existant, reportez-vous à la section Création d'un
nouveau fichier de définition dans le chapitre Utilisation de l'éditeur de
définition dans le manuel Guide des fonctionnalités générales.
En revanche, vous pouvez être amené à modifier cette interface pour l'adapter
à vos applications particulières, et ce en utilisant l'éditeur de fichier de
définition de SGBD.
Qu'est-ce qu'un Un fichier de définition de SGBD est une liste de valeurs et de paramètres
fichier de définition qui représentent des spécifications pour un SGBD (Système de Gestion de
de SGBD ? Bases de Données) dans un format compréhensible par PowerAMC. En tant
qu'interface entre un SGBD et PowerAMC, il fournit à PowerAMC la
syntaxe et les règles relatives à la génération de bases de données, triggers et
procédures correspondant au SGBD cible choisi. Le fichier de définition de
SGBD est un fichier au format .XML.
Le fichier de définition de SGBD est un composant requis de PowerAMC
lorsque vous travaillez sur des Modèles Physiques de Données (MPD).
Chaque SGBD pris en charge par PowerAMC a sa propre définition de
SGBD.
2 PowerAMC
Chapitre 1 Guide de référence du SGBD
Que contient une

définition de Tous les fichiers de définition de SGBD ont la même structure composée de
SGBD ? catégories. Une catégorie peut contenir d'autres catégories, des entrées et
des valeurs. Ces entrées sont des paramètres reconnaissables par
PowerAMC.
Les valeurs pour les catégories et entrées de définition de SGBD varient pour
chaque SGBD. Certaines entrées peuvent ne pas exister dans certains fichiers
de SGBD si elles ne sont pas applicables à ces SGBD particuliers.
Certaines entrées peuvent en outre contenir des paramètres qui sont
obligatoires pour générer une syntaxe correcte. Certaines entrées contiennent
des instructions SQL qui vont permettre à PowerAMC de générer et
d'effectuer du reverse engineering correctement pour la base de données
choisie (create, drop , etc).
Que sont les Vous pouvez incorporer des variables dans les requêtes SQL du SGBD
variables sélectionné. Ces variables sont remplacées par les valeurs appropriées de
PowerAMC ? votre modèle lorsque les scripts sont générés. Ces variables sont évaluées
pour créer les objets correspondants dans les modèles PowerAMC lors du
reverse engineering.
Les variables PowerAMC sont écrites entre signes pourcent (%).
Exemple CreateTable = create table %TABLE%
L'évaluation des variables dépend des paramètres et du contexte. Par
exemple, la variable %COLUMN% ne peut pas être utilisée dans un
paramètre CreateTablespace, car cette variable n'est reconnue que dans un
contexte de paramètre de colonne.
Pour obtenir la liste des toutes les variables PowerAMC que vous
pouvez utiliser dans une définition de SGBD, reportez-vous à la section
Variables de MPD.

Editeur de SGBD
Editeur de SGBD
Vous pouvez consulter ou modifier un fichier de définition de SGBD à l'aide
de l'éditeur de SGBD.
Pour afficher l'éditeur de SGBD :

♦ Sélectionnez SGBD→Editer le SGBD courant
ou
Sélectionnez Outils→Ressources→SGBD, puis sélectionnez un SGBD
existant, ou bien créez un nouveau fichier de définition de SGBD.
La feuille de propriétés de SGBD s'affiche.
L'éditeur de SGBD permet de naviguer parmi les catégories et entrées de
SGBD. Lorsque vous sélectionnez une catégorie dans l'éditeur de définition
de SGBD, le nom, le code et le commentaire associés s'affichent dans la
partie droite de la boîte de dialogue. Lorsque vous sélectionnez une entrée
dans la fenêtre de définition de SGBD, le nom, la valeur et le commentaire
associés s'affichent dans la partie droite de la boîte de dialogue.
Pour plus d'informations sur l'utilisation de l'éditeur de SGBD,
reportez-vous au chapitre L'éditeur de ressources dans le manuel Guide des
fonctionnalités générales.
Templates de Le SGBD contient la définition des templates de trigger et des éléments de
trigger et éléments template de trigger.
de template de
trigger Vous pouvez accéder aux pages Templates de trigger ou Eléments de
template de trigger en cliquant sur l'onglet correspondant.
Les templates pour les procédures stockées sont définis sous la catégorie
Procedure dans l'arborescence du SGBD.
Pour plus d'informations sur l'utilisation, la création et l'édition de
templates de trigger ou d'éléments de template de trigger, reportez-vous au
chapitre Triggers et procédures dans le manuel Guide de l'utilisateur du
MPD.
4 PowerAMC
Notions de base relatives aux catégories de

SGBD
Une définition de SGBD peut avoir les catégories suivantes :
Catégorie Description
General Identification du SGBD cible
Script Caractéristiques du SGBD, définition de commande et
conversions de types de données pour la génération et le
reverse engineering de script
ODBC Caractéristiques du SGBD, définition de commande et
conversions de types de données pour la génération et le
reverse engineering via ODBC
Profil de Permet de créer des profils contenant des transformations
transformations utilisées au cours de la génération de modèle ou appliquées
dans un modèle
Profile Extension des métaclasses PowerAMC pour personnaliser les
modèles
Remarquez que certains SGBD n'affichent pas de catégorie ODBC car cette
dernière n'est pas nécessaire à leur définition.
Feuille de propriétés de SGBD

Un SGBD a une feuille de propriétés disponible quand vous cliquez sur le
noeud racine dans l'arborescence. Les propriétés suivantes y sont définies :
Propriété Description
Nom Nom du SGBD. Ce nom doit être unique dans un modèle
Code Code du SGBD. Ce code doit être unique dans un modèle
Nom du Chemin d'accès et nom du fichier du SGBD. Vous ne pouvez pas
fichier modifier le contenu de cette zone
Famille Utilisé pour classifier un SGBD. L'utilisation d'une famille
permet d'établir un lien entre différents fichiers de ressources
de base de données. Par exemple, Sybase AS Anywhere et
Sybase AS Enterprise appartiennent à la famille SQL Server.
Les triggers ne sont pas effacés lorsque vous changez de base de
données cible au sein d'une même famille.
Une interface de fusion permet de fusionner des modèles de la
même famille

Notions de base relatives aux catégories de SGBD
Commentaire Informations supplémentaires relatives au SGBD
Catégorie General
La catégorie General contient des informations générales relatives à la base
de données, sans catégorie. Toutes les entrées définies dans la catégorie
General s'appliquent à tous les objets de la base de données.
Exemple Si l'entrée EnableCheck a la valeur Yes, les paramètres de contrôle sont
générés.
Catégorie Script et ODBC

La catégorie Script est utilisée pour la génération et le reverse engineering de
script, ainsi que pour le reverse engineering ODBC.
La catégorie ODBC est utilisée pour les requêtes de génération ODBC
lorsque le SGBD ne prend pas en charge les instructions standard pour la
génération. Remarquez que certains SGBD n'affichent pas de catégorie
ODBC car elle n'est pas nécessaire à leur définition.
6 PowerAMC
Lorsque la valeur d'une commande ou sa catégorie manque lors de la

génération ODBC, PowerAMC la recherche dans la catégorie Script. Une
entrée est alors redéfinie dans la catégorie ODBC uniquement si elle est
différente de la valeur située dans Script.
Les catégories Script et ODBC contiennent les catégories suivantes :
Catégories Description
SQL Contient les catégories Syntax, Format, File et Keywords.
Chaque catégorie contient des entrées dont les valeurs
définissent la syntaxe générale pour la base de données
Objects Contient des catégories pour chaque type d'objet dans la
base de données. Chaque catégorie contient des entrées
dont les valeurs définissent des commandes de base de
données et des caractéristiques objet
Data Type Contient des entrées de conversion des types de données.
Ces entrées répertorient les correspondances entre les types
de données internes PowerAMC et les types de données de
la base de données cible
Customize Extrait les informations de fichiers de définition de SGBD
de PowerAMC Version 6. Non utilisé dans les versions
ultérieures

Exemple Dans le fichier de définition de Sybase Adaptive Server Anywhere 6, la

catégorie Script est développée pour afficher la catégorie Objects dans
laquelle Index est également développée. L'entrée Create est sélectionnée
et la zone Valeur associée à cette commande définit la façon ont l'index est
créé.
Catégorie SQL
La catégorie SQL contient les catégories suivantes :
♦ Syntax contient des paramètres généraux relatifs à la syntaxe SQL
♦ Format contient des paramètres concernant les caractères admis
♦ File contient les entrées de texte header, footer et usage utilisées lors de
la génération
♦ Keywords contient la liste des mots réservés et fonctions disponibles
dans SQL
8 PowerAMC

catégorie Script est développée pour montrer la catégorie SQL dans laquelle
Syntax est également développée pour montrer les paramètres généraux de
syntaxe tels que Terminator et BlockTerminator.
L'entrée Terminator est sélectionnée et la zone Valeur associée à cette

entrée définit le symbole de fin courant.
Catégorie Objects
La catégorie Object contient toutes les commandes pour créer, supprimer ou
modifier tous les objets dans la base de données. Elle inclut également des
commandes qui définissent le comportement des objets, les valeurs par
défaut, les instructions SQL nécessaires, les options de reverse engineering,
etc.


catégorie Objects est développée pour montrer la catégorie Database.
L'entrée Create est sélectionnée et la zone Valeur associée contient la
commande relative à la création de base de données.
10 PowerAMC
Catégorie Data type

La catégorie Data Type contient une liste des types de données valides pour
le SGBD spécifié et les types correspondants dans PowerAMC.
catégorie Data Type est développée de façon à afficher tous les types de
données. L'entrée PhysDataType est sélectionnée et la valeur associée
montre la mise en correspondance décrite dans la zone Commentaire.
Catégorie Transformation profile

Un profil de transformation est un groupe de transformations utilisé au cours
d'une génération de modèle ou lorsque vous souhaitez appliquer des
modifications à certains objets dans les modèles source ou cible.
Vous définissez un profil de transformation dans la catégorie Transformation
Profiles d'une définition étendue de modèle, d'un langage objet, d'un SGBD,
ou d'un langage de processus. Chaque profil est identifié par le modèle dans
lequel le fichier de ressource est défini, par un type de modèle, une famille et
une sous famille.
Pour plus d'informations sur les transformations, reportez-vous au
chapitre Gestion des transformations, dans le Guide des Fonctionnalités
Générales.

Catégorie Profile
La catégorie Profile est utilisée pour définir les profils PowerAMC.
Dans un SGBD, vous pouvez définir les types d'attributs étendus et les
attributs étendus pour les objets de base de données.
La catégorie Profile contient les catégories suivantes :
Shared\Extended Permet de définir les types d'attributs étendus et les
attribute types templates partagés. Les types d'attributs étendus sont des
types de données réutilisés entre attributs étendus. Les
templates partagés sont des morceaux de code utilisés dans
la génération de texte
Metaclasses Permet de définir des extensions de métaclasse, par
exemple des symboles personnalisés, des stéréotypes, des
critères ou des fichiers générés
Pour plus d'informations sur les profils, reportez-vous au chapitre

Gestion de profils.
Pour plus d'informations sur les templates et les fichiers générés,
reportez-vous au chapitre Guide de référence de la génération.
Attributs étendus Pour chaque attribut étendu défini dans cette catégorie, un onglet Attributs
étendus s'affiche dans la feuille de propriétés de l'objet correspondant. Vous
pouvez utiliser cet onglet pour ajouter une valeur d'attribut étendu dans la
définition de l'objet.
Certains SGBD sont fournis avec des attributs étendus qui sont nécessaires
lors de la génération, il est donc préférable de ne pas modifier ces attributs
étendus, ou tout au moins de créer une copie de sauvegarde de chaque fichier
de SGBD avant de commencer à les modifier.
Si vous souhaitez améliorer la génération de modèle, vous pouvez suivre le
modèle des attributs étendus existants et l'affecter aux autres catégories
d'objet.
Définition étendue Si vous souhaitez compléter la définition des objets de modélisation et
d'objet développer le métamodèle PowerAMC, vous devez définir des attributs
étendus dans une définition étendue de modèle. De tels attributs étendus ne
sont pas utilisés lors du processus de génération.
Pour plus d'informations sur les définitions étendues de modèle,
reportez-vous au chapitre Guide de référence des définitions étendues de
modèle.
12 PowerAMC
La catégorie Extended Attribute est divisée en deux catégories :

♦ Types
♦ Objects
Définition d'un attribut étendu dans un SGBD

Chaque attribut étendu a les propriétés suivantes :
Propriété de
l'entrée Description
Nom Nom de la catégorie ou de l'entrée
Commentaire Description de la catégorie ou de l'entrée sélectionnée
Type de données Types d'attributs étendus prédéfinis ou définis par
l'utilisateur
Valeur par défaut Valeur par défaut de la liste des valeurs. Dépend du type de
données sélectionné
Pour ajouter un attribut étendu :

1 Pointez sur une catégorie de métaclasse dans la catégorie Profile, cliquez
le bouton droit de la souris, puis sélectionnez Nouveau→Attributs
étendus dans le menu contextuel.
Un nouvel attribut étendu est créé.
2 Saisissez un nom dans la zone Nom.
3 Saisissez un commentaire dans la zone Commentaire.
4 Sélectionnez un type de données dans la liste déroulante Type de
données.
5 <facultatif>> Sélectionnez une valeur par défaut dans la liste déroulante
Valeur par défaut.
6 Cliquez sur Appliquer.
Exemple Dans DB2 UDB 7 OS/390, l'attribut étendu WhereNotNull permet

d'ajouter une clause qui spécifie que les noms d'index doivent être uniques à
condition qu'ils ne soient pas null.

Dans la commande Create index, WhereNotNull est évalué comme

suit :
create [%INDEXTYPE% ][%UNIQUE% [%WhereNotNull%?where not
null ]]index [%QUALIFIER%]%INDEX% on
[%TABLQUALIFIER%]%TABLE% (
%CIDXLIST%
)
[%OPTIONS%]
Si le nom d'index est unique, et si vous définissez le type de l'attribut étendu
WhereNotNull comme True, la clause "where not nul" sera insérée dans le
script.
Dans la quête SqlListQuery :
{OWNER, TABLE, INDEX, INDEXTYPE, UNIQUE, INDEXKEY,
CLUSTER, WhereNotNull}
select
tbcreator,
tbname,
name,
case indextype when '2' then 'type 2' else 'type 1'
end,
case uniquerule when 'D' then '' else 'unique' end,
case uniquerule when 'P' then 'primary' when 'U' then
'unique' else '' end,
case clustering when 'Y' then 'cluster' else '' end,
case uniquerule when 'N' then 'TRUE' else 'FALSE' end
from
sysibm.sysindexes
where 1=1
[ and tbname=%.q:TABLE%]
[ and tbcreator=%.q:OWNER%]
[ and dbname=%.q:CATALOG%]
order by
1 ,2 ,3
Utilisation des attributs étendus dans le MPD

Les attributs étendus définis dans un SGBD sont utilisés pour contrôler la
génération du modèle.
Vous pouvez également définir des attributs étendus dans une définition
étendue de modèle, afin d'enrichir la définition d'un objet. Ces attributs
étendus ne sont pas utilisés lors de la génération.
reportez-vous au chapitre Guide de référence des définitions étendues de
modèle.
14 PowerAMC
Par défaut, les attributs étendus s'affichent sur un onglet distinct dans la page
Attributs étendus d'une feuille de propriétés d'objet ou dans des listes
d'objets.
Chaque attribut étendu a les propriétés suivantes :
Nom Nom de l'attribut étendu
Type de données Type de données de l'attribut étendu (boolean, color, date,
file, float, font, etc.) ou type de données personnalisé
Valeur Valeur de l'attribut étendu. Cette zone affiche la valeur par
défaut définie pour le type de données d'attribut étendu
R Valeur redéfinie. Cette case est cochée si vous modifiez la
valeur par défaut dans la colonne Valeur, soit en ouvrant la
liste déroulante, soit en cliquant sur le bouton Points de
suspension
Le nom et le type de données des attributs étendus ne peuvent pas être

modifiés à partir de la feuille de propriétés de l'objet. Ces propriétés doivent
être éditées à partir de l'éditeur de SGBD. Toutefois, la valeur d'attribut
étendu peut être modifiée dans la page Attributs étendus ou dans une liste.
Pour définir la valeur d'un attribut étendu :

1 Affichez la feuille de propriétés d'un objet.
ou
Sélectionnez Modèle→Objets pour afficher une liste d'objets.
2 Cliquez sur l'onglet Attributs étendus pour afficher la page
correspondante.
ou
Cliquez sur l'outil Personnaliser les colonnes et filtrer, sélectionnez
Attributs étendus dans la liste des colonnes, puis cliquez sur OK.
Les attributs étendus s'affichent dans des pages munies d'onglets ou sous
la forme de colonnes supplémentaires dans la liste.
3 Cliquez sur la colonne Valeur d'un attribut étendu si vous souhaitez
modifier sa valeur et sélectionnez une valeur dans la liste déroulante.
ou
Saisissez ou sélectionnez une valeur dans la cellule appropriée de la
liste.
Le bouton Points de suspension permet de mieux définir la valeur de
l'attribut étendu sélectionné.

4 Cliquez sur OK.
Utilisation d'attributs étendus lors de la génération

Les attributs étendus sont créés pour contrôler la génération : chaque valeur
d'attribut étendu peut être utilisée sous forme de variable qui peut être
référencée dans les scripts définis dans la catégorie Script.
Certains SGBD incluent des attributs étendus prédéfinis. Par exemple, dans
PostgreSQL, les domaines incluent les attributs étendus par défaut utilisés
pour la création de types de données utilisateur.
Vous pouvez créer autant d'attributs étendus que vous le souhaitez, pour
chaque objet pris en charge par le SGBD.
PowerAMC prend en compte la casse des caractères

Les noms des variables PowerAMC tiennent compte de la casse des
caractères. Le nom d'une variable doit correspondre à la casse près au nom
d'attribut étendu.
16 PowerAMC
Exemple Dans DB2 UDB 7, l'attribut étendu WhereNotNull permet d'ajouter une
clause qui spécifie que les noms d'index doivent être uniques à condition
qu'ils ne soient pas null.
Dans la commande Create index, WhereNotNull est évalué comme
suit :
create [%INDEXTYPE% ][%UNIQUE% [%WhereNotNull%?where not
null ]]index [%QUALIFIER%]%INDEX% on
[%TABLQUALIFIER%]%TABLE% (
%CIDXLIST%
)
[%OPTIONS%]
Si le nom d'index est unique, et si vous avez défini le type de l'attribut étendu
WhereNotNull comme True, la clause "where not nul" sera insérée dans le
script.
Dans l'entrée SqlListQuery :
{{OWNER, TABLE, INDEX, INDEXTYPE, UNIQUE, INDEXKEY,
CLUSTER, WhereNotNull}
select
tbcreator,
tbname,
name,
case indextype when '2' then 'type 2' else 'type 1'
end,
case uniquerule when 'D' then '' else 'unique' end,
case uniquerule when 'P' then 'primary' when 'U' then
'unique' else '' end,
case clustering when 'Y' then 'cluster' else '' end,
case uniquerule when 'N' then 'TRUE' else 'FALSE' end
from
sysibm.sysindexes
where 1=1
[ and tbname=%.q:TABLE%]
[ and tbcreator=%.q:OWNER%]
[ and dbname=%.q:CATALOG%]
order by
1 ,2 ,3

Gestion de la génération et du reverse engineering
Gestion de la génération et du reverse

engineering
PowerAMC utilise le fichier de définition de SGBD pour communiquer avec
la base de données via reverse engineering et génération. PowerAMC prend
en charge à la fois l'utilisation de script et d'ODBC pour le reverse
engineering et la génération. Dans cette section, vous allez en apprendre plus
sur le reverse engineering et la génération.
Mode de fonctionnement
Cette section décrit les mécanismes de génération et de reverse engineering.
Terminologie Le mot instruction est utilisé pour définir un fragment de syntaxe SQL ; les
instructions contiennent le plus souvent des variables qui seront évaluées lors
de la génération et du reverse engineering de script.
Le mot requête est réservé pour le reverse engineering ODBC.
Génération Lors de la génération, les instructions sont analysées et les variables
contenues dans les instructions sont évaluées et remplacées par leur valeur
prise dans le modèle courant. Les mêmes instructions sont utilisées pour la
génération de script et la génération ODBC.
Reverse Lors du reverse engineering de script, PowerAMC analyse le script et
engineering identifie les différentes instructions grâce au caractère de fin (terminator)
(défini dans Script\Sql\Syntax). Chaque instruction individuelle est
"associée" à une instruction existante dans le fichier de définition de SGBD
afin de valider en tant qu'éléments dans un modèle PowerAMC, les variables
contenues dans les instructions récupérées via reverse engineering.
Lors du reverse engineering ODBC, des requêtes spéciales sont utilisées
pour extraire les informations de tables système de la base de données.
Chaque colonne d'un jeu de résultats de requête est associée à une variable.
L'en-tête de la requête spécifie l'association entre les colonnes du jeu de
résultats et la variable. Les valeurs des enregistrements renvoyés sont
stockées dans ces variables qui sont alors validées en tant qu'attributs d'objet.
Pour plus d'informations sur les variables, reportez-vous à la section
Chaînes et variables facultatives.
18 PowerAMC
Notions de base relatives aux instructions et requêtes

Les instructions relatives à la génération de script, au reverse engineering de
script ainsi qu'à la génération ODBC sont identiques, tandis que le reverse
engineering ODBC requiert des requêtes spécifiques.
Location La catégorie Script contient La catégorie ODBC contient
Instructions pour la génération de script Instructions de génération ODBC
Instructions pour le reverse engineering lorsque le SGBD ne prend pas en
de script charge les instructions standard
Requêtes de reverse engineering ODBC
Exploration de la catégorie Script

La catégorie Script ne contient que les entrées suivantes :
♦ Instructions de génération et de reverse engineering par script
♦ Instructions de modifications
♦ Eléments de définition de base de données
♦ Requêtes de reverse engineering ODBC
Instructions de La catégorie Script contient des instructions DDL (Database Description

génération et de Language) utilisées pour la génération de script et la génération ODBC ainsi
reverse que pour le reverse engineering de script.
engineering
Par exemple, l'instruction standard pour créer un index est la suivante :
create index %INDEX%
Toutefois, les valeurs d'instructions varient d'un fichier de définition à l'autre
en ce qui concerne la syntaxe de SGBD et les fonctionnalités spécifiques. Par
exemple, dans Oracle 9i, l'instruction de création pour un index contient la
définition du propriétaire de l'index car Oracle 9i prend en charge les
propriétaires d'index:
create [%UNIQUE%?%UNIQUE% :[%INDEXTYPE% ]]index
[%QUALIFIER%]%INDEX% on [%CLUSTER%?cluster
C_%TABLE%:[%TABLQUALIFIER%]%TABLE% (
%CIDXLIST%
)]
[%OPTIONS%]
Les autres instructions incluent notamment :
♦ Drop pour supprimer un objet
♦ Options pour définir les options physiques d'un objet

♦ ConstName pour définir le template de nom de contrainte pour les

vérifications d'un objet
etc...
Instructions Modify Ces instructions sont utilisées lors d'une modification de base de données,
afin de modifier les attributs d'objets existants. Elles peuvent être aisément
identifiées car la plupart d'entre elles commencent par le mot "Modify". Par
exemple ModifyColumn est l'instruction utilisée pour modifier une colonne.
Toutefois, toutes ces instructions ne commencent pas forcément par Modify,
par exemple Rename ou AlterTableFooter.
Les instructions de création d'une clé peuvent également être particulières en
fonction de l'endroit où la clé est définie : si elle se trouve dans la table, elle
sera créée à l'aide d'une commande de génération. Si elle est créée hors de la
table, elle sera créée à l'aide d'une commande de modification portant sur la
table.
Eléments de La catégorie Script contient également des éléments associés à la définition
définition de base de base de données. Il ne s'agit pas d'instructions et elles ne sont pas utilisées
de données lors de la génération ou du reverse engineering, mais plutôt dans le cas d'une
personnalisation de l'interface et du comportement de PowerAMC en
fonction des fonctionnalités de base de données.
Par exemple, l'élément Maxlen dans la catégorie table doit être défini
conformément à une longueur maximale de code tolérée pour une table dans
la base de données courante.
Permission, EnableOwner, AllowedADT sont d'autres exemples d'éléments
définis pour adapter PowerAMC au SGBD courant.
Requêtes de La plupart des requêtes de reverse engineering ODBC commencent par
reverse "Sql", ce qui permet de les identifier facilement. Par exemple, SqlListQuery
engineering ODBC est la requête utilisée pour extraire une liste d'objets, ou SqlOptsQuery est la
requête utilisée pour procéder au reverse engineering d'options physiques.
Pour plus d'informations sur les requêtes de reverse engineering ODBC,
reportez-vous à la section Reverse engineering ODBC.
Exploration de la catégorie ODBC

La catégorie ODBC contient des entrées pour la génération ODBC lorsque le
SGBD ne prend pas en charge les instructions de génération définies dans la
catégorie Script.
20 PowerAMC
Par exemple, l'échange de données entre PowerAMC et MSACCESS

fonctionne à l'aide de scripts VB et non de SQL, c'est pourquoi ces
instructions sont situées dans la catégorie ODBC. Vous devez utiliser un
programme spécial (access.mdb) pour convertir ces scripts en objets de base
de données MSACCESS.
Génération de script
Les instructions de génération de script sont disponibles dans la catégorie
Script, sous les différentes catégories d'objet.
Par exemple, dans Sybase ASA 8, l'instruction Create de la catégorie Table
se présente comme suit :
create table [%QUALIFIER%]%TABLE%
(
%TABLDEFN%
)
[%OPTIONS%]
Cette instruction contient les paramètres de création de la table ainsi que le
nom de son propriétaire et ses options physiques.
Mécanisme Vous pouvez étendre des instructions de génération de script pour compléter
d'extension la génération. Le mécanisme d'extension permet de générer les instructions
immédiatement avant ou après les instructions Create, Drop et Modify, et
d'extraire ces instructions lors du reverse engineering.
Pour plus d'informations sur le reverse engineering d'instructions
supplémentaires, reportez-vous à la section Reverse engineering de script.
Vous utilisez des instructions before ou after pour générer du code
supplémentaire ; il s'agit d'éléments de texte définis dans une catégorie
d'objet sélectionnée dans le SGBD. Dans cette section, nous les appellerons
instructions d'extension.
Langage de Les instructions d'extension sont définies à l'aide du mécanisme de langage
génération par de génération par template (GTL) PowerAMC.
template (GTL)
Une instruction d'extension peut contenir :
♦ Une référence à d'autres instructions qui sera évaluée lors de la
génération. Ces entrées sont des éléments de texte qui doivent être
définis dans la même catégorie que les objet des instructions d'extension
♦ Des variables utilisées pour évaluer des propriétés d'objet et des
attributs étendus. Les variables sont encadrées par des caractères %
♦ Des macros fournissant des structures de programmation générique pour
tester des variables (.if)

Pour plus d'informations sur le langage de génération par template

(GTL) PowerAMC, reportez-vous au chapitre Guide de référence de la
génération.
Lors de la génération, les instructions et variables sont évaluées et le résultat
est ajouté au script global.
Exemple 1 L'instruction d'extension AfterCreate est définie dans la catégorie Table
pour compléter l'instruction Create de la table, en ajoutant des partitions à la
table si la valeur de l'attribut étendu de la table le requiert.
AfterCreate est défini dans la syntaxe de GTL comme suit :
.if (%ExtTablePartition% > 1)
%CreatePartition%
go
.endif
La macro .if est utilisée pour évaluer la variable %ExtTablePartitions%.
Cette variable est un attribut étendu qui contient le nombre de partitions de la
table. Si la valeur de %ExtTablePartitions% est supérieure à 1,
%CreatePartition% sera généré suivi de "go". %CreatePartition% est une
instruction définie dans la catégorie Table comme suit :
alter table [%QUALIFIER%]%TABLE%
partition %ExtTablePartition%
%CreatePartition% génère l'instruction de création du nombre de partitions
de table spécifié dans %ExtTablePartitions%.
Exemple 2 Vous créez dans Sybase ASE une instruction étendue pour créer
automatiquement un login d'utilisateur avant l'exécution de l'instruction
Create user. L'instruction BeforeCreate se présente comme suit :
sp_addlogin %Name% %Password%
go
22 PowerAMC
Le login généré automatiquement aura le même nom que l'utilisateur et son

mot de passe. Vous pouvez afficher un aperçu de l'instruction dans la feuille
de propriétés de l'objet, l'instruction BeforeCreate apparaît avant l'instruction
de création de l'utilisateur :
Instructions Modify Vous pouvez également ajouter des instructions BeforeModify et

AfterModify aux instructions modify standard.
Les instructions Modify sont exécutées afin de synchroniser la base de
données avec la structure créée dans le MPD. Par défaut, la fonctionnalité de
modification de base de données ne prend pas en compte les attributs étendus
lorsqu'elle compare les changements effectués sur le modèle depuis la
dernière génération. Vous pouvez contourner cette règle en ajoutant des
attributs étendus dans l'élément de liste ModifiableAttributes. Les attributs
étendus définis dans cette liste seront pris en compte dans la boîte de
dialogue de fusion lors de la synchronisation de base de données.
Pour détecter qu'une valeur d'attribut étendu a été modifiée, vous pouvez
utiliser les variables suivantes :
♦ %OLDOBJECT% pour accéder à l'ancienne valeur de l'objet
♦ %NEWOBJECT% pour accéder à la nouvelle valeur de l'objet
Par exemple, vous pouvez vérifier que la valeur de l'attribut étendu
ExtTablePartition a été modifiée à l'aide de la syntaxe de GTL suivante :
.if (%OLDOBJECT.ExtTablePartition% != %NEWOBJECT.ExtTablePartition%)

Si la valeur d'attribut étendu a été modifiée, une instruction étendue sera

générée pour mettre à jour la base de données. Dans la syntaxe de Sybase
ASE, l'instruction étendue ModifyPartition se présente comme suit car en cas
de changement de partition vous devez supprimer la précédente partition
avant de la recréer :
.if (%OLDOBJECT.ExtTablePartition% != %NEWOBJECT.ExtTablePartition%)
.if (%NEWOBJECT.ExtTablePartition% > 1)
.if (%OLDOBJECT.ExtTablePartition% > 1)
%DropPartition%
.endif
%CreatePartition%
.else
%DropPartition%
.endif
.endif
Pour plus d'informations sur le langage de génération par template

(GTL) PowerAMC, reportez-vous au chapitre Guide de référence de la
génération.
Reverse engineering de script

Les mêmes instructions sont utilisées pour la génération et le reverse
engineering.
Si vous utilisez le mécanisme d'extension pour la génération de script, vous
devez déclarer les instructions dans l'élément de liste ReversedStatements
afin qu'elles puissent être correctement traitées par le reverse engineering.
Saisissez une instruction par ligne dans la liste ReversedStatement.
24 PowerAMC
Par exemple, l'instruction d'extension AfterCreate utilise l'instruction

CreatePartition. Cette entrée de texte doit être déclarée dans
ReversedStatements pour être correctement traitée par le reverse engineering.
Vous pouvez déclarer d'autres instructions de la façon suivante :
Génération ODBC
Le plus souvent, la génération pour ODBC utilise les mêmes instructions que
la génération de script. Toutefois, lorsque le SGBD ne prend pas en charge la
syntaxe SQL standard, des instructions de génération spéciales sont définies
dans la catégorie ODBC. C'est notamment le cas pour MSACCESS qui a
besoin de scripts VB pour créer des objets de base de données à l'aide de la
génération ODBC.
Ces instructions sont définies dans la catégorie ODBC du SGBD.
Reverse engineering ODBC

Le SGBD contient des requêtes de reverse engineering ODBC permettant
d'extraire des objets (tables, colonnes, etc.) de la base de données.

La plupart des requêtes sont nommées sur le modèle "Sql...Query".
Entrée Description
SqlListQuery Dresse la liste des objets pouvant être sélectionnés dans
la zone Sélection. SqlListQuery extrait les objets et
remplit la fenêtre de reverse engineering. Par la suite,
chacune des autres requêtes ci-dessous est exécutée pour
chaque objet sélectionné.
Si SqlListQuery n'est pas défini, des fonctions
ODBC standard sont utilisées pour extraire les objets.
SqlAttrQuery, SqlOptsQuery etc. seront ensuite
exécutées, si elles ont été définies.
SqlListQuery doit extraire le plus petit nombre de
colonnes possible car le processus fait une utilisation
intensive de la mémoire
SqlAttrQuery Procède au reverse engineering d'attributs d'objets
SqlAttrQuery peut ne pas être nécessaire si
SqlListQuery peut extraire toutes les informations
nécessaires. Par exemple, dans Sybase Adaptive Server
Anywhere 6, TablespaceListQuery suffit pour
extraire toutes les informations requises pour l'utilisation
dans un MPD
SqlOptsQuery Procède au reverse engineering des options physiques
SqlListChildrenQuery Procède au reverse engineering des objets enfant, par
exemple des colonnes d'un index ou d'une clé
particulière, des jointures d'une référence spécifique
SqlSysIndexQuery Procède au reverse engineering des index système créés
par la base de données
SqlChckQuery Procède au reverse engineering des contraintes relatives
aux vérifications d'objet
SqlPermQuery Procède au reverse engineering de permissions sur les
objets
Vous pouvez définir des requêtes ODBC supplémentaires pour récupérer

plusieurs attributs lors du reverse engineering, ce afin d'éviter de charger
SqlListQuery avec des requêtes pour extraire des attributs non pris en
charge par SqlAttrQuery, ou des objets non sélectionnés pour le reverse
engineering. Ces requêtes supplémentaires doivent être répertoriées dans
l'entrée ReversedQueries. Par exemple, SqlColnListQuery est utilisé pour
extraire exclusivement des colonnes de vues. Cette requête doit être déclarée
dans l'entrée ReversedQueries pour être prise en compte lors du reverse
engineering.
26 PowerAMC
Remarque : les requêtes étendues ne doivent pas être définies dans l'entrée
ReversedQueries. Pour plus d'informations sur ReversedQueries, reportez-
vous à la section Mécanisme d'extension pour les requêtes de reverse
engineering ODBC.
Structure de requête
Chaque colonne d'un jeu de résultats est associée à une variable. Un en-tête
de script spécifie l'association entre les colonnes du jeu de résultats et la
variable. Les valeurs des enregistrements renvoyés sont stockées dans ces
variables, qui sont alors validées comme valeurs d'attribut d'objet.
L'en-tête de script est contenu entre accolades { }. Ces variables sont
répertoriées entre crochets, et sont séparées les unes des autres par une
virgule. Il existe une colonne pour chaque variable dans l'instruction Select
qui suit l'en-tête.
Par exemple :
{OWNER, @OBJTCODE, SCRIPT, @OBJTLABL}
SELECT U.USER_NAME, P.PROC_NAME, P.PROC_DEFN, P.REMARKS
FROM SYSUSERPERMS U,SYSPROCEDURE P
WHERE [%SCHEMA% ? U.USER_NAME='%SCHEMA%' AND]
P.CREATOR=U.USER_ID
ORDER BY U.USER_NAME
La liste des variables possibles correspond à la liste des variables établie dans
le chapitre Variables dans PowerAMC du Guide de l'utilisateur du MPD.

Chaque partie de l'en-tête (séparée par des virgules) est associée aux
informations suivantes :
♦ Nom de la variable (obligatoire). Voir l'exemple dans Traitement avec
des noms de variable
♦ Le mot clé ID suit chaque nom de variable. ID signifie que la variable
fait partie de l'identifiant
♦ Le mot clé … (points de suspension) signifie que la variable doit être
concaténée pour toutes les lignes renvoyées par la requête SQL et ayant
les mêmes valeurs pour les colonnes d'ID
♦ Retrieved_value = PD.value répertorie l'association entre une
valeur extraite et une valeur PowerAMC. Une table de conversion
permet de convertir chaque valeur de l'enregistrement (table système) en
une autre valeur (dans PowerAMC). Ce mécanisme est un mécanisme
alternatif. Voir l'exemple dans Traitement avec une table de conversion
La seule information obligatoire est le nom de variable. Toutes les autres
informations sont facultatives. Les mots clés ID et … (points de suspension)
sont mutuellement exclusifs.
Traitement avec {TABLE ID, ISPKEY ID, CONSTNAME ID, COLUMNS ...}
des noms de select
t.table_name,
variable 1,
null,
c.column_name + ', ',
c.column_id
from
systable t,
syscolumn c
where
etc..
Dans ce script, l'identifiant est défini comme TABLE + ISKEY+
CONSTNAME.
Dans les lignes de résultat renvoyées par le script SQL, les valeurs du
quatrième champ sont concaténées dans le champ COLUMNS tant que ces
valeurs d'ID sont identiques.
SQL Result set
Table1,1,null,’col1,’
In PowerDesigner memory
Table1,1,null,’col1,col2,col3’
Table2,1,null,’col4’
28 PowerAMC
Dans l'exemple, COLUMNS va contenir la liste des colonnes séparées par

des virgules. PowerAMC va traiter le contenu du champ COLUMNS pour
supprimer la dernière virgule.
Traitement avec La syntaxe insérée immédiatement derrière un champ dans l'en-tête est la
une table de suivante :
conversion (SQL value1 = PowerDesigner value1, SQL value2 =
PowerDesigner value2, * = PowerDesigner value3)
dans laquelle * représente toutes les autres valeurs.
Par exemple :
{ADT, OWNER, TYPE(25=JAVA , 26=JAVA)}
SELECT t.type_name, u.user_name, t.domain_id
FROM sysusertype t, sysuserperms u
WHERE [u.user_name = '%SCHEMA%' AND]
(domain_id = 25 OR domain_id = 26) AND
t.creator = u.user_id
Dans cet exemple, lorsque la requête SQL renvoie la valeur 25 ou 26, elle est
remplacée par JAVA dans la variable TYPE.
Mécanisme d'extension pour les requêtes de reverse engineering ODBC

Lors du reverse engineering, PowerAMC exécute des requêtes permettant
d'extraire des informations des colonnes des tables système. Le résultat d'une
requête est mis en correspondance avec les variables internes PowerAMC via
l'en-tête de la requête. Lorsque les tables système d'un SGBD stockent des
informations dans des colonnes avec LONG, BLOB, TEXT et d'autres types
de données incompatibles, il est impossible de concaténer ces informations
dans une chaîne.
Vous pouvez contourner cette limitation en créant des requêtes définies par
l'utilisateur et des variables définies par l'utilisateur dans les requêtes de
reverse engineering existantes. Ces requêtes sont également appelées
requêtes étendues.
Lors du reverse engineering, les requêtes sont exécutées pour évaluer les
variables et créer une instruction de chaîne. Lorsque l'en-tête de requête
contient le mot clé EX, cela signifie que le résultat de la requête contient des
requêtes et variables définies par l'utilisateur.
Par exemple :
select '%UserDefinedQueryName.UserDefinedVariableName%'
|| i.indexname
from…
Ces variables définies par l'utilisateur seront évaluées par des requêtes
séparées définies par l'utilisateur.

Les graphiques suivants illustrent le processus d'évaluation de variable lors

du reverse engineering :
ReversedQueries
Les requêtes étendues ne doivent pas être définies dans l'entrée
ReversedQueries.
Etape 1 Une requête est exécutée pour évaluer les variables dans un jeu d'instructions
de chaîne.
Si les variables contiennent des requêtes et variables définies par l'utilisateur,

la requête définie par l'utilisateur est exécutée pour évaluer les variables
définies par l'utilisateur. Ces variables définies par l'utilisateur sont créées
pour être remplies de données provenant des colonnes de type de données
LONG/BLOB/TEXT….
Vous pouvez créer des requêtes définies par l'utilisateur dans une requête de
reverse engineering ODBC. Assurez-vous d'utiliser le même nom de variable
dans ces requêtes et dans les requêtes définies par l'utilisateur. Dans le cas
contraire, les variables ne seront pas évaluées.
30 PowerAMC
Vous devez également vérifier l'unicité des noms de variable si vous

souhaitez que toutes les variables soient évaluées lors de l'exécution de la
requête.
L'en-tête d'une requête utilisateur contient des noms de variable internes qui
ne seront pas évaluées. En revanche, les règles de conversion pour les valeurs
exprimées entre crochets (like (0="", *=",")) peuvent être utilisées lors de la
concaténation de chaîne.
Etape 2 L'exécution de la requête définie par l'utilisateur doit générer un jeu de
résultats numérotés contenant autant de paires de variable définie par
l'utilisateur (sans %) et de valeur de variable que nécessaire, s'il existe des
variables à évaluer.
Par exemple, dans le jeu de résultats suivant, la requête a renvoyé trois lignes
et 4 colonnes par ligne :
Variable 1 1 Variable 2 2
Etape 3 Les noms des variables définies par l'utilisateur sont remplacés par leurs
valeurs.
Les sections suivantes expliquent les requêtes utilisateur définies pour
remédier aux limitations du reverse engineering.
Reverse engineering ODBC d'options physiques

Lors du reverse engineering, les options physiques sont concaténées dans une
seule instruction de chaîne. Toutefois, lorsque les tables système d'une base
de données sont partitionnées (comme dans Oracle) ou fragmentées (comme
dans Informix), les partitions/fragments partagent les mêmes attributs
logiques, mais leurs propriétés physiques telles que les spécifications de
stockage sont conservées dans chaque partition/fragment de la base de
données. Les colonnes dans les partitions/fragments ont un type de données
(LONG) qui permet le stockage de grandes quantités d'informations binaires
non structurées.
Les options physiques dans ces colonnes ne pouvant pas être concaténées
dans une instruction de chaîne lors du reverse engineering, SqlOptsQuery
(catégorie Tables dans le SGBD) contient un appel à une requête définie par
l'utilisateur qui va évaluer ces options physiques.

Dans Informix SQL 9, SqlOptsQuery est fourni par défaut avec les
requêtes et variables utilisateur suivantes (le code suivant est un sous-
ensemble de SqlOptsQuery) :
select
t.owner,
t.tabname,
'%SqlFragQuery.FragSprt'||f.evalpos||'%
%FragExpr'||f.evalpos||'% in %FragDbsp'||f.evalpos||'%
',
f.evalpos
from
informix.systables t,
informix.sysfragments f
where
t.partnum = 0
and t.tabid=f.tabid
[ and t.owner = '%SCHEMA%']
[ and t.tabname='%TABLE%']
A l'issue de l'exécution de SqlOptsQuery, la requête définie par
l'utilisateur SqlFragQuery est exécutée pour évaluer FragDbsp n,
FragExpr n, et FragSprt n. n représente evalpos qui définit la
position du fragment dans la liste de fragmentation. n permet d'affecter des
noms uniques aux variables, quel que soit le nombre de fragments définis
dans la table.
FragDbsp n, FragExpr n, et FragSprt n sont des variables utilisateur
qui seront évaluées pour récupérer des informations concernant les options
physiques des fragments dans la base de données :
Variable utilisateur Options physiques

FragDbsp n Emplacement du fragment pour le fragment n
FragExpr n Expression du fragment pour le fragment n
FragSprt n Séparateur du fragment pour le fragment n
32 PowerAMC
SqlFragQuery est défini comme suit :

{A, a(E="expression", R="round robin", H="hash"), B, b,
C, c, D, d(0="", *=",")}
select
'FragDbsp'||f.evalpos, f.dbspace,
'FragExpr'||f.evalpos, f.exprtext,
'FragSprt'||f.evalpos, f.evalpos
from
informix.systables t,
informix.sysfragments f
where
t.partnum = 0
and f.fragtype='T'
and t.tabid=f.tabid
[ and t.owner = '%SCHEMA%']
[ and t.tabname='%TABLE%']
L'en-tête de SqlFragQuery contient les noms de variable suivants.
{A, a(E="expression", R="round robin", H="hash"), B, b,
C, c, D, d(0="", *=",")}
Seules les règles de conversion définies entre crochets seront utilisées lors de
la concaténation de chaîne : "FragSprt0", qui contient 0 (f.evalpos), sera
remplacé par " ", et "FragSprt1", qui contient 1, sera remplacé par ","
SqlFragQuery génère un jeu de résultats numérotés contenant autant de
paires de nom de variable utilisateur (sans %) et de valeurs de variable que
nécessaire, s'il existe de nombreuses variables à évaluer.
Les noms de variable définies par l'utilisateur sont remplacés par leur valeur
dans l'instruction de chaîne pour les options physiques des fragments dans la
base de données.
Reverse engineering ODBC d'index basés sur une fonction

Dans Oracle 8i et versions ultérieures, vous pouvez créer des index basés sur
des fonctions et des expressions qui impliquent une ou plusieurs colonnes
dans la table en cours d'indexation. Un index basé sur une fonction précalcule
la valeur de la fonction ou de l'expression et la stocke dans l'index. La
fonction ou l'expression va remplacer la colonne d'index dans la définition de
l'index.
Une colonne d'index avec une expression est stockée dans les tables système
ayant un type de données LONG qui ne peut pas être concaténé dans une
instruction de chaîne lors du reverse engineering.

Pour contourner cette limitation, SqlListQuery (catégorie Index dans le

SGBD) contient un appel vers la requête définie par l'utilisateur
SqlExpression utilisée pour récupérer l'expression d'index dans une
colonne ayant le type de données LONG et pour concaténer cette valeur dans
une instruction de chaîne (le code suivant est un sous-ensemble de
SqlListQuery) :
select
'%SCHEMA%',
i.table_name,
i.index_name,
decode(i.index_type, 'BITMAP', 'bitmap', ''),
decode(substr(c.column_name, 1, 6), 'SYS_NC',
'%SqlExpression.Xpr'||i.table_name||i.index_name||c.colu
mn_position||'%', c.column_name)||' '||c.descend||', ',
c.column_position
from
user_indexes i,
user_ind_columns c
where
c.table_name=i.table_name
and c.index_name=i.index_name
[ and i.table_owner='%SCHEMA%']
[ and i.table_name='%TABLE%']
[ and i.index_name='%INDEX%']
L'exécution de SqlListQuery appelle l'exécution de la requête définie par
l'utilisateur SqlExpression.
SqlExpression est suivi d'une variable définie par l'utilisateur comme
suit :
{VAR, VAL}
select
'Xpr'||table_name||index_name||column_position,
column_expression
from
all_ind_expressions
where 1=1
[ and table_owner='%SCHEMA%']
[ and table_name='%TABLE%']
Le nom de la variable définie par l'utilisateur est unique, il s'agit du résultat
de la concaténation de "Xpr", du nom de table, du nom d'index et de la
position de colonne.
34 PowerAMC
Qualifiants et reverse engineering ODBC

Le qualifiant d'objet est affiché dans la liste déroulante dans l'angle supérieur
gauche de la boîte de dialogue Reverse engineering ODBC. Vous pouvez
utiliser un qualifiant pour sélectionner les objets sur lesquels faire porter le
reverse engineering.
Vous pouvez ajouter une section relative aux qualifiants lorsque vous
personnalisez votre SGBD. Cette section doit contenir les entrées suivantes :
♦ enable: YES/NO
♦ SqlListQuery (script) : cette entrée contient la requête SQL qui est
exécutée pour extraire la liste des qualifiants. Vous ne devez pas ajouter
d'en-tête à cette requête
L'effet de ces entrées est affiché dans le tableau ci-dessous :
Activé SqlListQuery présent ? Résultat

Yes Yes Les qualifiants sont disponibles et
peuvent être sélectionnés.
Sélectionnez-en si nécessaire. Vous
pouvez également saisir le nom d'un
qualifiant.
SqlListQuery est exécuté pour remplir
la liste des qualifiants
No Seule la valeur par défaut (Tous les
qualifiants) est sélectionnée. Vous
pouvez également saisir le nom d'un
qualifiant

Activé SqlListQuery présent ? Résultat

No No La liste déroulante est grisée
Pour plus d'informations sur les filtres de qualifiants, reportez-vous à la

section Filtres et options de reverse engineering dans le chapitre
Reverse engineering du manuel Guide de l'utilisateur du MPD.
Exemple Dans Adaptive Server Anywhere 7, une requête de qualifiant typique se
présente comme suit :
.Qualifier.SqlListQuery :
select dbspace_name from sysfile
Syntaxe dans les instructions SQL

La syntaxe définie dans la définition de SGBD est utilisée par PowerAMC
pour analyser les instructions SQL lors du reverse engineering d'un script de
base de données. Elle est utilisée pour définir les variables appropriées lors
du processus de création et de modification des objets PowerAMC.
Vous pouvez incorporer des variables dans les requêtes SQL du SGBD
sélectionné. Les variables PowerAMC sont écrites entre signes pourcent (%).
Mots clés réservés

Pour un domaine ou une colonne, les champs de vérifications standard
peuvent indiquer les valeurs minimale, maximale et par défaut, ainsi qu'une
liste de valeurs.
En règle générale, Si le type de données du domaine ou de la colonne est un
type de données de chaîne, des apostrophes encadrent ces valeurs dans le
script généré. Cependant, les apostrophes ne sont pas générées dans les cas
suivants :
♦ Vous pouvez définir un type de données qui n'est pas reconnu en tant
que type de données de chaîne par PowerAMC
♦ La valeur est encadrée par le caractère tilde
♦ La valeur est un mot réservé défini dans le SGBD (par exemple, NULL)
En outre, si la valeur est déjà encadrée d'apostrophes, des apostrophes
supplémentaires ne sont pas générés.
36 PowerAMC
La génération des apostrophes ou des guillemets dépend du SGBD courant.

Le SGBD contient la liste des mots réservés spécifiée sous forme de valeurs
pour le champ ReservedDefault, sous la catégorie Keywords.
Exemple L'exemple suivant affiche le résultat de l'utilisation d'un mot réservé pour le
SGBD Sybase AS Anywhere 6.
Sybase AS Anywhere 6 contient les lignes suivantes :
ReservedDefault =
NULL
AUTOINCREMENT
CURRENT DATE
CURRENT PUBLISHER
CURRENT TIME
CURRENT TIMESTAMP
CURRENT USER
LAST USER
USER
Vous pouvez définir CURRENT DATE comme valeur par défaut pour une
colonne :

Le script résultant contient la chaîne CURRENT DATE sans apostrophe ou

guillemet.
create table SALE
(
SALE_ID T_IDENTIFIER not null,
STOR_ID T_AN_IDENTIFIER not null,
TITLE_ISBN char(12) not null,
SALE_DATE T_DATE not null
default CURRENT DATE,
SALE_AMOUNT T_AMOUNT ,
SALE_TERMS T_LONG_TEXT ,
SALE_QTY T_QUANTITY ,
primary key (SALE_ID)
);
Lorsque vous exécutez ce script, Sybase Adaptive Server Anywhere
reconnaît CURRENT DATE comme valeur par défaut réservée.
Chaînes et variables facultatives

Vous pouvez utiliser des crochets [ ] pour :
♦ Inclure des chaînes et variables facultatives, ou des listes de chaînes et
de variables dans la syntaxe des instructions SQL [%--%]
♦ Tester la valeur d'une variable et insérer ou reconsidérer une valeur en
fonction du résultat du test. [%--%? is true : is false]
♦ Testez le contenu d'une variable [%--%=--? if true : if false]
Reverse
Variable Génération engineering
[%--%] Généré si la variable est Reçoit une valeur si
définie. Si la variable est l'analyseur détecte un
vide ou a la valeur NO ou morceau de commande
FALSE, elle n'est pas SQL correspondant à la
générée variable. Si la variable
est vide ou s'est vue
affecter la valeur NO ou
FALSE, elle n'est pas
renseignée
38 PowerAMC
Reverse
Variable Génération engineering
[%--%? Is true : Si la variable est true, Is Si l'analyseur détecte Is
Is false]
true est généré, si la true, Is true subit le
pour tester la valeur de la variable est false, Is reverse engineering, si
variable (valeur false est généré l'analyseur détecte Is
conditionnelle) false, Is false subit
le reverse engineering
et la variable % % est
définie à True ou False
en fonction
[%--%=--? Is true Si la variable est égale à la Si l'analyseur détecte Is
: Is false]
valeur constante, Is true, Is true subit le
pour tester le contenu de true est généré, si la reverse engineering, si
la variable (valeur variable est différente, Is l'analyseur détecte Is
conditionnelle) false est généré false, Is false subit
le reverse engineering
[.Z: [s1][s2]...] .Z est ignoré Spécifie que la chaîne
et les variables entre
crochets ne sont pas
triés
Exemples ♦ [%--%]
[%OPTIONS%]
Si %OPTIONS% n'est pas FALSE, n'est pas vide ou n'a pas la valeur
NO, la variable est générée, ce texte est remplacé par la valeur de
%OPTIONS% (options physiques pour les objets visibles dans la feuille
de propriétés de l'objet).
[default %DEFAULT%]
Dans le reverse engineering, si un texte default 10 est rencontré lors
du reverse engineering, %DEFAULT% est renseigné avec la valeur 10.
Toutefois cette spécification n'est pas obligatoire et l'instruction SQL fait
l'objet d'un reverse engineering même si la spécification est absente.
Dans la génération du script, si la valeur par défaut est définie (10, par
exemple) lors de la génération, le texte est remplacé par default 10,
dans le cas contraire rien n'est généré pour le bloc.
♦ [%--%? Is true : Is false]

Vous pouvez utiliser une valeur conditionnelle pour une chaîne ou

variable facultative. Deux conditions sont séparées par un signe deux
points au sein de crochets utilisés avec la chaîne ou variable facultative.
Par exemple, [%MAND%?Is true:Is false]. Si %MAND% est évalué
comme true ou renseigné à l'aide d'une valeur (différente de FALSE ou
NO) lors de la génération, ce texte est remplacé par Is true. Dans le
cas contraire, il est remplacé par Is false.
♦ [%--%=--? Is true : Is false]
Vous pouvez également utiliser des mots clés pour tester le contenu
d'une variable.
[%DELCONST%=RESTRICT?:[on delete %DELCONST%]]
♦ Create table abc (a integer not null default 99)
Create table abc (a integer default 99 not null)
Ces deux commandes de création sont identiques mais les attributs sont
inversés.
En règle générale, le fichier XDB cible prend en charge uniquement une
notation avec un ordre spécifique dans la chaîne et les variables. Si vous
procédez au reverse engineering de ces deux commandes, l'une d'elles ne
passera pas en raison de l'ordre des variables. Vous pouvez contourner
cette limitation en utilisant la macro .Z de la façon suivante :
%COLUMN% %DATATYPE%[.Z: [%NOTNULL%][%DEFAULT%]]
Si vous utilisez cette macro, l'analyseur syntaxique du reverse
engineering ne prend plus en compte l'ordre dans les variables.
Utilisation des Une chaîne placée entre crochets est toujours générée ; toutefois, que cette
chaînes chaîne soit présente ou non dans l'instruction SQL n'annulera pas le reverse
engineering de l'instruction courante puisqu'elle est facultative dans la
syntaxe SQL de l'instruction. Par exemple, la syntaxe de création d'une vue
inclut une chaîne :
create [or replace] view %VIEW% as %SQL%
Lorsque vous procédez au reverse engineering d'un script, et si ce dernier ne
contient que create ou create or replace, l'instruction fait l'objet
d'un reverse engineering dans les deux cas car la chaîne est facultative.
40 PowerAMC
Définition d'options de format de variable

Les variables ont une syntaxe qui peut forcer un format sur leur valeur. Les
utilisations les plus courantes sont les suivantes :
♦ Forcer les valeurs en minuscules ou en majuscules
♦ Tronquer les valeurs
♦ Mettre le texte entre guillemets
Vous devez incorporer les options de format dans la syntaxe de variable
comme suit :
%.format:variable%
Les options de format des variables sont les suivantes :
Option Description
n (n, étant un Ajoute des espaces ou des zéros à gauche pour remplir la
entier) largeur et justifier à droite
-n Ajoute des espaces ou des zéros à droite pour remplir la
largeur et justifier à gauche
.L Force les caractères en minuscules
.U Force les caractères en majuscules
.c Force la majuscule à la première lettre ainsi que des
minuscules aux autres lettres du mot
.F Combiné avec L et U, applique des conversions au premier
caractère
.T Les espaces de début et de fin sont supprimés de la variable
.n Tronque la valeur pour ne conserver que les n premiers
caractères
.-n Tronque la valeur pour ne conserver que les n derniers
caractères
q Place la variable entre apostrophes
Q Place la variable entre guillemets
Vous pouvez combiner les codes de format. Par exemple, %.U8:CHILD%

met en forme le code de la table enfant avec un maximum de huit caractères
majuscules.

Exemple Les exemples suivants montrent les codes de format incorporés dans la
syntaxe de variable pour le template de nom de contrainte des clés primaires,
en utilisant une table nommée CUSTOMER_PRIORITY :
Format Utilisation Exemple Résultat

.L Minuscules PK_%.L:TABLE% PK_customer_priority
.Un Majuscules + PK_%.U12:TABLE% PK_CUSTOMER_PRI
texte de variable
justifié à droite
jusqu'à une
longueur fixe, n
représente le
nombre de
caractères
.T Supprimer les PK_%.T:TABLE% PK_customer_priority
espaces de début
et de fin de la
variable
.n Longueur PK_%.8:TABLE% PK_Customer
maximum dans
laquelle n
représente le
nombre de
caractères
-n Complète le PK_%-20:TABLE% PK_ Customer_priority
résultat avec des
espaces à droite
pour afficher une
longueur fixe
dans laquelle n
représente le
nombre de
caractères
Pour obtenir la liste des variables utilisées dans PowerAMC, reportez-

vous à la section Variables de MPD.
42 PowerAMC
Template de nom de contrainte

Le SGBD utilise des variables et des formats de variable pour définir des
templates de nom de contrainte. Ces derniers dont définis par la valeur du
champ de SGBD ConstName. Les catégories d'objet suivantes ont un nom
ConstName :
TABLE Template de nom de contrainte pour les vérifications de table
COLUMN Template de nom de contrainte pour les vérifications de
colonne
PKEY Template de nom de contrainte pour les vérifications de clé
primaire
KEY Template de nom de contrainte pour les vérifications de clé
alternative
REFERENCE Template de nom de contrainte pour les vérifications de clé
étrangère
Dans PowerAMC, vous pouvez définir des noms de contrainte définis par
l'utilisateur. Les templates s'appliquent à toutes les contraintes pour lesquelles
vous ne définissez pas de noms de contrainte définis par l'utilisateur.
Variables Code et De nombreux objets ont des variables Code et Generated Code qui sont
Generated code différenciées comme suit :
Variable Description
Code Code d'attribut défini dans la feuille de propriétés
Generated Code Code calculé en fonction des options de génération. Le
code généré peut être différent du code dans les cas
suivants :
Le code est un mot réservé ou contient des caractères
incorrects. Le code généré est placé entre
guillemets
Le code est plus long que la longueur autorisée par le
SGBD. Le code généré est tronqué
Pour obtenir la liste de toutes les variables utilisées dans PowerAMC,

reportez-vous à la section Variables de MPD.

Variables de nom Le champ ConstName pour tous les objets peut accepter les variables
communes pour courantes suivantes :
ConstName
%@OBJTNAME% Nom d'objet
%@OBJTCODE% Code d'objet
%@OBJTLABL% Commentaire pour l'objet
%@OBJTDESC% Description pour l'objet
ConstName pour Le champ ConstName pour l'objet TABLE peut accepter les variables
TABLE suivantes :
Variable Valeur
%TABLE% Code généré pour la table
%TNAME% Nom de la table
%TCODE% Code de la table
%TLABL% Commentaire de la table
ConstName pour Le champ ConstName pour l'objet COLUMN peut accepter les variables
COLUMN suivantes :
Variable Valeur
%COLUMN% Code généré pour la colonne
%COLNAME% Nom de la colonne
%COLNCODE% Code de la colonne
ConstName pour Le champ ConstName pour l'objet PKEY peut accepter la variable suivante :
PKEY
Variable Valeur
%CONSTNAME% Nom de contrainte
ConstName pour Le champ ConstName pour l'objet KEY peut accepter les variables
KEY suivantes :
Variable Valeur
%AKEY% Code de la clé alternative
%TABLE% Code de la table
44 PowerAMC
ConstName pour Le champ ConstName pour l'objet REFERENCE peut accepter les variables
REFERENCE suivantes :
Variable Valeur
%REFR% Code généré pour la référence
%PARENT% Code généré pour la table parent
%PNAME% Nom de la table parent
%PCODE% Code de la table parent
%CHILD% Code généré pour la table enfant
%CNAME% Nom de la table enfant
%CCODE% Code généré pour la table enfant
%PQUALIFIER% Qualifiant de la table parent
%CQUALIFIER% Qualifiant de la table enfant
%REFRNAME% Nom de référence
%REFRCODE% Code de référence
%PKCONSTRAINT% Nom de contrainte de clé parent utilisé pour faire
référence à l'objet
%POWNER% Propriétaire de la table parent
%COWNER% Propriétaire de la table enfant
%CHCKONCMMT% TRUE lorsque Check on commit est sélectionné sur la
référence (spécifique ASA 6.0)
Exemple L'exemple suivant montre l'utilisation de templates de nom de contrainte pour

Sybase Adaptive Server Anywhere 6.
Le SGBD Adaptive Server Anywhere 6 contient les valeurs suivantes pour le
champ ConstName :
Catégorie Commentaire Valeur

PKEY Template de nom PK_%.U27:TABLE%
de contrainte pour
les clés primaires
REFR Template de nom FK_%.U8:CHILD%_%.U9:REFR%_%.U8:
de contrainte pour PARENT%
les clés étrangères

Catégorie Commentaire Valeur

KEY Template de nom AK_%.U18:AKEY%_%.U8:TABLE%
de contrainte pour
les clés alternatives
COLN Template de nom CKC_%.U17:COLUMN%_%.U8:TABLE%
de contrainte pour
les vérifications de
colonne
TABL Template de nom CKT_%.U26:TABLE%
de contrainte pour
les vérifications de
table
Le script résultant que vous pouvez générer pour une table utilisant Adaptive
Server Anywhere 6 déclare les noms de contrainte comme suit :
create table DISCOUNT
(
DISCOUNT_ID T_IDENTIFIER not null,
STOR_ID T_AN_IDENTIFIER not null,
DISC_PERCENT T_PERCENT not null,
DISC_TYPE T_SHORT_TEXT null
constraint CKC_DISC_TYPE_DISCOUNT check
(DISC_TYPE in ('High','Medium','Low')),
DISC_LOWQTY T_QUANTITY null ,
DISC_HIGHQTY T_QUANTITY null ,
constraint PK_DISCOUNT primary key (DISCOUNT_ID)
)
go
46 PowerAMC
Définition d'options physiques

Dans certaines définitions de SGBD, les entrées Options sont utilisées pour
définir une arborescence d'options physiques dans le volet gauche de la
feuille de propriétés d'un objet. Une option physique est un paramètre qui
définit la façon dont un objet est optimisé ou stocké dans une base de
données. Les options physiques peuvent être incluses à la fin d'une
instruction Create et sont spécifiques à un SGBD.
Une arborescence typique est représentée ci-dessous :
Lors de la génération, les options sélectionnées dans le modèle pour chaque

objet sont stockées dans une variable %OPTIONS%.
La variable %OPTIONS% contient la chaîne d'option physique comme si elle
était écrite dans un script SQL. Cette chaîne doit s'afficher à la fin de
l'élément auquel elle appartient et ne doit être suivie de rien.
Exemple create table
[%OPTIONS%]
Il s'agit de la syntaxe correcte.

Variables dans les Vous pouvez utiliser les variables PowerAMC définies pour un objet donné
options physiques pour définir les options pour cet objet.
Par exemple, dans Oracle, vous pouvez définir la variable suivante pour un
cluster si vous souhaitez que ce cluster prenne le même nom que la table.
Cluster %TABLE%
Pour obtenir la liste de toutes les variables utilisées dans PowerAMC,
Attributs étendus Vous pouvez utiliser des attributs étendus dans des options physiques.
Pour plus d'informations sur les attributs étendus, reportez-vous à la
section Catégorie Profile.
Lors du reverse engineering par script, la section de la requête SQL
déterminée comme étant les options physiques est stockée dans
%OPTIONS%, et sera ensuite analysée lorsque requis par une feuille de
propriétés d'objet.
Lors du reverse engineering ODBC, l'instruction SqlOptsQuery est
exécutée pour extraire les options physiques qui sont stockées dans
%OPTIONS% afin de les analyser lorsque requis par une feuille de
propriétés d'objet.
Selon la définition de SGBD, vous pouvez définir des options physiques pour
les objets suivants :
♦ Tablespace
♦ Storage
♦ Database
♦ Table
♦ Column
♦ Index
♦ Key (primaire et alternative)
Les options physiques typiques sont pctfree, pctused, fillfactor et
partition.
Vous définissez des options physiques sur la feuille de propriétés d'un objet.
48 PowerAMC
Définition d'options physiques spécifiées par une valeur

Les entrées d'options physiques contiennent du texte qui est analysé et utilisé
pour renseigner le volet gauche de la page Options de l'objet. Chaque ligne
d'une entrée Option crée une ligne dans le volet gauche de la page d'options
physiques. L'utilisateur peut cliquer sur les boutons entre les deux volets pour
sélectionner ces lignes.
Les lignes peuvent ou non contenir des variables %d ou %s pour laisser
l'utilisateur spécifier une valeur. Exemple :
with max_rows_per_page=%d
on %s: category=storage
Lorsque vous sélectionnez une option avec une valeur %d ou %s dans le volet
droit, une zone d'édition s'affiche en bas de ce volet. Elle est utilisée lorsque
l'option physique requiert une valeur. Les variables possibles sont les
suivantes :
%d Une valeur numérique suit l'option physique. Vous devez saisir une
valeur numérique dans le champ d'édition
%s La chaîne suit l'option physique. Vous devez saisir une chaîne dans
la zone d'édition
Chaque option sélectionnée crée une ligne dans le volet droit. Si la sélection
contient une variable %d, une valeur numérique peut être entrée. Si la
sélection contient une variable %s, un texte est entré. Si la sélection ne
contient ni variable %d ni variable %s, aucune valeur n'est entrée.
Les variables entre signes % (%--%) ne sont pas admises dans les options
physiques.
Vous pouvez spécifier une contrainte sur n'importe quelle ligne contenant une
variable, par exemple une liste de valeurs, des valeurs par défaut, la valeur
doit être un storage ou un tablespace, certaines lignes peuvent être groupées.
Ces contraintes sont introduites par une virgule directement derrière l'option
physique et séparées par des virgules (voir la section suivante).

Exemple La page Options dans une feuille de propriétés de tables est illustrée ci-
dessous :
Lorsque l'option with max_rows_per_page est sélectionnée, la zone

Valeur s'affiche en bas de la page, en regard du bouton Egal. La valeur par
défaut est zéro (0).
With max_rows_per_page est une option physique d'index pour
Sybase AS Enterprise 11.x. Cette option limite le nombre de lignes par page
de données. La syntaxe se présente comme suit :
with max_row_per_page = x
Où x est le nombre de lignes spécifié par l'utilisateur.
Dans Sybase Adaptive Server Enterprise, cette option peut être définie pour
l'objet d'index comme suit :
with max_rows_per_page=%d
on %s : category=storage
Les variables %d et %s doivent se trouver en dernière position et ne doivent
pas être suivies d'autres options.
50 PowerAMC
Syntaxe pour une option physique sans nom

Une ligne dans une entrée d'option ne doit pas contenir uniquement une
variable, elle doit contenir un texte pour l'option physique ou un nom afin de
d'être identifiée par PowerAMC. Une option physique dépourvue de texte ne
peut pas être représentée dans la syntaxe PowerAMC. Si une option physique
est dépourvue de nom, vous devez ajouter un nom entre signes supérieur et
inférieur à (<>) avant l'option. Cet indicateur est un mot qui décrit l'option
physique à saisir.
Exemple Pour définir un segment dans Sybase AS Enterprise 11, la syntaxe appropriée
est la suivante :
sp_addsegment segmentname, databasename, devicename
segmentname correspond au code de storage défini dans PowerAMC.
databasename correspond au code de modèle. Ces deux entrées sont
automatiquement générées. devicename doit être saisi par l'utilisateur, il
devient une option.
Dans SYSTEM11, cette option est définie comme suit :
Create = execute sp_addsegment %STORAGE%, %DATABASE%,
%OPTIONS%
OPTIONS = <devname> %s
Une option physique dépourvue de nom doit être suivie de la variable %d ou
%s.
Définition d'une valeur par défaut pour une option physique

Une option physique peut avoir une valeur par défaut. Le mot clé
Default= est utilisé pour spécifier cette valeur. Après le nom de l'option
physique ou après la valeur %d ou %s, il est nécessaire d'ajouter un signe
deux points suivi de default=x, où x est la valeur par défaut de la base de
données cible.
Exemple La valeur par défaut pour max_row_per_page est 0. Dans Sybase
Adaptive Server Enterprise 11, cette valeur par défaut pour l'objet d'index est
définie comme suit :
max_rows_per_page=%d : default=0
La valeur par défaut est affichée par défaut dans la fenêtre Options.

Définition d'une liste de valeurs pour une option physique

Lorsque vous utilisez les variables %d et %s, une valeur d'option physique
peut correspondre à une liste d'options possibles. Le mot clé List= est
utilisé pour spécifier cette liste. Après le nom de l'option physique, ou après
la valeur %d ou %s, il est nécessaire d'ajouter un signe deux-points, puis
list= x | y co où x, y et z sont des valeurs possibles. Les valeurs
sont séparées par le caractère |.
Exemple L'option dup_prow d'un index Sybase Adaptive Server Enterprise
correspond à deux options mutuellement exclusives pour créer un index
cluster non unique. Cette option peut être ignorée ou admise.
Dans Sybase Adaptive Server Enterprise 11 :
IndexOption =
<duprow> %s: list=ignore_dup_row | allow_dup_row
Une liste déroulante avec les valeurs est affichée en regard du volet droit de
la page d'options physiques.
Utilisation d'une virgule pour séparer Default et List

Si vous utilisez simultanément Default= et List=, vous devez les
séparer par une virgule.
Exemple Si ignore_dup_row est la valeur par défaut pour un index, la syntaxe

utilisée dans le fichier de définition de SGBD pour définir cette valeur est la
suivante :
IndexOption =
<duprow> %s: default= ignore_dup_row, list=ignore_dup_row
| allow_dup_row
Définition d'une option physique correspondant à un tablespace ou

à un storage
Une option physique peut utiliser le code d'un tablespace ou d'un storage :
category=tablespace ou category=storage construit une liste
avec tous les codes de tablespace ou de storage définis dans la boîte de
dialogue Liste des tablespaces ou Liste des storages.
Exemple L'option d'index on segmentname spécifie que l'index est créé sur le
segment nommé. Un segment Sybase correspond à un storage PowerAMC.
La syntaxe est la suivante :
on segmentname
52 PowerAMC
Dans Sybase Adaptive Server Enterprise 11, la valeur par défaut pour l'objet
d'index est définie dans les options comme suit :
on %s: category=storage
Vous pouvez sélectionner le storage approprié dans une liste déroulante dans
la page d'options physiques.
Syntaxe d'option physique composite

Une option physique composite est une option physique qui inclut d'autres
options dépendantes. Ces options sont sélectionnées simultanément dans le
volet droit de la page d'options physiques.
La syntaxe standard pour les options physiques se présente comme suit :
with : composite=yes, separator=yes, parenthesis=no
{
fillfactor=%d : default=0
}
L'option physique With inclut les autres options entre accolades { },
séparées par une virgule. Pour définir une option composite, vous devez
utiliser un mot clé composite.
Mot clé Valeur et résultat

composite= Si composite=yes, des accolades sont utilisées pour définir une
option physique composite
separator= Si separator=yes, les options sont séparées par une virgule
Si separator=no, les options sont dépourvues de caractère
séparateur. Il s'agit de la valeur par défaut
parenthesis= Si parenthesis=yes, l'option composite est délimitée par des
parenthèses qui incluent toutes les autres options, par
exemple :
with (max_row_per_page=0,
ignore_dup_key)
Si parenthesis=no, rien ne délimite l'option composite. Il s'agit
de la valeur par défaut
nextmand= Si nextmand=yes, la prochaine ligne dans l'option physique est
obligatoire. Si vous n'utilisez pas ce mot clé, vous ne serez
pas en mesure de procéder à la génération/au reverse
engineering de l'intégralité de l'option physique composite
prevmand= Si prevmand=yes, la ligne précédente dans l'option physique est
obligatoire. Si vous n'utilisez pas ce mot clé, vous ne serez
pas en mesure de procéder à la génération/au reverse
engineering de l'intégralité de l'option physique composite

Mot clé Valeur et résultat

childmand= Si childmand=yes, il doit y avoir au moins une ligne enfant
category= Si category=tablespace, l'élément est lié à un tablespace
Si category=storage, l'élément est lié à un storage (*)
list= Liste dans laquelle des valeurs sont séparées par un trait vertical
(|)
dquoted= Si dquoted=yes, la valeur est placée entre guillemets ("" "")
squoted= Si squoted=yes, la valeur est placée entre apostrophes (' ')
enabledbprefix= Si enabledbprefix=yes, le nom de base de données est utilisé
comme préfixe (voir les options de tablespace dans DB2
OS/390)
Default= et/ou List= peut également être utilisé avec les mots clés
composite=, separator= et parenthesis=. Category= peut être
utilisé avec les trois mots clés d'une option composite.
Exemple Les options relatives aux index IBM DB2 contiennent l'option composite
suivante :
<using_block> : composite=yes
{
using vcat %s
using stogroup %s : category=storage, composite=yes
{
priqty %d : default=12
secqty %d
erase %s : default=no, list=yes | no
}
(*) Cas particulier Dans Oracle, la catégorie Storage est utilisée comme template pour définir
avec Oracle toutes les valeurs de storage dans une entrée de storage. Ceci vous permet
d'éviter d'avoir à définir des valeurs indépendamment chaque fois que vous
devez utiliser les mêmes valeurs dans une clause de storage. L'option
physique Oracle n'inclut pas le nom de storage (%s)
storage : category=storage, composite=yes, separator=no,
parenthesis=yes
{
54 PowerAMC
Répétitions d'options
Certaines bases de données répètent un bloc d'options, groupées dans une
option composite. Dans ce cas, la définition composite contient le mot clé
multiple :
with: composite=yes, multiple=yes
Par exemple, les options de fragmentation Informix peuvent être répétées n

fois comme illustré ci-après :
IndexOption =
fragment by expression : composite=yes, separator=yes
{
<list> : composite=yes, multiple=yes
{
<frag-expression> %s
in %s : category=storage
}
remainder in %s : category=storage
}
La sous-option <list> est utilisée pour éviter d'avoir à répéter le mot clé
fragment avec chaque nouveau bloc d'options.
Lorsque vous répétez une option composite, cette option s'affiche avec <*>
dans le volet des options physiques disponibles (volet gauche) sur la page des
options physiques.
max_rows_per_page=0 <*>
Vous pouvez ajouter l'option composite dans le volet droit plusieurs fois en
utilisant le bouton Ajouter entre les volets, sur la page d'options physiques.

Si la sélection se trouve sur l'option composite dans le volet droit et que vous
cliquez sur la même option composite dans le volet gauche afin de l'ajouter,
une boîte de message vous demande si vous souhaitez réutiliser l'option
sélectionnée. Si vous cliquez sur Non, l'option composite est ajoutée dans le
volet droit comme nouvelle ligne.
Changements d'interface utilisateur

Votre interface utilisateur spécifique peut être différente de celle montrée
dans les illustrations. Ceci est dû aux caractéristiques spécifiques du SGBD
que vous utilisez ou modifiez ainsi qu'aux paramètres de l'entrée
sélectionnée.
Si un paramètre d'option est vide pour un objet, ou s'il n'est pas activé,
l'interface change comme suit :
♦ L'onglet Options correspondant ne s'affiche pas dans la feuille de
propriétés de l'objet. Cette particularité est applicable à Tablespace,
Storage, Database, Primary key et Keys
♦ Les cases à cocher Options physiques contenues dans la fenêtre
Génération d'une base de données et Modifications d'une base de
données, ainsi que dans la page Base de données de la boîte de dialogue
Génération d'une base de données sont grisées et ne sont pas accessibles.
Ceci concerne les zones de groupe Tables, Index et Bases de données
56 PowerAMC
Catégorie General
La catégorie General contient des informations d'identification de SGBD.
EnableCheck
Détermine si la génération des paramètres de contrôle est autorisée ou non.
Valeur Résultat
Yes Paramètres de contrôle générés
No Toutes les variables liées aux paramètres de contrôle ne seront pas
évaluées lors des processus de génération et de reverse engineering
EnableIntegrity
Permet de recourir à des contraintes d'intégrité dans le SGBD. Vous
contrôlez ainsi si les paramètres de génération relatifs aux clés primaires,
étrangères ou alternatives sont grisés ou disponibles.
Valeur Résultat
Yes Les cases relatives aux clés primaires, clés alternatives et clés
étrangères sont disponibles pour la génération et la modification de
base de données
No Les cases relatives aux clés primaires, clés alternatives et clés
étrangères sont grisées et non disponibles pour la génération et la
modification de base de données

Catégorie General
EnableMultiCheck
Détermine si la génération de plusieurs paramètres de contrôle pour les tables
et colonnes est autorisée ou non.
Valeur Résultat
Yes Plusieurs paramètres de contrôle sont générés. La première contrainte
dans le script correspond à la concaténation de toutes les règles de
validation, les autres contraintes correspondent à chaque règle de
gestion de contrainte attachée à un objet
No Toutes les règles de gestion (validation et contrainte) sont concaténées
dans une même expression de contrainte
EnableConstname
Détermine si les noms de contrainte sont utilisés lors de la génération.
Valeur Résultat
Yes Les noms de contrainte sont utilisés lors de la génération
No Les noms de contrainte ne sont pas utilisés
SqlSupport
Détermine si la syntaxe SQL est admise. Cette entrée est sans influence sur la
génération de script mais a un impact sur l'aperçu de code SQL.
Valeur Résultat
Yes Syntaxe SQL admise et Aperçu SQL disponible
No La Syntaxe SQL admise et Aperçu SQL disponible
58 PowerAMC
UniqConstName
Détermine si les noms de contrainte uniques pour les objets sont ou non
autorisés.
Valeur Résultat
Yes Tous les noms de contrainte doivent être uniques dans la base de
données, y compris les noms d'index
No Les noms de contrainte doivent être uniques pour un objet
La vérification de modèle prend en compte cette entrée lors de la vérification

de nom de contrainte.

Catégories Script ou ODBC
Catégories Script ou ODBC

La catégorie Script est utilisée pour la génération de Script et la catégorie
ODBC est utilisée pour la génération ODBC. Lorsqu'une valeur d'entrée ou
sa catégorie est manquante dans la catégorie ODBC lors de la génération
ODBC, elle est automatiquement recherchée dans la catégorie Script.
Les catégories Script ou ODBC sont divisées en catégories comme suit :
♦ SQL
♦ Objects
♦ Data Type
Toutes les entrées de chaque catégorie sont décrites dans les sections
suivantes.
60 PowerAMC
Catégorie SQL
La catégorie SQL contient les catégories suivantes :
♦ Syntax
♦ Format
♦ File
♦ Keywords
Ces catégories contiennent les entrées qui définissent la syntaxe SQL pour le
SGBD.
Syntax
La catégorie Syntax contient les entrées qui définissent la syntaxe spécifique
au SGBD.
Terminator
Caractère de fin d'instruction. Est utilisé pour terminer les instructions telles
que les instructions de création de table, de vue ou d'index, ou bien pour les
instructions d'ouverture/fermeture de base de données.
Exemple Terminator = ;
Si aucune valeur n'est spécifiée, c'est BlockTerminator qui est utilisé.
BlockTerminator
Caractère de fin de bloc. Est utilisé pour terminer les expressions pour les
triggers et les procédures stockées.
Exemple BlockTerminator = /

Catégorie SQL
UseBlockTerm
Syntaxe d'utilisation de BlockTerminator.
Valeur Résultat
Yes BlockTerminator est toujours utilisé
No BlockTerminator est utilisé pour les triggers et les procédures
stockées uniquement
Exemple Dans Oracle 8I :

UseBlockTerm = yes
Delimiter
Caractère de séparation de champs. Par exemple : col1, col2, col3.
Exemple Delimiter = ,
Les colonnes sont séparées par des virgules dans l'instruction create table.
create table CUSTOMER
(
CUSNUM numeric(5) not null,
CUSNAME char(30) not null,
CUSADDR char(80) not null,
CUSACT char(80) ,
CUSTEL char(12) ,
CUSFAX char(12) ,
primary key (CUSNUM)
);
Quote
Caractère utilisé pour encadrer les valeurs de chaîne. Il s'agit le plus souvent
de l'apostrophe ou du guillemet.
Exemple Quote = '
Quote est utilisé pour placer des apostrophes ou des guillemets de part et
d'autre des valeurs par défaut dans le code SQL généré.
Cohérence entre les apostrophes ou guillemets

Le même caractère (apostrophe ou guillemet) doit être utilisé dans les
pages de paramètres de contrôle pour encadrer les mots réservés utilisés
comme valeur par défaut.
62 PowerAMC
SqlContinue
Caractère de suite. Certaines bases de données requièrent un caractère de
suite lorsqu'une instruction dépasse une ligne. Pour connaître le caractère
approprié, reportez-vous à la documentation relative à votre SGBD. Ce
caractère est attaché à chaque ligne, juste avant le caractère de saut de ligne.
BlockComment
Caractère utilisé pour encadrer un commentaire portant sur plusieurs lignes.
Utilisé dans le reverse engineering et dans la génération.
Exemple BlockComment = /* */
Ajoute un espace entre les caractères d'ouverture et de fermeture.
LineComment
Caractère utilisé pour encadrer un commentaire d'une seule ligne.
Utilisé dans le reverse engineering.
Exemple LineComment = %%
Format
La catégorie Format contient des entrées qui définissent le format du script.
IllegalChar
Caractères incorrects pour les noms. Utilisé uniquement pour la génération.
Si le code contient un caractère illégal, il est défini entre guillemets lors de la
génération.
IllegalChar = "+-*/!=<>'"()"
Exemple If the name of the table is “SALES+PROFITS", the
generated create statement will be:
CREATE TABLE "SALES+PROFITS"
Des guillemets sont placés de part et d'autre du nom de table pour indiquer
qu'un caractère incorrect est utilisé.
Lors du reverse engineering, tout caractère illégal est considéré comme
séparateur à moins qu'il ne soit situé dans un nom entre guillemets.

Catégorie SQL
CaseSensitivityUsingQuote
Détermine si la sensibilité à la casse est gérée à l'aide de guillemets. Vous
devez définir cette valeur booléenne à Yes si le SGBD que vous utilisez
nécessite des guillemets pour préserver la casse des codes d'objet.
UpperCaseOnly
Majuscules uniquement. Lorsque vous générez un script à partir d'un MPD,
tous les objets (tables, colonnes, contraintes, index, etc.) peuvent être forcés
en majuscules à la génération, indépendamment des conventions de
dénomination définies pour le modèle (Majuscules, Minuscules ou Mixte) et
des codes du MPD.
Valeur Résultat
Yes Force tous les caractères du script généré en majuscules
No Génère tout le script sans changer la façon dont les objets sont écrits
dans le modèle (majuscules, minuscules, ou mixte)
Exemple UpperCaseOnly = NO
Conflit entre UpperCaseOnly et LowerCaseOnly

Le champ UpperCaseOnly est ignoré si les entrées UpperCaseOnly
et LowerCaseOnly sont définies à la valeur Yes. Dans ce cas, le script
PowerAMC est généré en minuscules.
LowerCaseOnly
Minuscules uniquement. Lorsque vous générez un script à partir d'un MPD,
tous les objets (tables, colonnes, contraintes, index, etc.) peuvent être forcés
en minuscules à la génération, indépendamment des conventions de
dénomination définies pour le modèle (Majuscules, Minuscules ou Mixte) et
des codes du MPD.
Valeur Résultat
Yes Force tous les caractères du script généré en minuscules
No Génère tout le script sans changer la façon dont les objets sont écrits
dans le modèle (majuscules, minuscules, ou mixte)
Exemple LowerCaseOnly = YES
64 PowerAMC
EnableOwnerPrefix et EnableDtbsPrefix
Les codes d'objet peuvent être préfixés par le nom du propriétaire de l'objet,
le nom de la base de données, ou les deux, ce afin d'être identifiés de façon
unique. Vous pouvez pour ce faire utiliser la variable %QUALIFIER%.
Si vous souhaitez que le préfixe soit le propriétaire de l'objet, vous devez
définir la valeur de l'entrée EnableOwnerPrefix à Yes, puis cocher la case
Préfixe de propriétaire dans la boîte de dialogue de génération. Si vous
souhaitez que le préfixe soit le nom de la base de données, vous devez définir
la valeur de l'entrée EnableDtbsPrefix à Yes et cocher la case Préfixe de base
de données dans la boîte de dialogue de génération.
Si vous cochez à la fois les cases Préfixe de base de données et Préfixe de
propriétaire, les deux noms sont concaténés lorsque %QUALIFIER% est
évalué.
Valeur Résultat
Yes Les cases Préfixe de base de données et Préfixe de propriétaire sont
disponibles dans la boîte de dialogue de génération. La variable
%QUALIFIER% est renseignée avec le nom de l'objet, ou le nom de la
base de données, ou bien les deux lors de la génération ou du reverse
engineering
No Les cases Préfixe de base de données et Préfixe de propriétaire sont
grisées et le préfixe n'est pas disponible
MaxScriptLen
Indiquent la longueur maximale d'une ligne de script.
Exemple 1024
AddQuote
Détermine si les codes d'objet sont systématiquement placés entre
apostrophes ou guillemets lors de la génération.
Valeur Résultat
Yes Les codes d'objet sont systématiquement placés entre apostrophes ou
guillemets lors de la génération
No Les codes d'objet sont générés sans apostrophes ou guillemets

Catégorie SQL
Format de date et d'heure

Vous pouvez personnaliser le format de date et d'heure pour la génération des
données de test via script ou via ODBC en utilisant les entrées de SGBD dans
la catégorie Format.
PowerAMC utilise la table de correspondance PhysDataType dans la
catégorie Script\Data types afin de convertir les types de données physiques
des colonnes en types de données conceptuels car les entrées de SGBD sont
liées aux types de données conceptuels.
Exemple pour Sybase AS Anywhere 7 :
Type de Type de Entrée de SGBD

données données utilisée pour Entrée de SGBD
physique conceptuel SQL utilisée pour ODBC
datetime DT DateTimeFormat OdbcDateTimeFormat
timestamp TS DateTimeFormat OdbcDateTimeFormat
date D DateFormat OdbcDateFormat
time T TimeFormat OdbcTimeFormat
Si vous souhaitez personnaliser le format de date et d'heure pour votre

génération de données de test, vous devez vérifier le type de données des
colonnes dans votre SGBD, puis trouver le type de données conceptuel
correspondant afin de savoir quelle entrée personnaliser dans votre SGBD.
Par exemple, si les colonnes utilisent les données Date & heure dans votre
modèle, vous devez personnaliser l'entrée DateTimeFormat dans votre
SGBD.
Le format par défaut pour la date et l'heure est le suivant :
♦ SQL: 'yyyy-mm-dd HH:MM:SS'
♦ ODBC : {ts 'yyy-mm-dd HH:MM:SS'}
Dans lequel :
Format Description
yyyy Année sur quatre chiffres
yy Année sur deux chiffres
mm Mois
dd Jour
HH Heure
66 PowerAMC
Format Description
MM Minute
SS Seconde
Par exemple, vous pouvez définir la valeur suivante pour l'entrée

DateTimeFormat pour SQL : aa-mm-dd HH:MM. Pour ODBC, cette entrée
doit avoir la valeur suivante : {ts 'yy-mm-dd HH:MM'}.
File
La catégorie File contient des entrées qui définissent le format du script.
Header
Texte d'en-tête pour un script de génération de base de données.
Footer
Texte de fin pour un script de génération de base de données.

Catégorie SQL
EnableMultiFile
Multi-script admis. Cette variable agit sur la disponibilité de la case Un seul
fichier dans la boîte de dialogue de génération de base de données, la boîte
de dialogue de triggers et de procédures ou la boîte de dialogue de
modification de base de données.
Valeur Résultat
Yes La case à cocher Un seul fichier est disponible. Si vous décochez cette
case, un script est créé pour chaque table, et un script général récapitule
toutes les entrées de script de table. Chaque script a le nom de la table
et le suffixe défini dans la variable TableExt. Si vous cochez cette case,
un seul script global inclut tous les scripts.
Le script général a comme suffixe de nom de fichier celui décrit dans la
variable de SGBD ScriptExt, et son nom est personnalisable dans la
zone Nom de fichier des boîtes de dialogue de génération ou de
modification. Les noms par défaut sont CREBAS pour la génération de
base de données, CRETRG pour la génération des triggers et les
procédures stockées, et ALTER pour la modification de base de
données
No La case à cocher Un seul fichier est grisée, et un seul script inclut toutes
les commandes.
Le suffixe de nom de fichier est décrit dans la variable ScriptExt, et son
nom est personnalisable dans la zone Nom de fichier des boîtes de
dialogue de génération ou de modification. Les noms par défaut sont
CREBAS pour la génération de base de données, CRETRG pour la
génération des triggers et les procédures stockées, et ALTER pour la
modification de base de données
Pour plus d'informations sur les variables utilisées avec PowerAMC,

Exemple EnableMultiFile = YES
ScriptExt
La variable ScriptExt définit le suffixe de script par défaut lorsque vous
générez une base de données ou la modifiez pour la première fois.
Exemple ScriptExt = sql
68 PowerAMC
TableExt
Si vous ne cochez pas la case Un seul fichier lorsque vous générez une base
de données, ou lorsque vous modifiez une base de données, un script est
généré pour chaque table, avec le suffixe de nom de fichier défini dans la
variable TableExt.
Exemple TableExt = sql
Voir aussi EnableMultiFile.
StartCommand
Instruction d'exécution d'un script. Ce paramètre correspond à la variable
%STARTCMD%. La valeur de cette variable dépend de ce paramètre.
L'instruction de début correspond à l'instruction utilisée par la base de
données cible pour exécuter un script SQL.
Le contenu de cette variable est utilisé dans le fichier d'en-tête pour une
génération portant sur plusieurs fichiers. Elle est utilisée pour appeler tous les
autres fichiers générés depuis le fichier d'en-tête.
Exemple Dans Sybase AS Enterprise 11.x :
StartCommand = isql %NAMESCRIPT%
Usage1
Applicable lorsque vous utilisez un script unique.
S'affiche à la fin de la génération dans la fenêtre Résultats.
(1) Start the SQL interpreter: ISQL
Exemple (2) Open the script %NAMESCRIPT%
(3) Execute the script
Usage2
Applicable lorsque vous utilisez plusieurs scripts.
Exemple (2) Open one script from the directory %PATHSCRIPT%
(3) Execute this script

Catégorie SQL
TriggerExt
Variable qui définit le suffixe du script principal lorsque vous générez des
triggers et des procédures stockées pour la première fois.
Exemple TriggerExt = trg
TrgUsage1
Applicable lorsque vous utilisez un script unique pour la génération des
triggers et des procédures.
Exemple (2) Select the item "Options" of the menu "Command"
(3) Change "Command Delimiter" to /
(4) Open the script %NAMESCRIPT% from the directory
%PATHSCRIPT%
(6) Restore "Command Delimiter" to ;
TrgUsage2
Applicable lorsque vous utilisez plusieurs scripts pour la génération des
triggers et procédures.
Exemple (2) Select the item "Options" of the menu "Command"
(3) Change "Command Delimiter" to /
(4) Open one script from the directory %PATHSCRIPT%
(6) Restore "Command Delimiter" to ;
70 PowerAMC
TrgHeader
Script d'en-tête pour la génération des triggers et procédures.
Exemple Dans Oracle 8 :
(2) Select the item "Options" of the menu "Command"
Integrity package declaration
create or replace package IntegrityPackage AS
procedure InitNestLevel;
function GetNestLevel return number;
procedure NextNestLevel;
procedure PreviousNestLevel;
end IntegrityPackage;
/
-- Integrity package definition
create or replace package body IntegrityPackage AS
NestLevel number;
-- Procedure to initialize the trigger nest level

procedure InitNestLevel is
begin
NestLevel := 0;
end;
-- Function to return the trigger nest level

function GetNestLevel return number is
begin
if NestLevel is null then
NestLevel := 0;
end if;
return(NestLevel);
end;
-- Procedure to increase the trigger nest level

procedure NextNestLevel is
begin
if NestLevel is null then
NestLevel := 0;
end if;
NestLevel := NestLevel + 1;
end;
-- Procedure to decrease the trigger nest level

procedure PreviousNestLevel is
begin
NestLevel := NestLevel - 1;
end;
end IntegrityPackage;

Catégorie SQL
TrgFooter
Texte de fin pour un script (génération de triggers et de procédures).
AlterHeader
Texte d'en-tête pour un script (modification de base de données).
AlterFooter
Texte de fin pour un script (modification de base de données).
Keywords
La catégorie Keywords contient des mots clés et des valeurs qui sont
réservées pour des tâches spéciales et qui ne peuvent pas être utilisées
comme noms ou valeurs de variable.
ReservedWord
Mots réservés.
Si un mot réservé est utilisé comme code d'objet, il est placé entre
apostrophes lors de la génération (en utilisant les apostrophes spécifiés dans
SGBD→ Script → SQL → Syntax → Quote)
Exemple Dans Adaptive Server Anywhere 6 :
TABLE
CREATE
DELETE
WHENEVER
ReservedDefault
Valeurs par défaut réservées.
Si un mot réservé est saisi dans une valeur par défaut, la valeur ne sera pas
placée entre apostrophes, elle sera utilisée comme valeur par défaut pour les
colonnes.
Exemple Dans Adaptive Server Anywhere 6, USER est une valeur par défaut réservée:
Create table CUSTOMER (
Username varchar(30) default USER,
)
72 PowerAMC
GroupFunc
Liste de fonctions SQL à utiliser avec des mots clés de regroupement.
Utilisé dans l'éditeur SQL (views) pour proposer une liste de fonctions
disponibles afin d'aider la saisie de code SQL. Ces fonctions sont les mêmes
que celles disponibles dans le SGBD.
Exemple avg()
count()
max()
min()
NumberFunc
Liste de fonctions SQL à utiliser sur les nombres.
Exemple abs()
acos()
asin()
atan()
CharFunc
Liste de fonctions SQL pour les caractères et les chaînes.
Exemple ascii()
char()
charindex()
char_length()
difference()
lower()
DateFunc
Liste de fonctions SQL pour les dates.

Catégorie SQL
Exemple dateadd()
datediff()
datename()
ConvertFunc
Liste de fonctions SQL à utiliser pour convertir des valeurs entre hex et
integer et pour gérer les chaînes.
Exemples convert()
hextoint()
inttohex()
OtherFunc
Liste de fonctions SQL pour l'estimation, la concaténation et les vérifications
SQL.
Exemple db_id()
db_name()
host_id()
ListOperators
Liste d'opérateurs SQL.
Exemple =
!=
not like
not in
Commit
Instruction de validation de la transaction par ODBC.
74 PowerAMC
Catégorie Objects
La catégorie Objects définit chaque type d'objet qui est pris en charge par la
définition de SGBD.
A la racine de la catégorie Objects, les deux entrées suivantes sont définies
pour tous les objets du SGBD :
♦ EnableOption : Valeur booléenne qui spécifie si les options physiques
sont admises pour les objets de SGBD
♦ MaxConstLen : Définit la valeur pour la longueur de nom de contrainte
pour les tables, les colonnes, les clés primaires et les clés étrangères
Entrées communes aux différents objets

Les entrées suivantes sont communes à de nombreux objets dans la définition
de SGBD :
Enable
Instruction permettant déterminer si un objet est admis.
Exemple Enable = Yes
Maxlen
Instruction permettant de définir la longueur maximale de code pour un objet.
Cette valeur est mise en oeuvre lors de la vérification de modèle et produit
une erreur si le code dépasse la valeur définie. Le code d'objet est également
tronqué au moment de la génération.
Exemple MaxLen = 128
Create
Instruction permettant de créer un objet (génération et reverse engineering).
Exemple create table %TABLE%

Catégorie Objects
Add
Instruction permettant d'ajouter un objet dans l'instruction de création d'un
autre objet (génération et reverse engineering).
Par exemple, Table create avec l'appel Column add.
Drop
Instruction permettant de supprimer un objet (génération uniquement).
Exemple Dans Sybase Adaptive Server Anywhere 6 :
if exists(select 1 from sys.systable where
table_name='%TABLE%' and table_type='BASE'[%QUALIFIER%?
and creator=user_id('%OWNER%')]) then
drop table [%QUALIFIER%]%TABLE%
end if
BeforeCreate, BeforeDrop, BeforeModify

Instructions étendues exécutées avant les principales instructions Create,
Drop ou Modify.
Pour plus d'informations sur les instructions étendues, reportez-vous à
la section Génération de script.
AfterCreate, AfterDrop, AfterModify

Instructions étendues exécutées après les principales instructions Create,
Drop ou Modify.
Pour plus d'informations sur les instructions étendues, reportez-vous à
la section Génération de script.
Options
Options physiques portant sur la création d'un objet (génération et reverse
engineering).
in %s : category=tablespace
76 PowerAMC
DefOptions
Valeurs par défaut pour les options physiques d'objet qui seront appliquées à
tous les objets. Ces valeurs doivent respecter la syntaxe SQL.
Par exemple :
in default_tablespace
SqlListQuery
Requête SQL permettant de répertorier les objets dans une boîte de dialogue
de reverse engineering.
La requête est exécutée pour renseigner les variables d'en-tête et créer des
objets en mémoire.
Exemple {OWNER, TABLE, COLUMN, DTTPCODE, LENGTH, SIZE, PREC,
NOTNULL (N='NOT NULL', *=NULL), DEFAULT, COMMENT}
[%ISODBCUSER% ?
SELECT '%SCHEMA%', C.TABLE_NAME, C.COLUMN_NAME,
C.DATA_TYPE, C.DATA_PRECISION, C.DATA_LENGTH,
C.DATA_SCALE, C.NULLABLE, C.DATA_DEFAULT, M.COMMENTS
FROM SYS.USER_COL_COMMENTS M, SYS.USER_TAB_COLUMNS C
WHERE M.TABLE_NAME = C.TABLE_NAME AND M.COLUMN_NAME =
C.COLUMN_NAME
[AND C.TABLE_NAME='%TABLE%']
ORDER BY C.TABLE_NAME, C.COLUMN_ID
:
SELECT C.OWNER, C.TABLE_NAME, C.COLUMN_NAME,
C.DATA_SCALE, C.NULLABLE, C.DATA_DEFAULT, M.COMMENTS
FROM SYS.ALL_COL_COMMENTS M, SYS.ALL_TAB_COLUMNS C
WHERE M.OWNER = C.OWNER AND M.TABLE_NAME = C.TABLE_NAME
AND M.COLUMN_NAME = C.COLUMN_NAME
[AND C.OWNER='%SCHEMA%'] [AND
C.TABLE_NAME='%TABLE%']
ORDER BY C.OWNER, C.TABLE_NAME, C.COLUMN_ID
]

Catégorie Objects
SqlAttrQuery
Requête SQL permettant d'extraire des information supplémentaires sur les
objets récupérés via reverse engineering par SQLListQuery.
{OWNER, TABLE, COMMENT}
[%ISODBCUSER% ?
SELECT '%SCHEMA%', TABLE_NAME, COMMENTS
FROM SYS.USER_TAB_COMMENTS
WHERE COMMENTS IS NOT NULL [AND TABLE_NAME='%TABLE%']
ORDER BY TABLE_NAME
:
SELECT OWNER, TABLE_NAME, COMMENTS
FROM SYS.ALL_TAB_COMMENTS
WHERE COMMENTS IS NOT NULL [AND OWNER='%SCHEMA%'] [AND
TABLE_NAME='%TABLE%']
ORDER BY OWNER, TABLE_NAME
]
Voir aussi SqlListQuery.
SqlOptsQuery
Requête SQL permettant d'extraire les options physiques d'objet sur les objets
récupérés via reverse engineering par SqlListQuery.
Le résultat de la requête va renseigner la variable %OPTIONS% et doit
respecter la syntaxe SQL.
{OWNER, TABLE, OPTIONS}
select su.USER_NAME, st.TABLE_NAME, 'in '+ dbspace_name
from SYS.SYSUSERPERMS su, SYS.SYSTABLE st, SYS.SYSFILE
sf
where
st.file_id = sf.file_id and dbspace_name <> 'SYSTEM' and
[%TABLE% ? TABLE_NAME = '%TABLE%' and] [%SCHEMA% ?
su.USER_NAME = '%SCHEMA%' and]
st.CREATOR = su.USER_ID
Voir aussi SqlListQuery.
SqlFragQuery
Pour plus d'informations, reportez-vous à la section Mécanisme
d'extension pour les requêtes de reverse engineering ODBC.
78 PowerAMC
ModifiableAttributes
Liste des attributs étendus qui seront pris en compte dans la boîte de dialogue
de fusion lors de la synchronisation de base de données.
Pour plus d'informations, reportez-vous à la section Génération de
script.
Exemple Dans Sybase ASE 12.5
ExtTablePartition
ReversedStatements
Liste des instructions qui vont faire l'objet d'un reverse engineering.
Pour plus d'informations, reportez-vous à la section Reverse
engineering de script.
Exemple Dans Sybase ASE 12.5 :
CreatePartition
Table
La catégorie Table contient des entrées qui définissent des paramètres
associés à la table.
Entrées communes pour Table

Vous pouvez définir des valeurs pour les entrées communes suivantes pour
l'objet Table dans la définition de SGBD :
Entrée Exemple
Enable Dans Sybase Adaptive Server Anywhere 6 :
Enable = Yes
Maxlen Dans Sybase Adaptive Server Anywhere 6 :
Maxlen = 128
Create Dans Sybase Adaptive Server Anywhere 6 :
create table [%QUALIFIER%]%TABLE%
(
%TABLDEFN%
)
[%OPTIONS%]

Catégorie Objects
Entrée Exemple
Drop Dans Sybase Adaptive Server Enterprise 11 :
if exists (select 1
from sysobjects
where id = object_id('[%QUALIFIER%]%TABLE%')
and type = 'U')
drop table [%QUALIFIER%]%TABLE%
Options Dans Sybase Adaptive Server Enterprise 11 :
with max_rows_per_page = %d : default=0
DefOptions Cette entrée est fréquemment vide. Elle définit les options
qui sont appliquées à toutes les tables, par exemple
with_max_row_per_page = 128
SqlListQuery Dans Oracle 7 :

{OWNER, TABLE}
select
owner,
table_name
from
sys.all_tables
where 1=1
[and owner='%SCHEMA%']
[and table_name='%TABLE%']
order by
owner,
table_name
SqlAttrQuery Dans Oracle 7 :
{OWNER, TABLE, COMMENT}
select
owner,
table_name,
comments
from
sys.all_tab_comments
where
comments is not null
[and owner='%SCHEMA%']
[and table_name='%TABLE%']
SqlOptsQuery Dans Sybase Adaptive Server Anywhere 6 :
{OWNER, TABLE, OPTIONS}
select su.USER_NAME, st.TABLE_NAME, 'in '+
dbspace_name
from SYS.SYSUSERPERMS su, SYS.SYSTABLE st,
SYS.SYSFILE sf
where
st.file_id = sf.file_id and dbspace_name <> 'SYSTEM'
and
[%TABLE% ? TABLE_NAME = '%TABLE%' and]
[%SCHEMA% ? su.USER_NAME = '%SCHEMA%'
and]
st.CREATOR = su.USER_ID
80 PowerAMC
Entrée Exemple
SqlFragQuery Dans Oracle 9I :
{VAR1NAME, VAR1VALUE}
select
'HighVal'||tp.partition_position,
tp.high_value
from
all_tab_partitions tp
where 1=1
[ and tp.table_owner=%.q:OWNER% ]
[ and tp.table_name=%.q:TABLE%]
ModifiableAttributes Liste des attributs étendus qui seront pris en compte dans
la boîte de dialogue de fusion lors de la synchronisation
de base de données
ReversedStatements Liste des instructions qui vont faire l'objet d'un reverse
engineering
Pour obtenir une description de chacune des entrées communes aux

objets, reportez-vous à la section Entrées communes aux différents objets.
Variable par défaut Dans une colonne, si la variable par défaut est de type texte ou chaîne, la
requête doit extraire la valeur de la variable par défaut entre apostrophes. La
plupart des SGBD ajoutent ces apostrophes à la valeur de la variable par
défaut. Si le SGBD que vous utilisez n'ajoute pas les apostrophes
automatiquement, vous devez les spécifier dans les différentes requêtes à
l'aide de la variable par défaut.
Par exemple, dans IBM DB2 UDB 8 pour OS/390, la ligne suivante a été
ajoutée dans SqlListQuery afin d'ajouter des apostrophes à la valeur de la
variable par défaut :
...
case(default) when '1' then '''' concat defaultvalue concat '''' when '5'
then '''' concat defaultvalue concat '''' else defaultvalue end,
...

Catégorie Objects
Permission
Permissions disponibles pour les tables. La première colonne affiche le nom
SQL de la permission (SELECT, par exemple). La seconde colonne est le
nom abrégé qui s'affiche dans le titre des colonnes de grille.
SELECT / Sel
INSER / Ins
DELETE / Del
UPDATE / Upd
REFERENCES / Ref
ConstName
Template de nom de contrainte pour un paramètre de vérification de table.
Utilisé dans la feuille de propriétés de table pour renseigner le nom de
contrainte.
CKT_%.U26:TABLE%
TableComment
Instruction permettant d'ajouter un commentaire de table. Le commentaire de
table est une instruction SQL qui n'est pas prise en charge par tous les SGBD.
Si TableComment est vide, la case Commentaire dans la page Tables &
vues de la boîte de dialogue de génération est grisée et non disponible.
Utilisé pour la génération et pour les reverse engineering.
Exemple Dans Sybase SQL Anywhere 5.5 :
TableComment = comment on table %OWNERPREFIX%%TABLE% is
'%COMMENT%'
La variable %TABLE% est le nom de la table défini dans la boîte de
dialogue Liste des tables, ou dans la feuille de propriétés de la table. La
variable %COMMENT% est le commentaire défini dans la zone
Commentaire de la feuille de propriétés de la table.
82 PowerAMC
Rename
Instruction permettant de renommer une table. Si Rename est vide, le
processus de modification de base de données supprime les contraintes de clé
étrangère, crée une nouvelle table avec le nouveau nom, insère les lignes de
l'ancienne table dans la nouvelle table, et crée les index et contraintes sur la
nouvelle table à l'aide de tables temporaires.
Utilisé dans le script de modification de base de données lorsqu'une table a
été renommée.
Exemple Dans Sybase Adaptive Server Enterprise 11 :
sp_rename %OLDTABL%, %NEWTABL%
La variable %OLDTABL% est le code de la table avant qu'elle ne soit
renommée. La variable %NEWTABL% est le nouveau code de la table.
AlterTableHeader
En-tête de l'instruction alter table. Tout ce qui est ajouté dans cette
entrée est ajouté avant l'instruction alter table. Vous pouvez placer un
en-tête alter table dans vos scripts pour les documenter ou dans le cadre d'une
logique d'initialisation.
Exemple AlterTableHeader = /* Table name: %TABLE% */
AlterTableFooter
Fin de Alter table. Tout ce qui est ajouté dans cette entrée est ajouté après
l'instruction alter table et avant le caractère de fin.
Exemple AlterTableFooter = /* End of alter statement */
DefineTableCheck
Instruction permettant de personnaliser le script de contraintes de table
(vérifications) au sein d'une instruction create table.
Exemple check (%CONSTRAINT%)
AddTableCheck
Instruction permettant de personnaliser le script pour modifier les contraintes
de table au sein d'une instruction alter table.
Exemple add check (%CONSTRAINT%)

Catégorie Objects
DropTableCheck
Instruction permettant de supprimer une vérification de table dans une
instruction alter table.
Exemple delete check
SqlChckQuery
Requête SQL permettant de procéder au reverse engineering de vérifications
de table.
{OWNER, TABLE, CONSTRAINT}
SELECT U.USER_NAME, T.TABLE_NAME, T.VIEW_DEF
FROM SYSUSERPERMS U, SYSTABLE T
WHERE [U.USER_NAME = '%OWNER%' AND] [T.TABLE_NAME =
'%TABLE%' AND]
T.CREATOR = U.USER_ID AND T.TABLE_TYPE = 'BASE' AND
T.VIEW_DEF IS NOT NULL
SqlPermQuery
Requête SQL permettant de procéder au reverse engineering de permissions
accordées sur des tables.
Exemple Dans Sybase Adaptive Server Enterprise 12.5 :
{ select u1.name grantee,
case
when (s.action = 193) then 'SELECT'
when (s.action = 195) then 'INSERT'
when (s.action = 196) then 'DELETE'
when (s.action = 197) then 'UPDATE'
end +
case
when (s.protecttype = 0) then '+'
when (s.protecttype = 1) then ''
when (s.protecttype = 2) then '-'
end
|| ','
from sysprotects s, sysusers u, sysusers u1, sysobjects
o
where
o.name = %.q:TABLE% and
o.uid = u.uid and
s.id = o.id and
u1.uid = s.uid
84 PowerAMC
SqlListRefrTables
Requête SQL utilisée pour répertorier les tables référencées par une table.
Exemple Dans Oracle 9i :
{OWNER, TABLE, POWNER, PARENT}
select
c.owner,
c.table_name,
r.owner,
r.table_name
from
sys.all_constraints c,
sys.all_constraints r
where
(c.constraint_type = 'R' and c.r_constraint_name =
r.constraint_name and c.r_owner = r.owner)
[ and c.owner = %.q:SCHEMA%]
[ and c.table_name = %.q:TABLE%]
union select
c.owner,
c.table_name,
r.owner,
r.table_name
from
sys.all_constraints c,
sys.all_constraints r
where
(r.constraint_type = 'R' and r.r_constraint_name =
c.constraint_name and r.r_owner = c.owner)
[ and c.owner = %.q:SCHEMA%]
[ and c.table_name = %.q:TABLE%]
order by 1, 2, 3, 4
UniqConstraintName
Interdit l'utilisation du même nom pour un index et une contrainte sur une
même table.
Valeur Résultat
Yes Le nom de contrainte et le nom d'index de la table doivent être
différents. Pris en compte pendant la vérification du modèle
No Le nom de contrainte et le nom d'index de la table peuvent être
identiques

Catégorie Objects
Header
En-tête de table. Tout ce qui est ajouté dans cette entrée est ajouté avant
l'instruction create table.
Footer
Table footer. Tout ce qui est ajouté dans cette entrée est ajouté après
l'instruction create table.
AllowedADT
Liste de types de données abstraits sur lesquels une table peut être basée.
Vous pouvez affecter des types de données abstraits objet aux tables. La table
utilise les propriétés du type de données abstrait et les attributs du type de
données abstrait deviennent des colonnes de la table.
Cette liste de types de données abstraits s'affiche dans la liste déroulante Basé
sur dans la feuille de propriétés de la table.
Exemple Dans Oracle 8I2 :
OBJECT
Dans DB2 UDB 5.x :
STRUCTURED
MaxConstLen
Instruction permettant de définir la longueur maximale de nom de contrainte
prise en charge par la base de données cible. Cette valeur est mise en oeuvre
dans la vérification de modèle et produit une erreur si le code dépasse la
valeur définie. Le nom de contrainte est également tronqué au moment de la
génération.
Longueur maximale pour les noms de contrainte :

PowerAMC a une longueur maximale de 254 caractères pour les noms de
contrainte. Si votre base de données prend en charge des noms de
contrainte plus longs, vous devez définir les noms de contrainte de sorte
qu'ils se conforment à la limite de 254 caractères.
Exemple MaxConstLen = 128
86 PowerAMC
Column
La catégorie Column contient des entrées qui définissent les paramètres
relatifs aux colonnes.
Entrées communes pour Column

l'objet Column dans la définition de SGBD.
Entrée Exemple (Sybase Adaptive Server Enterprise 11)

Enable Enable = Yes
Maxlen Maxlen = 30
Create alter table [%QUALIFIER%]%TABLE%
add %20:COLUMN% %30:DATATYPE%
[default %DEFAULT%]
[%IDENTITY%?identity:%NULL%]
[[constraint %CONSTNAME%] check (%CONSTRAINT%)]
Add %20:COLUMN% %30:DATATYPE% [default %DEFAULT%]

[%IDENTITY%?identity:[%NULL%][%NOTNULL%]]
[[constraint %CONSTNAME%] check (%CONSTRAINT%)]
Drop Dans Sybase Adaptive Server Anywhere 6 :

delete %COLUMN%
DefOptions Cette entrée est souvent vide. Elle définit des options qui sont
appliquées aux colonnes

Catégorie Objects

SqlListQuery Dans Oracle 8I2 :
{OWNER, TABLE, COLUMN, DTTPCODE, LENGTH, SIZE,
PREC, NOTNULL (N='NOT NULL', *=NULL), DEFAULT,
COMMENT}
[%ISODBCUSER% ?
SELECT '%SCHEMA%', C.TABLE_NAME,
C.COLUMN_NAME, C.DATA_TYPE, C.DATA_PRECISION,
C.DATA_LENGTH, C.DATA_SCALE, C.NULLABLE,
C.DATA_DEFAULT, M.COMMENTS
FROM SYS.USER_COL_COMMENTS M,
SYS.USER_TAB_COLUMNS C
WHERE M.TABLE_NAME = C.TABLE_NAME AND
M.COLUMN_NAME = C.COLUMN_NAME
[AND C.TABLE_NAME='%TABLE%']
ORDER BY C.TABLE_NAME, C.COLUMN_ID
:
SELECT C.OWNER, C.TABLE_NAME, C.COLUMN_NAME,
C.DATA_SCALE, C.NULLABLE, C.DATA_DEFAULT,
M.COMMENTS
FROM SYS.ALL_COL_COMMENTS M,
SYS.ALL_TAB_COLUMNS C
WHERE M.OWNER = C.OWNER AND M.TABLE_NAME =
C.TABLE_NAME AND M.COLUMN_NAME =
C.COLUMN_NAME
[AND C.OWNER='%SCHEMA%'] [AND
C.TABLE_NAME='%TABLE%']
ORDER BY C.OWNER, C.TABLE_NAME, C.COLUMN_ID
SqlAttrQuery Dans Oracle 7 :

{OWNER, TABLE, COLUMN, COMMENT}
select
c.owner,
c.table_name,
c.column_name,
m.comments
from
sys.all_col_comments m,
sys.all_tab_columns c
where
m.owner=c.owner
and m.table_name=c.table_name
and m.column_name=c.column_name
[and c.owner='%SCHEMA%']
[and c.table_name='%TABLE%']
[and c.column_name='%COLUMN%']
SqlOptsQuer —
y
SqlFragQuer —
y
88 PowerAMC

Options Dans DB2 UDB 6.x common server :
<logged> %s : list=logged|not logged, default=logged
<compact> %s : list=compact|not compact, default=not
compact
linktype url : composite=yes
{
no link control
file link control : composite=yes
{
mode db2options
integrity %s : default=all
read permission %s : list=fs|db, default=fs
write permission %s : list=fs|blocked, default=fs
recovery %s : list=yes|no, default=no
on unlink %s : list=restore|delete, default=restore
}
}
ModifiableAt Liste des attributs étendus qui seront pris en compte dans la boîte
tributes de dialogue de fusion lors de la synchronisation de base de
données
ReversedStat Liste des instructions qui vont faire l'objet d'un reverse
ements engineering

Permission
Permissions disponibles pour les colonnes. La première colonne affiche le
nom SQL de la permission (SELECT, par exemple). La seconde colonne est
le nom abrégé qui s'affiche dans le titre des colonnes de grille.
Exemple Dans Sybase ASA 8 :
REFERENCES / References
SELECT / Select
UPDATE / Update

Catégorie Objects
AltEnableAddColnChk
Indique si une contrainte de vérification de colonne, construite à partir des
paramètres de contrôle de la colonne, peut ou non être ajoutée dans une table
à l'aide de l'instruction alter table.
Valeur Résultat
Yes AddColnChck peut être utilisé pour modifier la contrainte de
vérification de colonne dans une instruction alter table
No Le processus de modification de la base de données procède comme
suit :
Supprime les contraintes de clé étrangère
Crée une table temporaire avec la même structure et les mêmes
colonnes que la table avant l'ajout de la contrainte de vérification de
colonne
Insère la ligne depuis l'ancienne table dans la nouvelle table temporaire
Supprime la table actuelle
Crée une nouvelle table avec la nouvelle contrainte de vérification de
colonne
Insère la ligne depuis la table temporaire dans la nouvelle table
Crée les index et contraintes sur la nouvelle table
Exemple AltEnableAddColnChk = NO
Voir aussi AddColnChck.
CheckNull
Vérifie si une colonne peut être NULL.
Valeur Résultat
Yes La vérification de modèle vérifie si les colonnes peuvent être NULL
No Aucune vérification sur la valeur NULL pour les colonnes
90 PowerAMC
EnableBindRule
Permet ou interdit la liaison d'une règle de gestion à une colonne pour les
paramètres de vérification.
Valeur Résultat
Yes Les entrées Create et Bind sont générées pour l'objet Rule
No La vérification est générée dans la commande Add de colonne
Exemple EnableBindRule = No
EnableComputedColn
Instruction permettant l'utilisation de colonnes calculées.
Valeur Résultat
Yes Colonnes calculées admises
No Colonnes calculées non admises
EnableDefault
Permet d'utiliser des valeurs prédéfinies.
Valeur Résultat
Yes La valeur par défaut est générée pour les colonnes lorsque la valeur par
défaut est définie. La valeur par défaut peut être définie dans les
paramètres de contrôle pour chaque colonne. La variable
%DEFAULT% contiendra la valeur par défaut
La case Valeur par défaut pour les colonnes doit être cochée dans la
page Tables & vues de la boîte de dialogue de génération
No La case Valeur par défaut pour les colonnes est grisée dans la page
Tables & vues de la boîte de dialogue de génération. La valeur par
défaut ne peut pas être générée

Catégorie Objects
Exemple Dans SQL Anywhere 5.5 :

EnableDefault = YES
La valeur par défaut pour la colonne employee EMPFUNC est Technical
Engineer, le script généré est le suivant :
create table EMPLOYEE
(
EMPNUM numeric(5) not null,
EMP_EMPNUM numeric(5) ,
DIVNUM numeric(5) not null,
EMPFNAM char(30) ,
EMPLNAM char(30) not null,
EMPFUNC char(30)
default 'Technical Engineer',
EMPSAL numeric(8,2) ,
primary key (EMPNUM)
);
EnableIdentity
Prise en charge de l'entrée de mot clé Identity. Les colonnes Identity sont des
compteurs séquentiels gérés par la base de données (par exemple, Sybase et
Microsoft SQL Server).
Valeur Résultat
Yes Active la case à cocher Identity dans la feuille de propriétés de la
colonne
No La case à cocher Identity ne s'affiche pas dans la feuille de propriétés de
la colonne
Lorsque la case Identity est cochée, le mot clé Identity est généré dans le
script après le type de données de la colonne. Une colonne Identity ne peut
pas être NULL : lorsque vous cochez la case Identity, la case Obligatoire est
automatiquement cochée.
92 PowerAMC
PowerAMC s'assure que :

♦ Une seule colonne Identity peut être définie par table : lorsque Identity
est défini pour une colonne, les autres colonnes de la table ont leur case à
cocher Identity grisée et non disponible
♦ Une clé étrangère ne peut pas être une colonne Identity : la case à cocher
est grisée et non disponible
♦ Identity n'est pris en charge que pour certains types de données : lorsque
la case Identity est cochée pour une colonne dont le type de données
n'est pas compatible avec Identity, le type de données est
automatiquement changé en numeric. Lorsque le type de données d'une
colonne Identity est remplacé par un type de données qui ne
correspondant à Identity, PowerAMC affiche un message d'erreur.

EnableIdentity=YES
La colonne employee number est une colonne Identity, le script suivant est
généré :
create table EMPLOYEE
(
EMPNUM numeric(5) identity,
EMP_EMPNUM numeric(5) null ,
DIVNUM numeric(5) not null,
EMPFNAM char(30) null ,
EMPLNAM char(30) not null,
EMPFUNC char(30) null ,
EMPSAL numeric(8,2) null ,
constraint PK_EMPLOYEE primary key (EMPNUM)
)
go
Changement du contenu de IDENTITY

Lors de la génération, la variable Identity contient "identity", mais vous
pouvez facilement changer le mot clé Identity à l'aide de la syntaxe
suivante lorsque cela est nécessaire :
[%IDENTITY%?new identity keyword]

Catégorie Objects
EnableNull
Permet l'utilisation du mot clé NULL.
Base de données
Valeur cible Résultat
Yes Supports NULL Les colonnes non signalées comme
keyword Obligatoire dans le MPD sont générées avec
le mot clé NULL après le type de données
No Does not support Les colonnes non signalées comme
NULL keyword Obligatoire dans le MPD sont générées sans
le mot clé NULL après le type de données

EnableNull = YES
CUSACT, CUSTEL, CUSFAX ne sont pas des colonnes obligatoires, le
mot clé null est défini en regard de la colonne dans le script create
table.
(
CUSACT char(80) null ,
CUSTEL char(12) null ,
CUSFAX char(12) null ,
constraint PK_CUSTOMER primary key (CUSNUM)
)
go
Si
EnableNull = NO
Le script SQL se présente comme suit :
(
CUSACT char(80) ,
CUSTEL char(12) ,
CUSFAX char(12) ,
constraint PK_CUSTOMER primary key (CUSNUM)
)
go
94 PowerAMC
EnableNotNullWithDflt
Instruction permettant d'utiliser Not null with default.
Valeur Résultat
Yes Lorsque vous activez With Default dans la feuille de propriétés d'une
colonne, une valeur par défaut est affectée à une colonne lorsqu'une
valeur Null est insérée
No L'option With Default dans une feuille de propriétés de colonne est
cachée
Exemple Dans IBM DB2 :

EnableNotNullWithDflt = YES
Bind
Instruction permettant de lier une règle à une colonne.
sp_bindrule %RULE%, %TABLE%.%COLUMN%
AddColnChck
Instruction permettant de personnaliser le script pour modifier des contraintes
de colonne au sein d'une instruction alter table.
modify (%COLUMN% %DATATYPE% constraint %CONSTNAME%
check (%CONSTRAINT%));
ConstName
Template de nom de contrainte pour un paramètre de contrôle de colonne.
Utilisé dans les feuilles de propriétés de colonne pour renseigner les noms de
contrainte.
Exemple CKC_%.U17:COLUMN%_%.U8:TABLE%

Catégorie Objects
ColumnComment
Instruction permettant d'ajouter un commentaire à une colonne.
Utilisé pour la génération et pour le reverse engineering.
Exemple comment on column [%QUALIFIER%]%TABLE%.%COLUMN% is
%.q:COMMENT%
DefineColnCheck
Instruction permettant de personnaliser le script des contraintes de colonne
(vérifications) au sein d'une instruction create table. Cette instruction
est appelée si les instructions create, add, ou alter contiennent
%CONSTDEFN%.
Exemple [constraint %CONSTNAME%] check (%CONSTRAINT%)
DropColnChck
Instruction permettant de supprimer une vérification de colonne dans une
instruction alter table. Cette instruction est utilisée dans le script de
modification de base de données lorsque les paramètres de contrôle ont été
supprimés d'une colonne.
Si DropColnChck est vide, la procédure de modification d'une base de
données :
♦ Supprime les contraintes de clé étrangère
♦ Crée une table temporaire avec la même structure et les mêmes colonnes
que la table avant la suppression du paramètre de contrôle
♦ Insère les lignes depuis l'ancienne table dans la nouvelle table temporaire
♦ Supprime la table actuelle
♦ Crée une nouvelle table sans paramètre de contrôle sur la colonne
modifiée
♦ Insère les lignes depuis la table temporaire dans la nouvelle table
♦ Crée les index et contraintes sur la nouvelle table
96 PowerAMC

DropColnChck = alter table [%QUALIFIER%]%TABLE%
modify %COLUMN% check null
La variable %COLUMN% est le nom de la colonne défini dans la liste des
colonnes d'une table.
DropColnComp
Instruction permettant de supprimer une expression calculée de colonne dans
une instruction alter table.
alter %COLUMN% drop compute
ModifyColumn
Instruction permettant de modifier une colonne. Ce paramètre est utilisé dans
le script de modification de base de données lorsque la définition de la
colonne a été modifiée. L'instruction ModifyColumn définie dans ce
paramètre est une instruction SQL spécifique différente de l'instruction
alter table. Non pris en charge par tous les SGBD.
modify %COLUMN% %DATATYPE% %NOTNULL%
ModifyColnDflt
Instruction permettant de modifier une valeur par défaut de colonne dans une
instruction alter table. Ce paramètre est utilisé dans le script de modification
de base de données, lorsque la valeur par défaut d'une colonne a été modifiée
dans la table.
Si ModifyColnDflt est vide, le processus de modification de base de
données :
que la table avant la modification de la valeur par défaut

Catégorie Objects
♦ Crée une nouvelle table avec la nouvelle valeur par défaut pour la
colonne modifiée
♦ Créer les index et les contraintes sur la nouvelle table

ModifyColnDflt = alter table [%QUALIFIER%]%TABLE%
modify %COLUMN% default %DEFAULT%
La variable %COLUMN% est le nom de la colonne défini dans la feuille de

propriétés de la table. La variable %DEFAULT% est la nouvelle valeur par
défaut de la colonne modifiée.
AddColnChck
Instruction permettant de modifier une vérification de colonne dans une
instruction alter table. Cette instruction est utilisée dans un script de
modification de base de données lorsque les paramètres de contrôle d'une
colonne ont été modifiés dans la table.
AltEnableAddColnChk doit être défini à YES pour permettre
l'utilisation de cette instruction.
Si AddColnChck est vide, le processus de modification de base de
données :
que la table avant modification des paramètres de contrôle
♦ Crée une nouvelle table avec les paramètres de contrôle pour la colonne
♦ Crée les index et les contraintes sur la nouvelle table

AddColnChck = alter table [%QUALIFIER%]%TABLE%
modify %COLUMN% [default %DEFAULT%]
[check (%CONSTRAINT%)]
La variable %COLUMN% est le nom de la colonne définie dans la feuille de

propriétés de la table. La variable % CONSTRAINT % est la contrainte de
vérification construite à partir du nouveau paramètre de contrôle.
98 PowerAMC
Voir aussi AltEnableAddColnChk.
ModifyColnNull
Instruction permettant de modifier l'état null/not null d'une colonne dans une
instruction alter table.
modify %COLUMN% %NOTNULL%
ModifyColnComp
Instruction permettant de modifier une expression calculée pour une colonne
dans une instruction alter table.
alter %COLUMN% set compute (%COMPUTE%)
MaxConstLen
génération.

Rename
Instruction permettant de renommer une colonne dans une instruction alter
table.
Exemple alter table [%QUALIFIER%]%TABLE%
rename %OLDCOLUMN% to %NEWCOLUMN%

Catégorie Objects
SqlChckQuery
Requête SQL permettant de procéder au reverse engineering de paramètres
de contrôle d'une colonne.
Le résultat doit être conforme à la syntaxe SQL appropriée.
{OWNER, TABLE, COLUMN, CONSTRAINT}
SELECT SU.USER_NAME, ST.TABLE_NAME, SC.COLUMN_NAME,
SC."CHECK"
FROM SYSUSERPERMS SU, SYSTABLE ST, SYSCOLUMN SC
WHERE [SU.USER_NAME='%OWNER%' AND]
[ST.TABLE_NAME='%TABLE%' AND]
ST.CREATOR=SU.USER_ID AND SC.TABLE_ID=ST.TABLE_ID AND
SC."CHECK" IS NOT NULL
ORDER BY SU.USER_NAME, ST.TABLE_ID
SqlPermQuery
d'objet.
Le résultat doit être conforme à la syntaxe SQL appropriée.
{ GRANTEE, GRANTOR, PERMISSION}
select
u1.user_name grantee, u.user_name grantor,
case
when (p.privilege_type = 1 and p.is_grantable ='Y' )
then 'SELECT+'
when (p.privilege_type = 1) then 'SELECT'
then 'UPDATE+'
when (p.privilege_type = 8) then 'UPDATE'
then 'REFERENCES+'
when (p.privilege_type = 16) then 'REFERENCES'
end
permission
from sysuserperm u, sysuserperm u1, syscolumn s,
syscolperm p, systable t
where
(t.table_name = %.q:TABLE%) and
(t.table_id = p.table_id) and
(s.column_name = %.q:COLUMN% ) and
(s.table_id = t.table_id) and
(u1.user_id = p.grantee) and
(u.user_id = p.grantor)
100 PowerAMC
Unbind
Instruction permettant de faire en sorte qu'une règle ne soit plus liée à une
colonne.
sp_unbindrule %TABLE%.%COLUMN%, %RULE%
Index
La catégorie Index contient des entrées définissant les paramètres associés à
un index.
Entrées communes pour Index

Vous pouvez définir des valeurs pour les entrées courantes suivantes pour
l'objet Index object dans la définition de SGBD.
Entrée Exemple
Enable Enable = Yes
Maxlen Maxlen = 128
Create Dans Sybase ASA 8 :
create [%UNIQUE%] index %INDEX% on
[%QUALIFIER%]%TABLE% (
%CIDXLIST%
)
[%OPTIONS%]
Drop if exists(select 1 from sys.sysindex I, sys.systable T

where I.table_id=T.table_id and
I.index_name='%INDEX%' and
T.table_name='%TABLE%') then
drop index [%QUALIFIER%]%TABLE%.%INDEX%
end if
Options in %s : category=tablespace
DefOptions in %s : category=tablespace
SqlListQuery —
SqlAttrQuery —

Catégorie Objects
Entrée Exemple
SqlOptsQuery Dans Sybase ASA 8 :
{OWNER, TABLE, INDEX, OPTIONS}
select
u.user_name,
t.table_name,
i.index_name,
'in '+ f.dbspace_name
from
sys.sysuserperms u
join sys.systable t on (t.creator=u.user_id)
join sys.sysindex i on (i.table_id=t.table_id)
join sys.sysfile f on (f.file_id=i.file_id)
where i."unique" in ('Y', 'N')
[ and t.table_name=%.q:TABLE%]
[ and u.user_name=%.q:OWNER%]
SqlFragQuery Dans Oracle 9I :

{VAR1NAME, VAR1VALUE}
select
'HighVal'||ip.partition_position,
ip.high_value
from
all_ind_partitions ip
where 1=1
[ and ip.index_owner=%.q:OWNER%]
[ and ip.index_name=%.q:INDEX%]
de base de données
engineering

102 PowerAMC
EnableAscDesc
Mots clés ASC et DESC admis sur une définition d'index. Vous pouvez
indiquer un ordre ascendant ou descendant en sélectionnant la valeur
correspondante dans la liste déroulante Tri de la page Colonnes d'une feuille
de propriétés d'index. Ascendant est la valeur par défaut.
Valeur Base de données cible Résultat

Yes Prend en charge les La variable %ASC% est calculée. Le mot
colonnes d'index triées en clé ASC ou DESC est généré lorsque
ordre ascendant ou vous créez ou modifiez la base de
descendant données
No Ne prend pas en charge le La colonne Tri ne s'affiche pas sur la
tri des colonnes d'index page Colonnes de la feuille de propriétés
d'index. La variable %ASC% n'est pas
calculée. Le mot clé ASC ou DESC n'est
pas généré lorsque vous créez ou
modifiez la base de données

EnableAscDesc = YES
Dans l'exemple suivant, un index de clé primaire est créé sur la table TASK,
la colonne PRONUM se voit attribuer un ordre ascendant et la colonne
TSKNAME se voit attributer un ordre descendant.
create index IX_TASK on TASK (PRONUM asc, TSKNAME desc);
EnableCluster
Permet de définir un index comme index cluster.
Valeur Résultat
Yes La case à cocher Cluster s'affiche dans la feuille de propriétés d'index
No L'index ne prend pas en charge les index cluster

Catégorie Objects
EnableFunction
Permet d'utiliser des index basés sur des fonctions.
Valeur Résultat
Yes Vous pouvez définir des expressions pour les index
No L'index ne prend pas en charge les expressions
EnableOwner
Permet de définir des propriétaires d'index. Le propriétaire d'index peut être
le propriétaire de la table, ou bien il peut s'agir d'un autre utilisateur.
Valeur Résultat
Yes La liste déroulante Propriétaire s'affiche dans la feuille de propriétés
d'index et l'utilisateur peut sélectionner un propriétaire pour l'index
courant
No L'index ne prend pas en charge les propriétaires
Exemple EnableOwner = YES

Si vous activez le propriétaire sur les index, vous devez faire en sorte que
l'instruction Create reflète ce changement de façon à prendre en compte le
propriétaire de la table et de l'index. Par exemple, dans Oracle 9i,
l'instruction Create d'un index est la suivante :
create [%UNIQUE%?%UNIQUE% :[%INDEXTYPE% ]]index
[%QUALIFIER%]%INDEX% on [%CLUSTER%?cluster
C_%TABLE%:[%TABLQUALIFIER%]%TABLE% (
%CIDXLIST%
)]
[%OPTIONS%]
%QUALIFIER% fait référence à l'objet courant (index) et
%TABLQUALIFIER% fait référence à la table parent de l'index.
104 PowerAMC
MandIndexType
Détermine si le type d'index est obligatoire pour un index.
Valeur Résultat
Yes Le type est obligatoire
No Le type n'est pas obligatoire
MaxColIndex
Nombre maximum de colonnes admis dans un index dans le SGBD. La
vérification de modèle procède au contrôle et indique une erreur si le nombre
de colonnes incluses dans la définition d'index dépasse la valeur admise.
Exemple MaxColIndex = 99
Cluster
Mot clé Cluster. Si ce paramètre est vide, la valeur par défaut de la variable
%CLUSTER% est CLUSTER.
Cluster = clustered
La valeur clustered est affectée à la variable %CLUSTER%.
AddColIndex
Instruction permettant d'ajouter une colonne dans l'instruction Create
Index. Ce paramètre définit chaque colonne dans la liste des colonnes de
l'instruction Create Index.
AddColIndex = %COLUMN% [%ASC%]
%COLUMN% est le code de la colonne définie dans la liste des colonnes de

la table. %ASC% est ASC (ordre ascendant) ou DESC (ordre descendant)
selon l'état du bouton radio Tri pour la colonne d'index.

Catégorie Objects
DefIndexType
Définit le type par défaut pour un index.
Exemple Dans DB2 :
Type2
DefineIndexColumn
Définit la colonne d'un index.
Footer
Fin d'index. Tout ce qui est ajouté dans cette entrée est ajouté après
l'instruction create index.
Header
En-tête d'index. Tout ce qui est ajouté dans cette entrée est ajouté avant
l'instruction create index.
IndexType
Liste des types disponibles pour un index.
bitmap
106 PowerAMC
SqlSysIndexQuery
Requête SQL utilisée pour répertorier les index système créés par la base de
données. Ces index sont exclus lors du reverse engineering.
{OWNER, TABLE, INDEX}
select u.user_name, t.table_name, i.index_name
from sys.sysindex i, sys.systable t, SYSUSERPERMS u
where "unique" = 'U' and t.table_id = i.table_id and
u.user_id = t.creator [and u.user_name='%OWNER%'] [and
t.table_name='%TABLE%']
union
select distinct u.user_name, t.table_name, t.table_name
|| '(primary key)'
from sys.systable t, SYSUSERPERMS u
where u.user_id = t.creator and t.primary_root <>0 [and
u.user_name='%OWNER%'] [and t.table_name='%TABLE%']
union
select distinct u.user_name, t.table_name, f.role ||
'(foreign key)'
from sys.systable t, SYSUSERPERMS u, sys.sysforeignkey f
where u.user_id = t.creator and t.table_id =
f.foreign_key_id [and u.user_name='%OWNER%'] [and
t.table_name='%TABLE%']
union
select distinct u.user_name, t1.table_name, f.role ||
'(foreign key)'
from sys.systable t1, sys.systable t2, SYSUSERPERMS u,
sys.sysforeignkey f
where u.user_id = t1.creator and t2.table_id =
f.primary_table_id and t1.table_id=f.foreign_table_id
[and u.user_name='%OWNER%'] [and
t1.table_name='%TABLE%']
IndexComment
Instruction permettant d'ajouter un commentaire à un index.
comment on index [%QUALIFIER%]%TABLE%.%INDEX% is
Exemple %.q:COMMENT%

Catégorie Objects
UniqName
Définition de la portée d'un nom d'index unique. Utilisé par la vérification de
modèle.
Valeur Résultat
Yes Un nom d'index unique est utilisé pour toute la base de données
No Un nom d'index peut être utilisé plusieurs fois s'il est associé à
différents objets
Exemple UniqName = YES
CreateBeforeKey
Permet d'inverser l'ordre de génération des index et des clés.
Valeur Résultat
Yes Les index sont générés avant les clés
No Les index sont générés après les clés
Exemple CreateBeforeKey = YES
108 PowerAMC
Pkey
La catégorie Pkey contient des entrées qui définissent les paramètres relatifs
aux clés primaires.
Entrées communes pour Pkey

l'objet Pkey dans la définition de SGBD.

Enable Enable = Yes
Create [%USE_SP_PKEY%?[execute] sp_primarykey %TABLE%,
%PKEYCOLUMNS%
:alter table [%QUALIFIER%]%TABLE%
add [constraint %CONSTNAME%] primary key
[%CLUSTER% ](%PKEYCOLUMNS%)
[%OPTIONS%]]
Add [constraint %CONSTNAME%] primary key [%CLUSTER%
](%PKEYCOLUMNS%)
[%OPTIONS%]
Drop [%USE_SP_PKEY%?execute sp_dropkey primary, %TABLE%

drop constraint %CONSTNAME%]
Options <clustered> %s : list=clustered | nonclustered

with : composite=yes, separator=yes, parenthesis=no
{
fillfactor=%d : default=0
}
DefOptions —


Catégorie Objects
PkAutoIndex
Clé primaire auto-indexée. Cette option détermine principalement si
l'instruction Create Index doit être générée pour chaque instruction de
clé primaire.

Yes Génère automatiquement un Les cases à cocher de clé primaire et
index de clé primaire lorsque Création d'index peuvent être
vous générez l'instruction de cochées simultanément dans les
clé primaire paramètres de génération ou de
modification.
Si vous cochez la case Clé primaire
sous Création d'index, la case
Primaire est automatiquement
décochée sous Création de table,
et réciproquement
No Ne génère pas les index de clé Les index de clé primaire doivent être
primaire lorsque vous générez générés de façon explicite. Les cases à
les clés primaires cocher relatives aux clés primaires et
la case Création d'index peuvent être
cochées simultanément

PkAutoIndex = YES
UseSpPrimKey
Utilisez l'instruction Sp_primarykey pour générer une clé primaire.
Pour une base de données qui prend en charge la procédure de mise en
oeuvre de définition de clé, vous pouvez tester la valeur de la variable
correspondante %USE_SP_PKEY% et choisir entre la création d'une clé
dans la table et le lancement d'une procédure.
Valeur Résultat
Yes L'instruction Sp_primarykey est utilisée pour générer une clé
primaire
No Les clés primaires sont générées séparément dans une instruction alter
table
110 PowerAMC
Exemple Dans Microsoft SQL Server :

UseSpPrimKey = YES
Add entry of Pkey contains
[%USE_SP_PKEY%?[execute] sp_primarykey %TABLE%,

%PKEYCOLUMNS%
add [constraint %CONSTNAME%] primary key
[%IsClustered%] (%PKEYCOLUMNS%)
[%OPTIONS%]]
ConstName
Permet de déclarer un template personnalisable pour tous les noms de
contrainte de clé primaire dans un MPD.
Pour chaque table dans un modèle, le nom de contrainte de clé primaire est
défini dans l'entrée Nom de contrainte pour la clé définie comme clé
primaire. Ce nom de contrainte est généré dans la base de données si cette
dernière prend en charge les clés primaires et noms de contrainte.
Certaines variables PowerAMC peuvent être utilisées pour définir le nom de
contrainte de clé primaire :
♦ %TABLE% : code de table
♦ %KEY% : code de clé
♦ %COLUMN% : code de colonne
♦ %COLNNO% : numéro de colonne
Les noms de contrainte en double sont renommés automatiquement en
prenant en compte la longueur de la contrainte.
%OID%
La variable %OID% utilisée dans certains fichier .Def dans la Version 6
n'est plus disponible. Les identificateurs d'objet sont codés sur plus de 20
caractères, ce qui les rend inutilisables pour les noms de contrainte
(souvent limités à 8 ou à 18 caractères)
Exemple PKConstraintName = PK_%.U27:TABLE%
PKeyComment
Instruction permettant d'ajouter un commentaire de clé primaire.
Exemple comment on primary key [%QUALIFIER%]%TABLE%.%PKEY% is
%.q:COMMENT%

Catégorie Objects
Key
La catégorie Key contient des entrées qui définissent les paramètres associés
aux clés.
Entrée communes pour Key

l'objet Key dans la définition de SGBD :
Entrée Exemple (Sybase Adaptive Server Anywhere 6)

Enable Enable = Yes
Create alter table [%QUALIFIER%]%TABLE%
add unique (%COLUMNS%)
Add unique (%COLUMNS%)
Drop alter table [%QUALIFIER%]%TABLE%

delete unique (%COLNLIST%)
DefOptions _
Options Oracle 7 :
using index : composite=yes, separator=no,
parenthesis=no
{
pctfree %d
initrans %d : default=1
maxtrans %d
tablespace %s : category=tablespace
storage : category=storage, composite=yes,
separator=no, parenthesis=yes
{
initial %s : default=10K
next %s : default=10K
minextents %d : default=1
maxextents %s
maxextents unlimited
pctincrease %d : default=50
freelists %d : default=1
freelist groups %d : default=1
optimal %d
optimal NULL
}
nosort
<recoverable> %s : list=recoverable | unrecoverable
}
disable
SqlAttrQuery —
SqlOptsQuery —
112 PowerAMC

SqlListQuery {TABLE ID, ISPKEY ID, CONSTNAME ID, COLUMNS
…}
select
t.table_name,
1,
null,
c.column_id
from
systable t,
syscolumn c
where
t.table_name='%TABLE%'
and c.pkey='Y'
and c.table_id=t.table_id
union select
t.table_name,
0,
i.index_name,
x.sequence
from
sysindex i,
systable t,
syscolumn c,
sysixcol x
where
t.table_name='%TABLE%'
and i."unique"='U'
and i.table_id=t.table_id
and x.table_id=t.table_id
and c.table_id=t.table_id
and x.index_id=i.index_id
and x.column_id=c.column_id
order by
1, 3, 5
SqlFragQuery —
de base de données
engineering


Catégorie Objects
AllowNullableColn
Instruction indiquant que la clé peut contenir des colonnes non obligatoires.
Valeur Résultat
Yes Colonne pouvant être non obligatoires admises
No Seules les colonnes obligatoires sont admises
UniqConstAutoIndex
Indexaction automatique de contrainte unique de clé alternative. Cette option
commence par déterminer si une instruction Create Index est requise
pour chaque instruction de clé.

Yes Génère automatiquement un La case Clé alternative (dans les
index de clé alternative lors options Filtre d'index de la zone de
de la génération de groupe Index) et la case Création de
l'instruction de clé alternative clé (zone de groupe Clés alternatives)
ne peuvent pas être cochées
simultanément dans la page Clés et
index de la boîte de dialogue de
génération
No Ne génère pas d'index de clé Les index de clé alternative doivent
alternative lors de la être générés de façon explicites. Les
génération des clés cases à cocher concernant les clés
alternatives alternatives et la case Création d'index
peuvent être cochées simultanément

UniqConstAutoIndex = YES
114 PowerAMC
UniqInTable
Clé alternative créée dans la table. Cette entrée détermine l'endroit où la clé
alternative est définie dans le script SQL.
Valeur Résultat
Yes Les clés alternatives sont incluses dans l'instruction create table.
L'entrée Add pour la clé est concaténée dans la variable
%TABLEDEFN%
No Les clés alternatives sont générées séparément dans une instruction
alter table, le contenu de l'entrée Create pour la clé alternative est
utilisé lors de la génération
Exemple UniqInTable = Yes
MaxConstLen
génération.

ConstName
contrainte de clé alternative dans un MPD. Utilisé dans la feuille de
propriétés de clé pour toutes les clés qui sont des clés alternatives et qui ne
sont pas des clés primaires.
Pour chaque table dans un modèle, un nom de contrainte de clé alternative est
défini dans l'entrée Nom de contrainte des propriétés de la clé si cette clé est
définie comme clé alternative. Ce nom de contrainte est généré dans la base
de données si la base de données prend en charge les clés alternatives et les
noms de contrainte.

Catégorie Objects
Certaines variables PowerAMC peuvent être utilisées pour définir un nom de

contrainte de clé alternative :
♦ %TABLE% : code de table
♦ %KEY% : code de clé
Les noms de contrainte en double sont automatiquement renommés en
fonction de la longueur de la contrainte.
AK_%.U18:AKEY%_%.U8:TABLE%
SqlAkeyIndex
Requête de reverse engineering permettant d'obtenir les index de clé
alternative d'une table via ODBC.
select distinct I.INDEX_NAME
from SYSINDEX I, SYSUSERPERMS U, SYSTABLE T
where I."UNIQUE" = 'U' and I.TABLE_ID = T.TABLE_ID and
T.TABLE_NAME = '%TABLE%' and T.CREATOR = U.USER_ID
and U.USER_NAME = '%USER%'
AKeyComment
Instruction permettant d'ajouter un commentaire de clé alternative.
Exemple comment on alternate key [%QUALIFIER%]%TABLE%.%AKEY% is
%.q:COMMENT%
116 PowerAMC
Reference
La catégorie Reference contient des entrée définissant des paramètres liés aux
références.
Entrées courantes pour Reference

l'objet Reference dans la définition de SGBD.

Enable Enable = Yes
Create Remarquez que check on commit (CHCKONCMMT) à la fin
de l'exemple est utile pendant le reverse engineering pour
analyser le texte.
Alter table [%QUALIFIER%]%TABLE%
Add foreign key %CONSTNAME%
(%FKEYCOLUMNS%)
references [%PQUALIFIER%]%PARENT%
(%CKEYCOLUMNS%)
[on update %UPDCONST%]
[on delete %DELCONST%]
[%CHCKONCMMT% ? check on commit]
Add foreign key %CONSTNAME% (%FKEYCOLUMNS%)

references [%PQUALIFIER%]%PARENT%
(%CKEYCOLUMNS%)
[on update %UPDCONST%]
[on delete %DELCONST%]
[%CHCKONCMMT% ? check on commit]
Drop if exists(select 1 from sys.sysforeignkey where

role='%CONSTNAME%') then
delete foreign key %CONSTNAME%
end if
SqlAttrQuery —
SqlListQuery —
de base de données
engineering

Catégorie Objects

EnableChangeJoinOrder
Lorsqu'une référence est liée à une clé, comme affiché sur la page Jointures
d'une feuille de propriétés de référence, cette entrée détermine si
l'organisation automatique de l'ordre des jointures est disponible.
Valeur Résultat
Yes L'ordre de jointure peut être établi automatiquement ou manuellement
à l'aide de l'option Organisation automatique de l'ordre des jointures.
Lorsque vous cochez la case de cette fonctionnalité, vous triez la liste
en fonction de l'ordre des colonnes de clé (les boutons de déplacement
ne sont pas disponibles). En décochant cette case, vous pouvez
modifier manuellement l'ordre de jointure à l'aide des boutons de
déplacement (qui sont alors disponibles)
No La case Organisation automatique de l'ordre des jointures est grisée et
non disponible
Exemple EnableChangeJoinOrder = YES
EnablefKeyName
Rôle de clé étrangère admis lors de la génération de base de données.
Valeur Résultat
Yes Le code de la référence est utilisé comme rôle pour la clé étrangère
No Le rôle n'est pas admis pour la clé étrangère
118 PowerAMC
FKAutoIndex
Clé étrangère auto-indexée. Cette option détermine si une instruction
Create Index doit ou non être générée pour chaque instruction de clé
étrangère.
Valeur SGBD Résultat

Yes Génère automatiquement La case Clé étrangère (dans les options
un index de clé étrangère Filtre d'index de la zone de groupe Index)
lors de la génération des et la case Création de clé (zone de groupe
instructions de clé primaire, Clés étrangères) ne peuvent pas être
alternative ou étrangère cochées simultanément dans la page Clés
et index de la boîte de dialogue de
génération
No Né génère pas Les index de clé étrangère doivent être
automatiquement d'index de générés de façon explicite. Les cases à
clé étrangère lors de la cocher de clé étrangère et la case à cocher
génération de clés Création de table peuvent être cochées
étrangères simultanément
Exemple FKAutoIndex = YES
MaxConstLen
génération.


Catégorie Objects
ConstName
contrainte de clé étrangère dans un MPD. Utilisé dans la feuille de propriétés
de référence, dans la zone Nom de contrainte sur la page Intégrité.
Pour chaque table dans un modèle, un nom de contrainte de clé étrangère est
défini dans l'entrée Nom de contrainte de la feuille de propriétés d'une
référence pour une clé définie comme clé étrangère. Ce nom de contrainte est
généré dans la base de données si cette dernière prend en charge les clés
étrangères et les noms de contrainte.
Les variables PowerAMC suivantes peuvent être utilisées pour définir un
nom de contrainte de clé étrangère :
%TABLE% : code de la table (table parent et enfant, compatible Version 6)
Les noms de contrainte en double sont automatiquement renommés en tenant
compte de la longueur de la contrainte.
Exemple FK_%.U8:CHILD%_%.U9:REFR%_%.U8:PARENT%
CheckOnCommit
Le test d'intégrité référentielle est uniquement effectué après COMMIT.
Contient le mot clé utilisé pour spécifier une référence avec l'option
CheckOnCommit.
Exemple CHECK ON COMMIT
DclUpdIntegrity
Contraintes d'intégrité référentielle déclarative pour la modification admises.
Doit contenir une liste de mots de la sélection suivante.
RESTRICT
CASCADE
SET NULL
SET DEFAULT
Selon la liste de mots sélectionnés, le bouton radio sur la page Intégrité de la
feuille de propriétés de référence est disponible ou non.
120 PowerAMC

RESTRICT
CASCADE
SET NULL
SET DEFAULT
DclDelIntegrity
Contraintes d'intégrité référentielle déclarative pour la suppression admises.
Doit contenir une liste de mots de la sélection suivante.
RESTRICT
CASCADE
SET NULL
SET DEFAULT
Selon la liste de mots sélectionnés, le bouton radio sur la page Intégrité de la
feuille de propriétés de référence est disponible ou non.
RESTRICT
CASCADE
SET NULL
SET DEFAULT
DefineJoin
Définit une jointure pour une référence, ce qui correspond à la variable
%JOINS%. Il s'agit d'une autre façon de définir le contenu de l'instruction
create reference.
En règle générale, le script create pour une référence utilise les variables
%CKEYCOLUMNS% et %PKEYCOLUMNS% qui contiennent des
colonnes enfant et parent séparées par une virgule.
Si vous utilisez %JOINS%, vous pouvez faire référence à chaque paire de
colonnes parent-enfant séparément.
Lorsque vous utilisez %JOINS%, une boucle est exécutée sur la jointure pour
chaque paire de colonnes parent-enfant, ce qui permet d'utiliser une syntaxe
mélangeant PK et FK.

Catégorie Objects
Exemple Dans Microsoft Access :

DefineJoin = P=%PK% F=FK%
Create = CreateJoin C=%CONSTANME% T=%TABLE% P=%PARENT%
(
%JOINS%
)
SqlListChildrenQuery
Requête SQL utilisée pour répertorier les jointures dans une référence.
SELECT COL2.COLUMN_NAME, COL1.COLUMN_NAME
FROM SYS.ALL_CONS_COLUMNS COL1, SYS.ALL_CONS_COLUMNS
COL2
WHERE
COL1.POSITION = COL2.POSITION
AND COL1.OWNER='%SCHEMA%' AND
COL1.TABLE_NAME='%TABLE%'
AND COL2.OWNER='%POWNER%' AND
COL2.TABLE_NAME='%PARENT%'
AND COL1.CONSTRAINT_NAME='%FKCONSTRAINT%' AND
COL2.CONSTRAINT_NAME='%PKCONSTRAINT%'
ORDER BY COL1.POSITION
UseSpFornKey
Utilise l'instruction Sp_foreignkey pour générer une clé étrangère.
Valeur Résultat
Yes L'instruction Sp_foreignkey est utilisée pour créer une référence
No Les clés étrangères sont générées séparément dans une instruction alter
table à l'aide de la commande Create de la référence

UseSpFornKey = Yes
Voir aussi UseSpPrimKey.
FKeyComment
Commande permettant d'ajouter un commentaire à une clé étrangère.
Exemple comment on foreign key [%QUALIFIER%]%TABLE%.%FK% is
%.q:COMMENT%
122 PowerAMC
View
La catégorie View contient des entrées qui définissent les paramètres associés
aux vues.
Entrées courantes pour View

l'objet View dans la définition de SGBD.
Entrée Exemple (Oracle 8)

Enable Enable = Yes
Create create [or replace ][%R% [no] force]view
[%QUALIFIER%]%VIEW% [(%VIEWCOLN%) ]as
%SQL%
[%VIEWCHECK%] [%R%with read only]
Drop drop view [%QUALIFIER%]%VIEW%
SqlListQuery —
SqlAttrQuery {OWNER, VIEW, SCRIPT}
[%ISODBCUSER% ?
SELECT '%SCHEMA%', VIEW_NAME, TEXT
FROM SYS.USER_VIEWS
ORDER BY VIEW_NAME
:
SELECT OWNER, VIEW_NAME, TEXT
FROM SYS.ALL_VIEWS [WHERE
OWNER='%SCHEMA%']
ORDER BY OWNER, VIEW_NAME
]
SqlFragQuery {VAR1NAME, VAR1VALUE}
select
'HighVal'||tp.partition_position,
tp.high_value
from
all_tab_partitions tp
where 1=1
[ and tp.table_owner=%.q:OWNER% ]
[ and tp.table_name=%.q:VIEW%]
SqlOptsQuery —
Options —
de base de données

Catégorie Objects

engineering

Permission
Permissions disponibles pour les vues. La première colonne affiche le nom
SQL de la permission (SELECT, par exemple). La seconde colonne est le
nom abrégé qui s'affiche dans le titre des colonnes de grille.
SELECT / Sel
INSER / Ins
DELETE / Del
UPDATE / Upd
Footer
Fin de la vue. Tout ce qui est ajouté dans cette entrée est ajouté après
l'instruction create view.
Header
En-tête de vue. Tout ce qui est ajouté dans cette entrée est ajouté avant
l'instruction create view.
124 PowerAMC
SqlPermQuery
accordées sur les vues.
select u1.name grantee,
case
end +
case
end
|| ','
o
where
o.name = %.q:VIEW% and
o.uid = u.uid and
s.id = o.id and
u1.uid = s.uid
ViewComment
Instruction permettant d'ajouter un commentaire à une vue. Le commentaire
de vue est une instruction SQL, qui n'est pas pris en charge par tous les
SGBD. Si ce paramètre est vide, la case à cocher Commentaire est grisée et
non disponible (zone de groupe Vues, dans la page Tables et vues de la boîte
de dialogue de génération).
comment on table [%QUALIFIER%.]%VIEW% is '%COMMENT%'
La variable %VIEW% est le nom de la vue tel que défini dans la boîte de
dialogue Liste des vues ou dans la feuille de propriétés de la vue. La variable
%COMMENT% représente le commentaire défini dans la zone de texte
Commentaire de la feuille de propriétés de la vue.

Catégorie Objects
ViewCheck
Option permettant de vérifier une vue. Ce paramètre détermine si la case
With Check Option dans la feuille de propriétés de la vue est disponible ou
grisée.
Si la case est cochée et que le paramètre ViewCheck n'est pas vide, la
valeur de ViewCheck est générée à la fin de l'instruction select de la vue et
avant le caractère de fin.
Exemple Dans Sybase SQL Anywhere 5.5 :
ViewCheck = with check option
Le script généré pour cet exemple est le suivant :
create view TEST as
select CUSTOMER.CUSNUM, CUSTOMER.CUSNAME,
CUSTOMER.CUSTEL
from CUSTOMER
with check option;
ViewStyle
Option permettant de définir le type d'utilisation d'une vue. La valeur définie
pour cette entrée sera affichée dans la liste déroulante Utilisation sur la
feuille de propriétés de la vue.
ViewStyle = materialized view
Tablespace
Le Tablespace contient des entrées qui définissent les paramètres associés
aux tablespace.
Entrées courantes pour Tablespace

l'objet Tablespace dans la définition de SGBD.

Enable Enable = Yes
Create create tablespace %TABLESPACE%
[%OPTIONS%]
126 PowerAMC

Drop drop tablespace %TABLESPACE% [including contents
[cascade constraints]]
Options datafile : composite=yes, chldmand=yes

{
<datafile_clause> : composite=yes, separator=yes,
multiple=yes
{
<file_spec> : composite=yes
{
<filename> %s : squoted=yes
size %d
reuse
}
<autoextend_clause> : composite=yes
{
autoextend off
autoextend on : composite=yes
{
next %s
maxsize %s : default=UNLIMITED
}
}
}
}
minimum extent %s
<log> %s : list=logging | nologging
default storage : category=storage, composite=yes,
parenthesis=yes
{
initial %d : default=10K
next %d : default=10K
maxextents %d
maxextents unlimited
optimal %d
optimal NULL
buffer_pool %s : list=keep | recycle | default
}
<online> %s : default=online, list=online | offline
<permanent> %s : default=permanent, list=permanent |
temporary
DefOptions —
SqlListQuery {TABLESPACE}
SELECT TABLESPACE_NAME FROM

USER_TABLESPACES ORDER BY 1

Catégorie Objects

SqlAttrQuery {TABLESPACE, OPTIONS}
SELECT TABLESPACE_NAME, 'DEFAULT STORAGE

(INITIAL ' || INITIAL_EXTENT ||
' NEXT ' || NEXT_EXTENT || ' MIN_EXTENTS ' ||
MIN_EXTENTS ||
' MAX_EXTENTS ' || MAX_EXTENTS || '
PCTINCREASE ' || PCT_INCREASE || ') ' ||
STATUS OPTS
FROM USER_TABLESPACES
SqlOptsQuery —
SqlFragQuery —
ModifiableAttributes Liste des attributs étendus qui seront pris en compte dans la
boîte de dialogue de fusion lors de la synchronisation de
base de données
engineering

TablespaceComment
Instruction permettant d'ajouter un commentaire à un tablespace.
Exemple comment on tablespace [%QUALIFIER%]%TABLESPACE% is
%.q:COMMENT%
Storage
La catégorie Storage contient des entrées qui définissent les paramètres
associés aux storages.
Entrées courantes pour Storage

l'objet Storage dans la définition de SGBD.

Enable Enable = Yes
Create -
128 PowerAMC

Drop —
Options initial %d : default=10K
next %d : default=10K
maxextents %d
freelist groups %d : default=1
optimal %d
buffer_pool %s : list=keep | recycle | default
DefOptions —
SqlList Query —
SqlAttrQuery {STORAGE, OPTIONS}
SELECT SEGMENT_NAME, 'INITIAL ' ||

INITIAL_EXTENT ||
' NEXT ' || NEXT_EXTENT || ' MIN_EXTENTS ' ||
MIN_EXTENTS ||
' MAX_EXTENTS ' || MAX_EXTENTS || '
PCTINCREASE ' || PCT_INCREASE ||
' FREELISTS ' || FREELISTS || '
FREELIST_GROUPS ' || FREELIST_GROUPS OPTS
FROM USER_SEGMENTS
de base de données
engineering

StorageComment
Instruction permettant d'ajouter un commentaire à un storage.
Exemple comment on storage [%QUALIFIER%]%STORAGE% is
%.q:COMMENT%

Catégorie Objects
Database
La catégorie Database contient des entrées qui définissent les paramètres
associés aux database.
Entrées courantes pour Database

l'objet Database dans la définition de SGBD.
Entrée Exemple (Adaptive Server Anywhere 6)

Enable Enable = No
Create create database '%DATABASE%.db'
[%OPTIONS%]
Drop drop database %DATABASE%
Options transaction
log %s : list= on | off
<logonfile> %s
mirror %s
case %s : default=respect, list=respect | ignore
page size %d : default=1024, list=1024 | 2048 | 4096
collation %s
encrypted %s : list=on | off
blank padding %s : list=on | off
ASE
compatible
java %s : list=on | off
jconnect %s : list=on | off
DefOptions —
SqlListQuery —
SqlAttrQuery —
de base de données
engineering

130 PowerAMC
BeforeCreateDatabase
Détermine si les instructions Create Tablespace et Create
Storage sont générées avant ou après la création de la base de données.
Valeur par défaut : YES.
Valeur Résultat
Yes Les instructions Create Tablespace et Create Storage sont générées
avant l'instruction Create Database
No Les instructions Create Tablespace et Create Storage sont générées
après l'instruction Create Database
Exemple Dans IBM DB2 MVS version 4 :

BeforeCreateDatabase = NO
CloseDatabase
Instruction permettant de fermer une base de données. Si ce paramètre est
vide, la case Fermeture de la base est grisée et non disponible (zone de
groupe Base de données sur la page Base de données) dans la boîte de
dialogue de génération.
CloseDatabase =
OpenDatabase
Instruction permettant d'ouvrir une base de données. Si ce paramètre est vide,
la case Ouverture de la base est grisée et non disponible (zone de groupe
Base de données sur la page Base de données) dans la boîte de dialogue de
génération.
OpenDatabase = use %DATABASE%
La variable %DATABASE% est le code de la base de données associé au
modèle généré.

Catégorie Objects
EnableManyDatabases
Détermine si le SGBD prend en charge plusieurs bases de données dans le
même modèle.
Exemple Dans DB2MVS8 :
EnableManyDatabases = Yes
Domain
La catégorie Domain contient des entrées qui définissent les paramètres
associés aux domaines.
Entrées courantes pour Domain

l'objet Domain dans la définition de SGBD.

Enable Enable = Yes
Maxlen MaxLen = 30
Create create datatype %DOMAIN% %DATATYPE%
[%NOTNULL%] [default %DEFAULT%]
[check (%CONSTRAINT%)]
Drop if exists(select 1 from systypes where

name='%DOMAIN%')then
drop datatype %DOMAIN%
end if
SqlListQuery {@OBJTCODE id, DTTPCODE, LENGTH, PREC}

Select d.type_name, t.domain_name, d.width,
t."precision"
from sysusertype d, sysdomain t
where d.domain_id=t.domain_id and d.domain_id
<> 25 and d.domain_id <> 26 and creator <> 0
SqlAttrQuery {@OBJTCODE id, DTTPCODE, LENGTH, PREC,

DEFAULT, CONSTRAINT}
Select d.type_name, t.domain_name, d.width,
d.scale, d."default", d."check"
from sysusertype d, sysdomain t
where d.domain_id=t.domain_id and
d.domain_id <> 25 and d.domain_id <> 26 and
creator <> 0
132 PowerAMC

ModifiableAttributes Liste des attributs étendus qui seront pris en compte
dans la boîte de dialogue de fusion lors de la
synchronisation de base de données
engineering

EnableBindRule
Permet ou interdit l'association d'une règle de gestion à un domaine pour les
paramètres de contrôle.
Valeur Résultat
Yes Les entrées Create et Bind de l'objet Rule sont générées
No Le contrôle inclus dans la commande d'ajout du domaine est généré
Exemple Dans Microsoft SQL Server et Sybase 11 :

EnableBindRule = Yes
EnableDefault
Permet l'utilisation de valeurs par défaut prédéfinies.
Valeur Résultat
Yes La valeur par défaut est générée pour le domaine lorsque la valeur par
défaut est définie. La valeur par défaut peut être définie dans les
paramètres de contrôle. La variable %DEFAULT% va contenir la
valeur par défaut
No La valeur par défaut ne peut pas être générée

Catégorie Objects
EnableCheck
Détermine si la génération de paramètres de contrôle est autorisée ou non.
Cette entrée est testée lors de la génération des colonnes : si l'option Type utilisateur
est sélectionnée pour les colonnes dans la boîte de dialogue de génération, et si
EnableCheck est défini à Yes pour les domaines, alors les paramètres de contrôle ne
sont pas générés pour les colonnes, puisque la colonne est associée à un domaine
ayant des paramètres de contrôle. Lorsque les contrôles portant sur la colonne
divergent de ceux sur le domaine, les contrôles sur la colonne sont générés.
Valeur Résultat
Yes Paramètres de contrôle générés
No Toutes les variables liées aux paramètres de contrôle ne seront pas
évaluées lors de la génération et du reverse engineering
EnableOwner
Permet de définir des propriétaires pour les domaines.
Valeur Résultat
Yes La liste déroulante Propriétaire s'affiche dans la feuille de propriétés du
domaine et l'utilisateur peut sélectionner un propriétaire pour le
domaine courant
No Le domaine ne prend pas en charge les propriétaires
UserTypeName
Vous pouvez définir des types de données avec des noms spécifiés par
l'utilisateur. Vous améliorez ainsi la lisibilité du contenu des objets dans vos
applications particulières.
Exemple UserTypeName = T_%DOMAIN%
Bind
Lie une règle de gestion à un domaine.
[execute] sp_bindrule %RULE%, %DOMAIN%
134 PowerAMC
BindDefault
Lie une valeur par défaut à un domaine.
Exemple Dans Microsoft SQL Server and Sybase 11 :
sp_bindefault %DEFAULTNAME%, %DOMAIN%
CreateDefault
Crée une valeur par défaut pour un domaine.
Exemple Dans Microsoft SQL Server and Sybase 11 :
create default %DEFAULTNAME%
as %DEFAULT%
SqlListDefaultQuery
Requête SQL permettant de répertorier les valeurs par défaut du domaine.
Dans le cas de certains SGBD, le processus de reverse engineering ODBC
extrait les valeurs par défaut de domaine dans les tables système. Cette
requête répertorie ces valeurs par défaut.
UddtComment
Instruction permettant d'ajouter un commentaire pour un type de données
utilisateur.
Exemple comment on user-defined data type [%QUALIFIER%]%DOMAIN%
is %.q:COMMENT%
Unbind
Dissocie une règle de gestion d'un domaine.
[execute] sp_unbindrule %DOMAIN%, %RULE%

Catégorie Objects
Abstract Data Type

La catégorie Abstract Data Type contient des entrées qui définissent les
paramètres associés aux types de données abstraits.
Entrées courantes pour Abstract Data Type

l'objet Abstract Data Types dans la définition de SGBD.
Entrée Exemple
Enable Sybase Adaptive Server Anywhere 6 :
Enable = Yes
Create Dans Oracle 8 :

[%ISARRAY% ? create type %ADT% as %TYPE%
(%SIZE%) of %DATATYPE%]
[%ISLIST% ? create type %ADT% as %TYPE% of
%DATATYPE%]
[%ISOBJECT% ? create type %ADT% as %TYPE%
(
%ADTDEF%
)]
Drop Dans Oracle 8 :

drop type %ADT%
SqlListQuery Dans Sybase Adaptive Server Anywhere 6 :

{ADT, OWNER, TYPE(25=JAVA , 26=JAVA)}
SELECT t.type_name, u.user_name, t.domain_id
FROM sysusertype t, sysuserperms u
WHERE [u.user_name = '%SCHEMA%' AND]
(domain_id = 25 OR domain_id = 26) AND
t.creator = u.user_id
ORDER BY type_name
SqlAttrQuery —
de base de données
engineering

136 PowerAMC
EnableAdtOnDomn
Instruction permettant l'utilisation de types de données abstraits sur les
domaines.
Valeur Résultat
Yes Les types de données abstraits sont ajoutés dans la listes des types de
domaines, à condition qu'ils aient un type correct
No Les types de données abstraits ne sont pas admis pour les domaines
Exemple EnableAdtOnDomn = Yes
EnableAdtOnColn
Instruction permettant l'utilisation de types de données abstraits sur les
colonnes.
Valeur Résultat
Yes Les types de données abstraits sont ajoutés dans la listes des types de
colonne, à condition qu'ils aient un type correct
No Les types de données abstraits ne sont pas admis pour les colonnes
Exemple EnableAdtOnColn = Yes
Install
Instruction permettant d'installer une classe Java. Cette entrée équivaut à une
instruction create.
Dans Sybase Adaptive Server Anywhere, les types de données abstraits ne
sont pas réellement créés, mais installés.
install JAVA UPDATE from file '%FILE%'

Catégorie Objects
Remove
Instruction permettant de désinstaller une classe Java. Cette entrée équivaut à
une instruction de suppression.
Dans Sybase Adaptive Server Anywhere, les types de données abstraits ne
sont pas réellement supprimés, mais retirés.
remove JAVA class %ADT%
AllowedADT
Liste des types de données abstraits qui peuvent être utilisés comme types de
données pour un type de données abstrait.
OBJECT
ADTComment
Instruction permettant d'ajouter un commentaire au type de données abstrait.
Exemple comment on abstract data type [%QUALIFIER%]%ADT% is
%.q:COMMENT%
Abstract Data Type Attribute

La catégorie Abstract Data Types Attribute contient des entrées qui
définissent les paramètres associés aux attributs de types de données
abstraits.
Entrées courantes pour Abstract Data Type Attribute

l'objet Abstract Data Types Attribute dans la définition de SGBD.
Entrée Example
_
Create
Add Dans Oracle 8 :
%ADTATTR% %DATATYPE%
138 PowerAMC
Entrée Example
Drop —
Modify —
SqlListQuery Dans Oracle 8 :
{ ADT, ADTATTR , DTTPCODE, LENGTH, PREC }
SELECT type_name, attr_name, attr_type_name,
length, precision
FROM all_type_attrs
ORDER BY type_name
de base de données
engineering

AllowedADT
Liste des types de données abstraits qui peuvent être utilisés comme type de
données pour des attributs de type de données abstrait.
Dans PowerAMC, lorsque vous sélectionnez le type OBJECT pour un type
de données abstrait, un onglet Attributs est ajoutée dans la feuille de
propriétés du type de données abstrait. Cet onglet vous permet de spécifier
les attributs du type de données de l'objet.
OBJECT
TABLE
VARRAY

Catégorie Objects
User
La catégorie User contient des entrées qui définissent les paramètres associés
aux utilisateurs.
Entrées courantes pour User

l'objet User dans la définition de SGBD.

Enable Enable = Yes
Maxlen Maxlen = 128
SqlListQuery {@OBJTCODE id} Select USER_NAME from
SYS.SYSUSERPERMS order by USER_NAME
SqlAttrQuery —
Create Dans Sybase ASE 12.5 :
sp_adduser %USERID%
[%PRIVILEGE%]
Drop Dans Sybase ASE 12.5 :

sp_dropuser %USERID%
de base de données
engineering

140 PowerAMC
SqlPermQuery
Requête SQL permettant de procéder au reverse engineering des permissions
accordées aux utilisateurs.
{USER ID, PRIVILEGE ...}

case
when (s.action = 198) then 'CREATE TABLE'
when (s.action = 203) then 'CREATE DATABASE'
when (s.action = 207) then 'CREATE VIEW'
when (s.action = 221) then 'CREATE TRIGGER'
when (s.action = 222) then 'CREATE PROCEDURE'
when (s.action = 233) then 'CREATE DEFAULT'
when (s.action = 236) then 'CREATE RULE'
end +
case
end
|| ','
from sysprotects s, sysusers u1
where u1.uid = s.uid
order by 1

Catégorie Objects
Rule
La catégorie Rule contient des entrées qui définissent les paramètres associés
aux règles.
Entrées courantes pour Rule

l'objet Rule dans la définition de SGBD.

Enable Enable = Yes
Maxlen MaxLen = 30
Create create rule %RULE% as
%RULESEXPR%
Drop if exists (select 1 from sysobjects where

name='%RULE%' and type='R')
drop rule %RULE%
SqlListQuery {@OBJTNAME ID, @OBJTCODE ID, SCRIPT …}
select
o.name,convert(char(20), o.id),t.text
from
dbo.sysobjects o, dbo.syscomments t
where
[%SCHEMA%? o.uid=user_id('%SCHEMA%') and]
o.type='R'
and t.id=o.id and t.texttype=0
order by
o.id,t.number,t.colid
SqlAttrQuery —
de base de données
engineering

142 PowerAMC
MaxDefaultLen
Longueur maximale que le SGBD prend en charge pour le nom par défaut de
la colonne. Ce nom n'est défini que dans la syntaxe des bases de données de
la famille Sybase.
Exemple MaxDefaultLen = 254
ColnDefaultName
Nom de la valeur par défaut pour la colonne. Lorsqu'une colonne a une
valeur par défaut particulière définie dans ses paramètres de contrôle, un nom
est créé pour cette valeur par défaut de colonne. Cette entrée est utilisée avec
les SGBD qui ne prennent pas en charge les paramètres de contrôle sur les
colonnes, tels que SQL Server 4.
La variable correspondante est %DEFAULTNAME%
ColnDefaultName = D_%.19:COLUMN%_%.8:TABLE%
La colonne Employee function EMPFUNC de la table EMPLOYEE a la
valeur par défaut, Technical Engineer. Le nom par défaut de la
colonne, D_EMPFUNC_EMPLOYEE, est créé :
create default D_EMPFUNC_EMPLOYEE
as 'Technical Engineer'
go
execute sp_bindefault D_EMPFUNC_EMPLOYEE,

"EMPLOYEE.EMPFUNC"
go
ColnRuleName
Les paramètres de contrôle de colonne sont définis dans des règles séparées
dans l'instruction create table pour Sybase SQL Server 4.x et Microsoft
SQL Server. Lorsqu'une colonne a une règle particulière définie dans ses
paramètres de contrôle, ces SGBD créent un nom pour cette règle de
colonne.
La variable correspondante est %RULE%
ColnRuleName = R_%.19:COLUMN%_%.8:TABLE%
La colonne Specialty (TEASPE) de la table Team a une liste de valeurs
définie dans ses paramètres de contrôle : Industry, Military, Nuclear, Bank,
Marketing.

Catégorie Objects
Le nom de règle suivant, R_TEASPE_TEAM, est créé et associé à la colonne

TEASPE :
create rule R_TEASPE_TEAM
as
@TEASPE in
('Industry','Military','Nuclear','Bank','Marketing')
go
execute sp_bindrule R_TEASPE_TEAM, "TEAM.TEASPE"

go
UddtDefaultName
Nom par défaut pour un type de données défini par l'utilisateur. Lorsqu'un
domaine a une valeur par défaut particulière définie dans ses paramètres par
défaut, les bases de données Sybase créent un nom comme valeur par défaut
pour ce type de données par défaut.
La variable correspondante est %DEFAULTNAME%
UddtDefaultName = D_%.28:DOMAIN%
Le domaine FunctionList a une valeur par défaut définie dans ses
paramètres de contrôle : Technical Engineer. Le script SQL suivant
va générer un nom par défaut pour cette valeur par défaut :
create default D_Functionlist
as 'Technical Engineer'
go
UddtRuleName
Nom d'une règle définie pour un type de données utilisateur. Lorsqu'un
domaine a une règle spécifique définie dans ses paramètres de contrôle, la
base de données Sybase crée un nom pour cette valeur de type de données
utilisateur pour une règle.
La variable correspondante est %RULE%
144 PowerAMC

UddtRuleName = R_%.28:DOMAIN%
Le domaine Domain_speciality doit appartenir à un jeu de valeurs. Ce
contrôle de domaine a été défini dans une règle de validation. Le script SQL
va générer le nom de règle en suivant le template défini dans l'entrée
UddtRuleName :
create rule R_Domain_speciality
as
(@Domain_speciality in
('Industry','Military','Nuclear','Bank','Marketing'))
go
execute sp_bindrule R_Domain_speciality,

T_Domain_speciality
go
RuleComment
Instruction permettant d'ajouter un commentaire à une règle.
Exemple comment on rule [%QUALIFIER%]%RULE% is %.q:COMMENT%
Procedure
La catégorie Procedure contient des entrées qui définissent les paramètres
associés aux procédures stockées.
Entrées courantes pour Procedure

l'objet Procedure dans la définition de SGBD.

Enable Enable = Yes
Maxlen Maxlen = 128
Create create procedure %PROC%[(%PROCPRMS%)]
%TRGDEFN%
Drop if exists(select 1 from sys.sysprocedure where

proc_name = '%PROC%') then
drop procedure %PROC%
end if

Catégorie Objects

SqlListQuery {OWNER, @OBJTCODE}
SELECT U.USER_NAME, P.PROC_NAME
WHERE [%SCHEMA% ?
U.USER_NAME='%SCHEMA%' AND]
P.CREATOR=U.USER_ID
SqlAttrQuery {OWNER, @OBJTCODE, SCRIPT, @OBJTLABL}

SELECT U.USER_NAME, P.PROC_NAME,
P.PROC_DEFN, P.REMARKS
WHERE [%SCHEMA% ?
P.CREATOR=U.USER_ID
ORDER BY U.USER_NAME
de base de données
engineering

Permission
Permissions disponibles pour les procédures. La première colonne affiche le
nom SQL de la permission (SELECT, par exemple). La seconde colonne est
le nom abrégé qui s'affiche dans le titre des colonnes de grille.
EXECUTE / Exe
EnableFunc
Détermine si les fonctions sont admises ou non.
Les fonctions sont une forme de procédure qui renvoie à l'environnement une
valeur à utiliser dans des requêtes et dans d'autres instructions SQL.
Valeur Résultat
Yes La fonction est admise
No La fonction n'est pas admise
Exemple EnableFunc = Yes
146 PowerAMC
EnableOwner
Permet de définir des propriétaires pour les procédures.
Valeur Résultat
Yes La liste déroulante Propriétaire s'affiche dans la feuille de propriétés de
procédure et l'utilisateur peut sélectionner un propriétaire pour la
procédure courante
No La procédure ne peut pas prendre en charge les propriétaires
MaxFuncLen
Détermine la longueur maximum du nom d'une fonction.
Exemple MaxFuncLen = 128
CreateFunc
Instruction permettant de créer une fonction.
create function %FUNC%[(%PROCPRMS%)]
%TRGDEFN%
CustomProc
Instruction permettant de créer une procédure stockée.
Les procédures stockées sont des scripts qui utilisent des opérateurs
prédéfinis, des variables, des fonctions et des macros pour gérer et modifier
des données.
create procedure %PROC% (IN <arg> <type>)
begin
.
.
.
end
/

Catégorie Objects
CustomFunc
Instruction permettant de créer une fonction.
Les fonctions définies par l'utilisateur ont la forme d'une procédure qui
renvoie une valeur à l'environnement appelant afin de l'utiliser dans des
requêtes et dans d'autres instructions SQL.
create function %FUNC% (<arg> <type>)
RETURNS <type>
begin
.
.
.
end
/
DropFunc
Instruction permettant de supprimer une fonction.
if exists(select 1 from sys.sysprocedure where proc_name
= '%FUNC%') then
drop function %FUNC%
end if
SqlPermQuery
accordées sur les procédures.
case
end +
case
end
|| ','
o
where
o.name = %.q:PROCEDURE% and
o.uid = u.uid and
148 PowerAMC
s.id = o.id and

u1.uid = s.uid
ProcedureComment
Instruction permettant d'ajouter un commentaire à une procédure.
Exemple comment on procedure [%QUALIFIER%]%PROC% is %.q:COMMENT%
FunctionComment
Instruction permettant d'ajouter un commentaire à une fonction.
Exemple comment on procedure [%QUALIFIER%]%PROC% is %.q:COMMENT%
Trigger
La catégorie Trigger contient des entrées qui définissent les paramètres
associés aux triggers.
Entrées courantes pour Trigger

l'objet Trigger dans la définition de SGBD.

Enable Enable = Yes
Maxlen MaxLen = 30
Drop if exists(select 1 from sys.systrigger where trigger_name
= '%TRIGGER%') then
drop trigger %TRIGGER%
end if
Create create trigger %TRIGGER%[%TRGTIME%=before? no

cascade][ %TRGTIME%][ %TRGEVENT%[ of
%COLUMNS%]] on [%QUALIFIER%]%TABLE%
%TRGDEFN%

Catégorie Objects

SqlListQuery {OWNER, TABLE, TRIGGER, TRGEVENT (C=Update,
D=Delete, *=Insert), TRGTIME (A=After, *=Before)}
SELECT U.USER_NAME, T.TABLE_NAME,
R.TRIGGER_NAME, R.EVENT, R.TRIGGER_TIME
FROM SYSUSERPERMS U,SYSTABLE
T,SYSTRIGGER R
WHERE [%SCHEMA% ?
R.TRIGGER_NAME IS NOT NULL AND
T.CREATOR=U.USER_ID AND R.TABLE_ID =
T.TABLE_ID
ORDER BY U.USER_NAME, T.TABLE_NAME
SqlAttrQuery {OWNER, TABLE, TRIGGER, SCRIPT}

SELECT U.USER_NAME, T.TABLE_NAME,
R.TRIGGER_NAME, R.TRIGGER_DEFN
FROM SYSUSERPERMS U,SYSTABLE
T,SYSTRIGGER R
WHERE [%OWNER% ?
U.USER_NAME='%OWNER%' AND] [%TABLE% ?
T.TABLE_NAME='%TABLE%' AND]
T.CREATOR=U.USER_ID AND R.TABLE_ID =
T.TABLE_ID
ORDER BY U.USER_NAME, T.TABLE_NAME
de base de données
engineering

EnableMultiTrigger
Détermine si plusieurs triggers de même type peuvent être utilisés ou non.
Exemple EnableMultiTrigger = Yes
150 PowerAMC
EnableOwner
Permet de définir des propriétaires de trigger. Le propriétaire de trigger peut
être identique ou différent du propriétaire de table.
Valeur Résultat
trigger et l'utilisateur peut sélectionner un propriétaire pour le trigger
courant
No Le trigger ne prend pas en charge le propriétaire
DefaultTriggerName
Nom de trigger par défaut.
%TEMPLATE%_%.L:TABLE%
UseErrorMsgTable
Gère les erreurs lors de la génération de trigger en utilisant des messages
définis par l'utilisateur.
Lorsque vous sélectionnez Utilisateur dans la page Messages d'erreur de la
boîte de dialogue Régénération des triggers, la macro .ERROR sera
remplacée par le contenu de l'entrée UseErrorMsgTable lors du
processus de régénération.
La macro .ERROR, est appelée par un élément de modèle dans le modèle de
trigger, elle a deux paramètres : %ERRNO% est le numéro d'erreur et
%ERRMSG% est le texte du message.
Les messages utilisateur sont stockés dans une table de messages que vous
devez créer dans votre base de données :
%MSGTAB% Nom de la table
%MSGNO% Colonne de numéro de message qui stocke le numéro du
message d'erreur référencé dans le script de trigger
%MSGTXT% Colonne de texte de message qui stocke le texte du message

Catégorie Objects
Lorsque vous avez sélectionnée l'option Utilisateur pour le type de message

d'erreur, si un numéro d'erreur dans le script du trigger correspond à un
numéro d'erreur dans la table de message, le paramètre de message d'erreur
par défaut de la macro .ERROR est remplacé par le message d'erreur défini
par l'utilisateur dans la table de messages.
begin
select @errno = %ERRNO%,
@errmsg = %MSGTXT%
from %MSGTAB%
where %MSGNO% = %ERRNO%
goto error
end
%MSGNO%, %MSGTAB% et %MSGTXT% seront remplacés par les valeurs
définies dans la colonne de numéro de message, la colonne de texte de
message et la colonne de nom de message dans le tableau de messages.
UseErrorMsgText
Gère les erreurs lors de la génération de triggers en utilisant des messages
d'erreur standard.
Lorsque vous sélectionnez Standard dans la page Messages d'erreur de la
boîte de dialogue Régénération des triggers, la macro .ERROR sera
remplacée par le contenu de l'entrée UseErrorMsgText lors du processus
de régénération.
La macro .ERROR, est appelée par un élément de modèle dans le modèle de
trigger, elle a deux paramètres : %ERRNO% est le numéro d'erreur et
%ERRMSG% est le texte du message.
Si l'option Standard est sélectionnée pour les messages d'erreur, si un numéro
d'erreur dans le script de trigger correspond au paramètre %ERRNO% de la
macro .ERROR, le message correspondant de la macro est utilisé.
begin
select @errno = %ERRNO%,
@errmsg = '%ERRMSG%'
goto error
end
Dans ce cas, le message d'erreur et le texte du message sont directement
utilisés.
152 PowerAMC
TriggerComment
Instruction permettant d'ajouter un commentaire au trigger.
Exemple comment on trigger [%QUALIFIER%]%TRIGGER% is
%.q:COMMENT%
Time
Liste d'attributs de moment de trigger.
Exemple Before
After
Event
Liste d'attributs d'événements de trigger.
Exemple Select
EventDelimiter
Caractère utilisé pour séparer les événements si vous souhaitez affecter
plusieurs événements à un trigger.
Exemple ,
Group
La catégorie Group contient des entrées qui définissent les paramètres
associés aux groupes.
Entrées courantes pour Group

l'objet Group dans la définition de SGBD.
Entrée Exemple (Sybase ASE 12.5)

Enable Enable = Yes

Catégorie Objects

SqlListQuery {GROUP}
select
u.name
from
[%CATALOG%.]dbo.sysusers u
where
u.uid = u.gid and
u.gid not in (select r.lrid from
[%CATALOG%.]dbo.sysroles r)
order by 1
SqlAttrQuery —
Drop sp_dropgroup %GROUP%
sp_addgroup %GROUP%
Create [%BIND%]
[%PRIVILEGE%]
Maxlen —

engineering

Bind
Instruction permettant d'ajouter un membre dans un groupe.
sp_adduser %USERID%, null, %GROUP%
Unbind
Instruction permettant de supprimer un membre d'un groupe.
Exemple Dans Sybase Adaptive Server Anywhere 8.0 :
revoke membership in group %GROUP% from %USER%
154 PowerAMC
Requête SQL permettant de dresser la liste des membres d'un groupe.
{GROUP ID, MEMBER}
select
g.name, u.name
from
[%CATALOG%.]dbo.sysusers u, [%CATALOG%.]dbo.sysusers
g
where
u.suid > 0 and
u.gid = g.gid and
g.gid = g.uid
order by 1
SqlPermQuery
accordées aux groupes.
Role
La catégorie Role contient des entrées qui définissent les paramètres associés
aux rôles.
Entrées courantes pour Role

l'objet Role dans la définition de SGBD.

Enable Enable = Yes
SqlListQuery {ROLE}
select
u.name
from
master.dbo.syssrvroles u
order by 1
SqlAttrQuery —
Drop drop role %ROLE% [with override]

Catégorie Objects

Create create role %ROLE% [with passwd
"%PASSWORD%"]
[%BIND%]
[%PRIVILEGE%]
Maxlen —

engineering

Bind
Instruction permettant d'affecter un rôle à un utilisateur ou à un autre rôle.
grant role %ROLE% to %USERID%
Unbind
Instruction permettant de désaffecter un rôle d'un utilisateur ou d'un autre
rôle.
revoke role %ROLE% from %USER%
156 PowerAMC
Requête SQL qui dresse la liste des utilisateurs auxquels le rôle a été affecté.
{ ROLE ID, MEMBER }
SELECT
r.name, u.name
FROM
master.dbo.sysloginroles l,
[%CATALOG%.]dbo.sysroles s,
[%CATALOG%.]dbo.sysusers u,
[%CATALOG%.]dbo.sysusers r
where
l.suid = u.suid
and s.id =l.srid
and r.uid = s.lrid
SqlPermQuery
accordées aux rôles.
Privilege
La catégorie Privilege contient des entrées qui définissent les paramètres
associés aux privilèges.
Entrées courantes pour Privilege

Vous pouvez définir des valeurs pour les entrées courantes suivantes l'objet
Privilege dans la définition de SGBD.

Enable Enable = Yes
Drop revoke %PRIVLIST% from %USERID%
Create grant %PRIVLIST% to %USERID%
de base de données
engineering

Catégorie Objects

GrantOption
Option pour la commande grant.
with admin option
RevokeOption
Option pour la commande revoke.
System
Liste de privilèges système admis dans le SGBD courant.
CREATE DATABASE
CREATE DEFAULT
CREATE PROCEDURE
CREATE TRIGGER
CREATE RULE
CREATE TABLE
CREATE VIEW
Permission
La catégorie Permission contient des entrées qui définissent les paramètres
associés aux permissions.
Entrées courantes pour Permission

l'objet Permission dans la définition de SGBD.

Enable Enable = Yes
Drop revoke %PERMLIST% on %OBJECTLIST% from %IDLIST%
[%REVOKEOPTION%]
Create grant %PERMLIST% on %OBJECTLIST% to %IDLIST%

[%GRANTOPTION%]
158 PowerAMC

SqlListQuery Requête de liste d'objets

GrantOption
Option pour la commande grant.
with grant option
RevokeOption
Option pour la commande revoke.
cascade
Default
La catégorie Default contient les entrées qui définissent les paramètres
associés aux défauts.
Entrée communes pour Default

l'objet Default dans la définition de SGBD.
Entrée Example (Sybase ASE 12.5)

Enable Enable = Yes

Catégorie Objects
Entrée Example (Sybase ASE 12.5)

SqlListQuery {DEFAULT ID, SCRIPT ...}
select
convert(char(20), d.tdefault),
t.text
from
[%CATALOG%.]dbo.systypes d,
[%CATALOG%.]dbo.syscomments t
where
t.id = d.tdefault
and (t.texttype=0 or t.texttype=2)
[ and d.name = %.q:DOMAIN%]
order by
1, 2
Drop drop default [%QUALIFIER%]%DEFAULT%
Create create default [%QUALIFIER%]%DEFAULT%

as %VALUE%
L'instruction create du défaut

Bind
Commande permettant de lier un défaut à un domaine ou à une colonne.
Lorsqu'un domaine ou une colonne utilise un défaut, ce dernier n'est pas
ajouté mais une instruction binddefault est générée après l'instruction de
création du domaine ou de la table. Dans l'exemple suivant, la colonne
Address dans la table Customer utilise le défaut CITYDFLT :
create table CUSTOMER (
ADDRESS char(10)
null
)
sp_bindefault CITYDFLT, 'CUSTOMER.ADDRESS'

Si le domaine ou la colonne utilise une valeur de défaut directement saisie
dans la liste déroulante Défaut, la valeur de défaut est déclarée sur la ligne de
création de la colonne :
ADDRESS char(10) default 'StdAddress' null
160 PowerAMC
EnableOwner
Permet de définir le propriétaire d'un défaut.
Value Result
défaut et l'utilisateur peut sélectionner un propriétaire pour le défaut
No Le défaut ne prend pas en charge les propriétaires
Unbind
Détache un défaut d'un domaine ou d'une colonne.
Maxlen
Instruction permettant de définir la longueur maximale du code pour un
objet. Cette valeur est mise en oeuvre dans la vérification de modèle et
produit une erreur si le nom ou le code dépasse la valeur définie.
Example MaxLen = 30
Join index
La catégorie Join Index contient des entrées qui définissent les paramètres
associés aux join index.
Entrées courantes pour Join Index

l'objet Join Index dans la définition de SGBD.

Enable Enable = Yes
Maxlen MaxLen = 128

Catégorie Objects
SqlListQuery Dans Adaptive Server IQ:

{JIDX ID, OWNER ID, REFRLIST ...}
SELECT j.joinindex_name, u.user_name,
lt.table_name || ',' || rt.table_name || ','
FROM sysiqjoinindex j, sysuserperm u,
sysiqjoinixcolumn jc, systable lt, systable rt
WHERE j.joinindex_id = jc.joinindex_id
AND j.creator = u.user_id
AND jc.left_table_id = lt.table_id AND jc.right_table_id
= rt.table_id
ORDER BY joinindex_name
Dans Adaptive Server IQ:
SqlAttrQuery
{JIDX ID, OWNER ID, RFJNLIST ...}
SELECT j.joinindex_name, u.user_name,
lt.table_name || '.' || lc.column_name || '=' ||
rt.table_name || '.' || rc.column_name || ','
FROM sysiqjoinindex j, sysuserperm u,
sysiqjoinixcolumn jc, systable lt, systable rt,
syscolumn lc, syscolumn rc
WHERE j.joinindex_id = jc.joinindex_id
AND j.creator = u.user_id
AND jc.left_table_id = lt.table_id AND jc.right_table_id
= rt.table_id
AND jc.left_column_id = lc.column_id AND
jc.right_column_id = rc.column_id
AND lc.table_id = lt.table_id AND rc.table_id =
rt.table_id
ORDER BY joinindex_name
_
Options
if exists(select 1 from sys.sysiqjoinindex where
Drop joinindex_name='%JIDX%') then
drop join index %JIDX%
end if
_
Add
_
DefOptions
create join index %JIDX% for
Create %JIDXDEFN%
de base de données
engineering

162 PowerAMC
Header
En-tête de join index. Tout ce qui est ajouté dans cette entrée est ajouté avant
l'instruction create join index.
Footer
Fin de join index. Tout ce qui est ajouté dans cette entrée est ajouté après
l'instruction create join index.
AddJoin
Instruction SQL utilisée pour définir des jointures pour les index de jointure.
Exemple Table1.coln1 = Table2.coln2
JoinIndexComment
Instruction permettant d'ajouter un commentaire de join index.
Exemple comment on join [%QUALIFIER%]%JIDX% is %.q:COMMENT%
EnableJidxColn
Cette entrée permet d'autoriser l'ajout de colonnes aux join index à l'aide de
la liste des colonnes dans la feuille de propriétés du join index. Dans Oracle
9i, un join index avec une liste de colonnes est un bitmap join index.
EnableOwner
Certains SGBD supportent le concept de propriétaire de join index. Si vous
positionnez cette entrée à oui, la zone Propriétaire s'affiche dans la feuille de
propriétés du join index.

Catégorie Objects
Qualifier
l'objet Qualifier dans la définition de SGBD.

Enable Enable = Yes
SqlListQuery —
Label Label=All Qualifiers

Sequence
La catégorie Sequence contient des entrées qui définissent les paramètres
associés aux séquences.
Entrées courantes pour Sequence

l'objet Sequence dans la définition de SGBD.

Enable Enable = Yes
Create create sequence %SQNC%

[%OPTIONS%]
Drop drop sequence %SQNC%
164 PowerAMC

Options <initial> : composite=yes
{
increment by %d
start with %d
}
<maxvalue> : composite=yes
{
maxvalue %d
nomaxvalue
}
<minvalue> : composite=yes
{
minvalue %d
nominvalue
}
<cycle> %s : list= cycle | nocycle
<cache> : composite=yes
{
cache %d
nocache
}
<order> %s : list= order | noorder
DefOptions —
SqlListQuery {SQNC}
SELECT sequence_name
FROM user_sequences
ORDER BY sequence_name
SqlAttrQuery {SQNC ID, OPTIONS ...}
select
sequence_name,
' increment by ' || increment_by ||
decode(max_value,
999999999999999999999999999, ' nomaxvalue ', -1 ,
' nomaxvalue ' ,' maxvalue ' || max_value ) ||
decode(min_value, 1, ' nominvalue ', -
99999999999999999999999999, ' nominvalue ' , '
minvalue ' || min_value ) ||
decode(cycle_flag, 'N' , ' nocycle ', ' cycle ') ||
decode(cache_size, 20, '', 0, ' nocache ', ' cache ' ||
cache_size) ||
decode(order_flag, 'N', ' noorder ', 'order')
from
user_sequences
order by 1
Rename rename %OLDNAME% to %NEWNAME%
de base de données

Catégorie Objects

engineering

EnableOwner
Permet de définir des propriétaires de séquence.
Valeur Résultat
séquence et l'utilisateur peut sélectionner un propriétaire pour la
séquence courante
No La séquence ne prend pas en charge le propriétaire
SequenceComment
Instruction permettant d'ajouter un commentaire de séquence.
Exemple comment on sequence [%QUALIFIER%]%SQNC% is %.q:COMMENT%
Synonym
La catégorie Synonym contient des entrées qui définissent les paramètres
associés aux synonymes.
Entrées courantes pour Synonym

l'objet Synonym dans la définition de SGBD.
Entrée Exemple (Oracle 9i)

Enable Enable = Yes
Create create [%VISIBILITY% ]synonym

[%QUALIFIER%]%SYNONYM% for
[%BASEOWNER%]%BASEOBJECT%
166 PowerAMC

Drop drop [%VISIBILITY% ]synonym
[%QUALIFIER%]%SYNONYM%
SqlListQuery {OWNER, SYNONYM, BASEOWNER, BASEOBJECT}
[%ISODBCUSER% ?
select
%.q:SCHEMA%,
t.synonym_name,
t.table_owner,
t.table_name
from
sys.user_synonyms t
order by
t.table_name
:
select
t.owner,
t.synonym_name,
t.table_owner,
t.table_name
from
sys.all_synonyms t
where
(1=1)
[ and t.synonym_name=%.q:TABLE%]
[ and t.owner=%.q:SCHEMA%]
order by
t.owner, t.synonym_name
]
SqlAttrQuery —

Maxlen
Instruction permettant de définir la longueur maximum du code pour un
objet. Cette valeur est mise en oeuvre dans la vérification de modèle et
produit une erreur si le nom ou le code dépasse la longueur définie.
Exemple MaxLen = 30
EnableAlias
Instruction permettant de définir si le type d'alias de synonyme est admis.
Exemple Dans DB2 :
EnableAlias = Yes

Catégorie Objects
DB Package
La catégorie DB Package contient des entrées qui définissent les paramètres
associés aux packages de base de données.
Entrées courantes pour DB Package

l'objet DB Package dans la définition de SGBD.

Enable Enable = Yes
Maxlen MaxLen = 30
Create Instruction permettant de créer the specification of the
database package
create [or replace ]package %DBPACKAGE% [authid
%DBPACKAGEPRIV% ][%R%?[is][as]:as]
%DBPACKAGESPEC%
end [%DBPACKAGE%]
Drop drop package %DBPACKAGE%
SqlListQuery {{OWNER, DBPACKAGE}
[%ISODBCUSER% ?
select distinct
%.q:SCHEMA%,
decode (type, 'PACKAGE', name, '')
from
sys.user_source
where
type in ('PACKAGE')
order by
2
:
select distinct
owner,
decode (type, 'PACKAGE', name, '')
from
sys.all_source
where
type in ('PACKAGE')
[ and owner = %.q:SCHEMA%]
order by
1, 2
]
168 PowerAMC

{OWNER ID, DBPACKAGE ID, TYPE ID,
SqlAttrQuery DBPACKAGESPEC ..., DBPACKAGEBODY ...}
[%ISODBCUSER% ?
SELECT %.q:SCHEMA%, NAME, TYPE, TEXT,
NULL, LINE
FROM SYS.USER_SOURCE S
WHERE TYPE = 'PACKAGE' AND LINE > 1 AND
LINE <> (SELECT MAX(S2.LINE) FROM
SYS.USER_SOURCE S2 WHERE S2.TYPE =
S.TYPE AND S2.NAME = S.NAME)
UNION
SELECT %.q:SCHEMA%, NAME, TYPE, NULL,
TEXT, LINE
FROM SYS.USER_SOURCE S
WHERE TYPE = 'PACKAGE BODY' AND LINE > 1
AND LINE <> (SELECT MAX(S2.LINE) FROM
ORDER BY NAME, TYPE, LINE
:
SELECT OWNER, NAME, TYPE, TEXT, NULL, LINE
FROM SYS.ALL_SOURCE S
WHERE TYPE = 'PACKAGE' AND LINE > 1 AND
LINE <> (SELECT MAX(S2.LINE) FROM
UNION
SELECT OWNER, NAME, TYPE, NULL, TEXT, LINE
FROM SYS.ALL_SOURCE S
WHERE TYPE = 'PACKAGE BODY' AND LINE > 1
AND LINE <> (SELECT MAX(S2.LINE) FROM
SYS.ALL_SOURCE S2 WHERE S2.TYPE = S.TYPE
AND S2.NAME = S.NAME)
ORDER BY OWNER, NAME, TYPE, LINE
]
de base de données
engineering


Catégorie Objects
CreateBody
Template permettant de définir le corps du package de base de données.
Cette instruction est utilisée pour l'instruction d'extension AfterCreate.
create [or replace ]package body %DBPACKAGE% as
%DBPACKAGEBODY%
[begin
%DBPACKAGEINIT%
]end [%DBPACKAGE%]
AfterCreate
Instruction d'extension évaluée après l'instruction create DB package.
Pour plus d'informations sur les instructions d'extension, reportez-vous
à la section Génération de script.
DB Package Procedure
La catégorie DB Package Procedure contient des entrées qui définissent les
paramètres associés aux procédures de package.
Entrées courantes pour DB Package Procedure

l'objet DB Package Procedure dans la définition de SGBD.

Add %DBPKPROCTYPE% %DBPKPROC%[
(%DBPKPROCPARAM%)][ return %DBPKPROCRETURN%][
[%R%?[is][as]:as]
%DBPKPROCCODE%]
170 PowerAMC
DBProcedureBody
Template permettant de définir le corps de la procédure de package dans la
page Définition de la feuille de propriétés de procédure de package.
begin
end
ParameterTypes
Types disponibles pour les procédures de package.
in
in out
out
out no copy
DB Package Variable
La catégorie DB Package Variable contient des entrées qui définissent les
paramètres associés aux variables de package.
Entrées courantes pour DB Package Variable

l'objet DB Package Variable dans la définition de SGBD.

Add %DBPKVAR% [%DBPKVARCONST% ]%DBPKVARTYPE%[ :=
%DBPKVARVALUE%]

Catégorie Objects
DB Package Type
La catégorie DB Package Type contient des entrées qui définissent les
paramètres associés aux types de package.
Entrées courantes pour DB Package Type

l'objet DB Package Type dans la définition de SGBD.

Add type %DBPKTYPE%[ is %DBPKTYPEVAR%]
DB Package Cursor
La catégorie DB Package Cursor contient des entrées qui définissent les
paramètres associés aux curseur de package.
Entrées courantes pour DB Package Cursor

l'objet DB Package Cursor dans la définition de SGBD.

Add cursor %DBPKCURSOR% [ (%DBPKPROCPARAM%)][ return
%DBPKCURSORRETURN%][ is
%DBPKCURSORQUERY%]
ParameterTypes
Types disponibles pour le curseur de package.
in
Exemple
172 PowerAMC
DB Package Exception
La catégorie DB Package Exception contient des entrées qui définissent les
paramètres associés aux exceptions de package.
Entrées courantes pour DB Package Exception

l'objet DB Package Exception dans la définition de SGBD.

Add %DBPKEXC% exception
DB Package Parameter
La catégorie DB Package Parameter contient des entrées qui définissent des
paramètres relatifs aux paramètres du package.
Entrées courantes pour DB Package Parameter

l'objet DB Package Parameter dans la définition de SGBD.

Add %DBPKPARM% [%DBPKPARMTYPE% ]%DBPKPARMDTTP%

Catégorie Objects
DB Package Pragma
La catégorie DB Package Pragma contient qui définissent les paramètres
relatifs au pragma de package.
Entrées courantes pour DB Package Pragma

l'objet DB Package Pragma dans la définition de SGBD.

Add pragma %DBPKPRAGMA% (%DBPKPRAGMAOBJ%,
%DBPKPRAGMAPARAM%)
174 PowerAMC
Commandes pour tous les objets

Les commandes suivantes sont définies dans la catégorie Objects et
s'appliquent à tous les objets.
MaxConstLen
Commande permettant de définir la longueur maximale de nom de contrainte
génération.

EnableOption
Commande permettant d'activer les options physiques pour le modèle, les
tables, les index, les clés alternatives et autres objets quis ont pris en charge
par le SGBD cible. Elle contrôle également la disponibilité de la page
Options d'une feuille de propriétés d'objet.

Yes Prend en charge les options La page Options est disponible dans la
physiques, par exemple feuille de propriétés de l'objet
Tablespaces, Storages, ou
options physiques telles que
pctfree et fillfactor
No Ne prend pas en charge les La page Options n'est pas disponible
options physiques dans le feuille de propriétés de l'objet.
Dans la page Base de données de la
boîte de dialogue de génération, tous les
paramètres de génération sont grisés et
ne peuvent pas être sélectionnés

Commandes pour tous les objets
Exemple EnableOption = YES
176 PowerAMC

La catégorie Data type définit les conversions de types de données entre les
types de données PowerAMC et les types de données de SGBD.
AmcdDataType
Table de conversion des types de données qui montre les correspondances
entre les types de données internes de PowerAMC et ceux du SGBD. Cette
table est utilisée pendant la génération d'un MCD vers un MPD ainsi que
lorsque vous changez de SGBD courant. Les variables suivantes sont
utilisées pour qualifier les types de données :
Variable Indique
%n Longueur du type de données
%s Taille du type de données
%p Précision du type de données
En utilisant les variables définies pour qualifier la correspondance,

PowerAMC crée une interface de fait entre ses types de données natifs et
ceux du SGBD choisi.
Type de données
ASE 12 Type de données PowerAMC
A%n char(%n)
VA%n varchar(%n)
LA%n varchar(%n)
BT tinyint

PhysDataType
entre les types de données du SGBD et ceux de PowerAMC. Cette table est
utilisée pendant la génération d'un MPD vers un MCD ainsi que lorsque vous
changez de SGBD courant (utilisation des types de données internes de
PowerAMC pour trouver un correspondance entre deux types de données de
fichier de définition de SGBD). Les variables suivantes sont utilisées pour
qualifier les types de données :
Variable Indique
%n Longueur du type de données
%s Taille du type de données
%p Précision du type de données
En utilisant les variables définies pour qualifier la correspondance,

PowerAMC crée une interface de fait entre ses types de données natifs et
ceux du SGBD choisi.
Type de données
PowerAMC Type de données ASE 12
sysname VA30
integer I
PhysDttpSize
Tableau des tailles de stockage pour les types de données de SGBD.
La taille de stockage appropriée est affectée à chaque type de données pour le
SGBD sélectionné.
Type de données
ASA 6 Taille de Storage
smallmoney 8
smalldatetime 4
datetime 8
timestamp 8
178 PowerAMC
OdbcPhysDataType
entre les types de données ODBC et ceux du SGBD.
Cette table est utilisée lors du reverse engineering via ODBC pour mettre en
correspondance les types de données extraits de la base de données et les
types de données de SGBD. Bien que les types de données soient des
concepts identiques dans la base de données et le SGBD, la façon dont ces
types de données sont stockés dans la base de données diffère de la notation
dans le SGBD. Par exemple, vous pouvez créer une colonne avec le type de
données decimal dans la base de données. Le type de données decimal est
stocké sous la forme decimal(30,6) dans Sybase Adaptive Server
Anywhere 6. Cette précision (30,6) n'apparaissait pas dans votre commande
create, et n'est pas requis lorsque vous utilisez les types de données de
SGBD, "decimal" suffit. Lorsque vous procédez au reverse engineering de la
base de données, le processus extrait des types de données tels qu'ils sont
stockés dans la base de données, i.e. decimal(30,6). A ce stade, PowerAMC
va utiliser la table de conversion pour mettre en correspondance les types de
données ODBC (decimal(30,6)) avec la notation préférée du type de données
SGBD (decimal).
Type de données
ODBC Type de données ASA 6
numeric(30,6) numeric
char(1) char
binary(1) binary
decimal(30,6) decimal

PhysOdbcDataType
Table de conversion des types de données de la base de données cible vers
les types de données ODBC.
Exemple Dans MS Access 95/97 :
Physique Type de données ODBC

Integer Short
LongInteger Long
OLE LongBinary
PhysLogADTType
Table de conversion des types de données abstraits cible vers les types de
données abstraits internes. Vous ne devez pas modifier ces valeurs.
Type de données physique de

base de données Type de données PowerAMC
Java Java
LogPhysADTType
Table de conversion des types de données abstraits internes vers les types de
données abstraits cible. Vous ne devez pas modifier ces valeurs.
Type de données internes Type de données physiques de base

PowerAMC de données
Undefined Array
Undefined List
Java Java
Undefined Object
Undefined Structured
180 PowerAMC
AllowedADT
Liste des types de données abstraits qui peuvent être utilisés comme types de
données pour les domaines et les colonnes.
JAVA
HostDataType
Conversion des types de données de base de données vers les types de
données de procédure.
Exemple Dans Oracle8 :
Type de données internes Type de données physique de

PowerAMC base de données
Number DEC
Number REAL
Number DOUBLE PRECISION
Float FLOAT
Integer INT
Integer INTEGER
Varchar VARCHAR(%n)
Varchar VARCHAR2(%n)

Variables de MPD
Variables de MPD
Vous pouvez incorporer des variables dans les requêtes SQL du SGBD
sélectionné. Ces variables sont remplacées par les valeurs de votre modèle
lors de la génération du script.
Variables pour la génération de base de données, ainsi que celle

des triggers et procedures
Nom de la
variable Commentaire
DATE Date et heure de génération
USER Nom de login de l'utilisateur exécutant la génération
PATHSCRIPT Emplacement pour la génération du fichier script
NAMESCRIPT Nom du fichier script dans lequel les commandes SQL
doivent être écrites
STARTCMD Description des modalités d'exécution du script généré
ISUPPER TRUE si l'option de génération Majuscules est sélectionnée
ISLOWER TRUE si l'option de génération Minuscules est sélectionnée
DBMSNAME Nom du SGBD associé au modèle généré
DATABASE Code de la base de données associée au modèle généré
USE_SP_PKEY Utilise la clé primaire de la procédure stockée pour créer
des clés primaires (spécifique à SQL Server)
USE_SP_FKEY Utilise la clé étrangère de procédure stockée pour créer des
clés primaires (spécifique à SQL Server)
182 PowerAMC
Variables pour le reverse engineering

Nom de la
R Défini à TRUE lors du reverse engineering
S Permet de sauter un mot. La chaîne est analysée pour le
reverse engineering, mais pas générée
D Permet de sauter une valeur numérique. La valeur
numérique est analysée pour le reverse engineering, mais
pas générée
A Permet de sauter tout le texte. Le texte est analysé pour le
reverse engineering, mais pas généré
ISODBCUSER True si l'utilisateur courant est l'utilisateur connecté
CATALOG Nom du catalogue à utiliser dans des requêtes de reverse
engineering ODBC
SCHEMA Variable qui représente un login utilisateur et l'objet
appartenant à cet utilisateur dans la base de données. Vous
devez utiliser cette variable pour les requêtes sur les objets
répertoriés dans les boîtes de dialogue de reverse
engineering ODBC, car leur propriétaire n'est pas encore
défini. Une fois le propriétaire d'un objet défini, vous
pouvez utiliser SCHEMA ou OWNER
SIZE Taille du type de données de la colonne ou du domaine.
Utilisé pour le reverse engineering ODBC, lorsque la
longueur n'est pas définie dans les tables système
VALUE Une valeur de la liste des valeurs dans une colonne ou dans
un domaine
PERMISSION Permet de procéder au reverse engineering de permissions
définies sur des objets de base de données
PRIVILEGE Permet de procéder au reverse engineering de privilèges
définis sur un utilisateur, un groupe ou un rôle

Variables de MPD
Variables pour la synchronisation de base de données

Nom de la
OLDOWNER Nom de l'ancien propriétaire de l'objet. Voir aussi
OWNER
NEWOWNER Nom du nouveau propriétaire de l'objet. Voir aussi
OWNER
OLDQUALIFIER Ancien qualifiant de l'objet. Voir aussi QUALIFIER
NEWQUALIFIER Nouveau qualifiant de l'objet. Voir aussi QUALIFIER
OLDTABL Ancien code de la table
NEWTABL Nouveau code de la table
OLDCOLN Ancien code de la colonne
NEWCOLN Nouveau code de la colonne
OLDNAME Ancien code de la séquence
NEWNAME Nouveau code de la séquence
Variables pour la sécurité dans la base de données

Nom de la
PRIVLIST Liste des privilèges pour une commande grant/revoke
PERMLIST Liste des permissions pour une commande grant/revoke
USER Nom de l'utilisateur
GROUP Nom du groupe
ROLE Nom du rôle
GRANTEE Nom générique utilisé pour concevoir un utilisateur, un
groupe ou un rôle
PASSWORD Mot de passe pour un utilisateur, un groupe ou un rôle
OBJECT Objets de base de données (table, vue, colonne, etc.)
GRANTOPTION Option pour grant : with grant option / with admin option
REVOKEOPTION Option pour revoke : with cascade
184 PowerAMC
Variables pour les métadonnées

Nom de la
@CLSSNAME Nom localisé de la classe de l'objet. Ex : Table, View,
Column, Index
@CLSSCODE Code de la classe de l'objet. Ex : TABL, VIEW, COLN,
INDX
Variables communes pour tous les objets nommés

Nom de la
@OBJTNAME Nom de l'objet
@OBJTCODE Code de l'objet
@OBJTLABL Commentaire de l'objet
@OBJTDESC Description de l'objet
Variables communes pour les objets

Ces objets peuvent être des tables, des index, des vues, etc.
Nom de la
COMMENT Commentaire de l'objet ou son nom (en l'absence de
commentaire)
OWNER Code généré pour l'utilisateur propriétaire de l'objet ou de
son parent. N'utilisez pas cette variable pour les requêtes
sur les objets répertoriés dans les boîtes de dialogue de
reverse engineering ODBC, car leur propriétaire n'est pas
encore défini
DBPREFIX Préfixe de base de données des objets (nom de la base + '.'
si la base est définie)
QUALIFIER Qualifiant de l'objet complet (préfixe de base + préfixe de
propriétaire)
OPTIONS Texte SQL définissant les options physiques pour l'objet

Variables de MPD
Nom de la
CONSTNAME Nom de contrainte de l'objet
CONSTRAINT Corps de la contrainte SQL de l'objet. Ex : (A <= 0) AND
(A >= 10)
CONSTDEFN Définition de contrainte de colonne. Ex : contraint C1
checks (A>=0) AND (A<=10)
RULES Concaténation d'expression serveur des règles de gestion
associée à l'objet
NAMEISCODE True si le nom et le code de l'objet (table, colonne, index)
sont identiques (spécifique AS/400)
Variables relatives aux SGBD, options de base de données

Nom de la
TABLESPACE Code généré pour le tablespace
STORAGE Code généré pour le storage
Variables pour les tables

Nom de la variable Commentaire
TABLE Code généré pour la table
TNAME Nom de la table
TCODE Code de la table
TLABL Commentaire de la table
PKEYCOLUMNS Liste des colonnes de clé primaire. Ex : A, B
TABLDEFN Corps complet de la définition de table. Contient la
définition des colonnes, des contrôles et des clés
CLASS Nom de type de données abstrait
CLUSTERCOLUMNS Liste des colonnes utilisées pour un cluster
186 PowerAMC
Variables pour vérifications sur les domaines et sur les colonnes

Nom de la
UNIT Attribut Unité des paramètre de contrôle
FORMAT Attribut Format des paramètre de contrôle
DATATYPE Type de données. Ex : int, char(10) ou numeric(8, 2)
DTTPCODE Code du type de données. Ex : int, char ou numeric
LENGTH Longueur du type de données. Ex : 0, 10 ou 8
PREC Précision du type de données. Ex : 0, 0 ou 2
ISRDONLY TRUE si l'attribut Lecture seule est sélectionné dans les
paramètres de contrôle standard
DEFAULT Valeur par défaut
MINVAL Valeur minimum
MAXVAL Valeur maximum
VALUES Liste des valeurs. Ex : (0, 1, 2, 3, 4, 5)
LISTVAL Contrainte SQL associée à la liste des valeurs. Ex : C1 in
(0, 1, 2, 3, 4, 5)
MINMAX Contrainte SQL associée aux valeurs minimale et
maximale. Ex : (C1 <= 0) AND (C1 >= 5)
ISMAND TRUE si le domaine ou la colonne est obligatoire
MAND Contient le mot clé "null" ou "not null" selon la valeur de
l'attribut Obligatoire
NULL Contient le mot clé "null" si le domaine ou la colonne est
obligatoire
NOTNULL Contient le mot clé "not null" si le domaine ou la colonne
est obligatoire
IDENTITY Mot clé "identity" si le domaine ou la colonne est de type
Identity (spécifique Sybase)
WITHDEFAULT Mot clé "with default" si le domaine ou la colonne est de
type With default
ISUPPERVAL TRUE si l'attribut Majuscules est sélectionné dans les
ISLOWERVAL TRUE si l'attribut Minuscules est sélectionné dans les

Variables de MPD
Variables pour les colonnes

Les variables de table parent sont également disponibles.
Nom de la
COLUMN Code généré pour la colonne
COLNNO Position de la colonne dans la liste des colonnes de la table
COLNNAME Nom de la colonne
COLNCODE Code de la colonne
PRIMARY Contient le mot clé "primaire" si la colonne est une colonne
de clé primaire
ISPKEY TRUE si la colonne fait partie d'une clé primaire
FOREIGN TRUE si la colonne fait partie d'une clé étrangère
COMPUTE Calcul du texte de la contrainte
Variables pour les types de données abstraits

Nom de la
ADT Code généré du type de données abstrait
TYPE Type du type de données abstrait. Contient des mots clés tels
que "array", "list", …
SIZE Taille du type de données abstrait
FILE Fichier Java du type de données abstrait
ISARRAY TRUE si le type de données abstrait est de type Array
ISLIST TRUE si le type de données abstrait est de type List
ISSTRUCT TRUE si le type de données abstrait est de type Structure
ISOBJECT TRUE si le type de données abstrait est de type Object
ISJAVA TRUE si le type de données abstrait est de type JAVA class
ADTDEF Contient la définition du type de données abstrait
188 PowerAMC
Variable pour les attributs de types de données abstraites

Nom de la
ADTATTR Code généré pour l'attribut de type de données abstrait
Variable pour les domaines

Nom de la
DOMAIN Code généré du domaine (disponible également pour les
colonnes)
DEFAULTNAME Nom de l'objet par défaut associé au domaine (spécifique à
SQL Server)
Variables pour les règles

Nom de la
RULE Code généré pour la règle
RULENAME Nom de la règle
RULECODE Code de la règle
RULECEXPR Expression client de la règle
RULESEXPR Expression serveur de la règle

Variables de MPD
Variables pour ASE & SQL Server

Nom de la
RULENAME Nom de la règle associée au domaine
DEFAULTNAME Nom de l'objet par défaut associé au domaine
USE_SP_PKEY Utilise sp_primary_key pour créer des clés primaires
USE_SP_FKEY Utilise sp_foreign_key pour créer des clés étrangères
Variables pour les séquences

Nom de la
SQNC Nom de la séquence
SQNCOWNER Nom du propriétaire de la séquence
Variables pour les index

INDEX Code généré pour l'index
TABLE Code généré du parent d'un index, peut être une table
ou une table de requête (vue)
INDEXNAME Nom de d'index
INDEXCODE Code d'index
UNIQUE Contient le mot clé "unique" lorsque l'index est
unique
INDEXTYPE Contient le type d'index (disponible uniquement pour
un nouveau SGBD)
CIDXLIST Liste des codes d'index avec séparateur, sur la même
ligne. Exemple : A asc, B desc, C asc
INDEXKEY Contient le mot clé "primary", "unique" ou "foreign"
en fonction de l'origine de l'index
190 PowerAMC

CLUSTER Contient le mot clé "cluster" lorsque l'index est de
type cluster
INDXDEF Liste des colonnes d'index sans séparateur, sur
différentes lignes. Exemple :
ColnA
ColnB
ColnC
Variables pour les join indexes (IQ)

Nom de la
JIDX Code généré pour le join index
JIDXDEFN Corps complet des définitions de join index definition
REFRLIST Liste des références (pour ODBC)
RFJNLIST Liste des références de jointure (pour ODBC)
Variables pour les colonnes d'index

Nom de la
ASC Contient les mots clés "ASC" ou "DESC", selon l'ordre de tri
ISASC TRUE si l'ordre de tri de la colonne d'index est l'ordre
ascendant
Variables pour les références

Nom de la
REFR Code généré pour la référence
PARENT Code généré pour la table parent
PNAME Nom de la table parent

Variables de MPD
Nom de la
PCODE Code de la table parent
PQUALIFIER Qualifiant de la table parent. Voir aussi QUALIFIER.
CHILD Code généré pour la table enfant
CNAME Nom de la table enfant
CCODE Code de la table enfant
CQUALIFIER Qualifiant de la table enfant. Voir aussi QUALIFIER.
REFRNAME Nom de référence
REFRCODE Code de référence
FKCONSTRAINT Nom de contrainte de clé étrangère (référence)
PKCONSTRAINT Nom de contrainte de clé primaire utilisée pour faire
référence à un objet
CKEYCOLUMNS Liste des colonnes de clé parent. Ex : C1, C2, C3
FKEYCOLUMNS Liste des colonnes de clé étrangère. Ex : C1, C2, C3
UPDCONST Contient des mots clés de contrainte déclarative pour les
modifications : "restrict", "cascade", "set null" ou "set
default"
DELCONST Contient des mots clés de contrainte déclarative pour les
suppressions : "restrict", "cascade", "set null" ou "set
default"
MINCARD Cardinalité minimale
MAXCARD Cardinalité maximale
POWNER Nom du propriétaire de la table parent
COWNER Nom du propriétaire de la table enfant
CHCKONCMMT TRUE si vous avez coché la case "check on commit" pour
la référence (spécifique à ASA 6.0)
REFRNO Numéro de référence dans la collection de référence de la
table enfant
JOINS Jointures de référence
192 PowerAMC
Variables de colonnes de référence

CKEYCOLUMN Code généré pour la colonne de table parent (clé
primaire)
FKEYCOLUMN Code généré pour la colonne de table enfant (clé
étrangère)
PK Code généré pour la colonne de clé primaire
PKNAME Nom de la colonne de clé primaire
FK Code généré pour la colonne de clé étrangère
FKNAME Nom de colonne de clé étrangère
AK Code de colonne de clé alternative (identique à PK)
AKNAME Nom de colonne de clé alternative (identique à
PKNAME)
COLTYPE Type de données de colonne de clé primaire
DEFAULT Valeur par défaut de colonne de clé primaire
HOSTCOLTYPE Type de données de colonne de clé primaire utilisé dans
une déclaration de procédure. Par exemple : without
length
Variables pour les clés

COLUMNS Liste des colonnes de la clé. Ex : "A, B, C"
COLNLIST
ISPKEY TRUE lorsque la clé est une clé primaire de table
PKEY Nom de contrainte de clé primaire
AKEY Nom de contrainte de clé alternative
KEY Nom de contrainte de la clé
ISMULTICOLN True si la clé porte sur plusieurs colonnes
CLUSTER Mot clé cluster

Variables de MPD
Variables pour les vues

Nom de la
VIEW Code généré pour la vue
VIEWNAME Nom de la vue
VIEWCODE Code de la vue
VIEWCOLN Liste des colonnes de la vue. Ex : "A, B, C"
SQL Texte SQL de la vue. Ex : Select * from T1
VIEWCHECK Contient le mot clé "with check option" si cette option est
sélectionnée dans la vue
SCRIPT Commande complète de création de la vue. Ex : create view
V1 as select * from T1
Variables pour les triggers

Des variables de table parent sont également disponibles.
Nom de la
ORDER Numéro d'ordre du trigger (si le SGBD prend en charge
plusieurs triggers d'un même type)
TRIGGER Code généré du trigger
TRGTYPE Type de trigger. Contient les mots clés "beforeinsert",
"afterupdate", etc.
TRGEVENT Evénement déclencheur. Contient les mots clés "insert",
"update", "delete"
TRGTIME Moment du déclenchement. Contient les mots clés NULL,
"before", "after"
REFNO Numéro d'ordre de référence dans la liste des références
ERRNO Numéro d'erreur pour une erreur standard
ERRMSG Message d'erreur pour une erreur standard
MSGTAB Nom de la table contenant des messages définis par
l'utilisateur
MSGNO Nom de la colonne contenant des numéros d'erreur dans un
tableau d'erreurs défini par l'utilisateur
194 PowerAMC
Nom de la
MSGTXT Code de la colonne contenant des numéros d'erreur dans un
tableau d'erreurs défini par l'utilisateur
SCRIPT Script SQL du trigger ou de la procédure
TRGBODY Corps du trigger (uniquement pour le reverse engineering
ODBC de Oracle)
TRGDESC Description du trigger (uniquement pour le reverse
engineering ODBC de Oracle)
TRGDEFN Définition de trigger
Variables pour les procédures

Nom de la
PROC Code généré pour la procédure (également disponible pour
un trigger si ce dernier est mis en oeuvre pas une
procédure)
FUNC Code généré pour la procédure si la procédure est une
fonction (avec une valeur de résultat)

Variables de MPD
196 PowerAMC
C H A P I T R E 2
Gestion des profils
Sujet Ce chapitre explique comment gérer les profils PowerAMC.

Sommaire
Section Page
Notions de base relatives au concept de profil 198

Définition d'un stéréotype 206
Définition d'un critère 213
Définition d'un symbole personnalisé dans un profil 215
Définition d'attributs étendus dans un profil 218
Définition d'une vérification personnalisée dans un profil 221
Définition de templates et de fichiers générés dans un profil 229
Définition d'une collection étendue dans un profil 234
Définition d'une méthode dans un profil 237
Définition des transformations dans un profil 241
Définition d'un gestionnaire d'événement dans un profil 247
Définition de menus dans un profil 252
Utilisation de profils : une étude de cas 256

Notions de base relatives au concept de profil

PowerAMC utilise le concept du profil d'UML pour étendre la définition de
son métamodèle afin de fournir des modèles et méthodes personnalisés pour
la construction d'applications différentes.
Prérequis
Il est recommandé de bien connaître la structure et la philosophie du
métamodèle afin de pouvoir faire une utilisation optimale des profils
PowerAMC.
Qu'est-ce qu'un profil ?

Un profil est un mécanisme d'extension utilisé pour la personnalisation d'un
métamodèle à l'aide de sémantiques supplémentaires. Les profils sont utilisés
pour créer des catégories d'objets (stéréotypes et critères), personnaliser les
graphiques des objets, ajouter des métadonnées supplémentaires aux objets
(attributs étendus), définir des fonctionnalités de génération nouvelles ou
modifiées (templates), et ajouter des méthodes, des transformations et des
collections étendues sur les métaclasses et menus.
Vous créez un profil lorsque vous avez besoin de concevoir une
méthodologie utilisateur, un modèle ayant une signification prédéfinie ou
bien pour une cible de génération particulière.
Dans PowerAMC, un profil permet de définir différentes extensions pour les
métaclasses disponibles dans le métamodèle. De telles extensions, telles que
les stéréotypes, les symboles ou les contrôles, sont utilisées pour compléter la
définition standard d'une métaclasse.
Les profils s'affichent dans tous les SGBD, les langages objet et les
définitions étendues de modèle fournis avec PowerAMC. Par défaut, chaque
fichier de ressource est doté d'un profil dès sa création.
Exemple Le Modèle de Processus Métiers PowerAMC permet de concevoir les
différentes tâches internes d'une société ainsi que la façon dont les partenaires
interagissent avec ces tâches et processus.
Si vous sélectionner le langage de processus ebXML, vous bénéficiez de
stéréotypes spécifiques, d'attributs étendus et de templates ainsi que d'autres
extensions adaptées au standard ebXML. Vous pouvez utiliser ces
stéréotypes définis dans le langage de processus ebXML pour définir plus
avant les processus dans votre modèle et les transformer en
<<BinaryCollaboration>>, <<BusinessTransaction>>, etc.
198 PowerAMC
Chapitre 2 Gestion des profils
Pour plus d'informations sur ebXML, reportez-vous au manuel Guide

de l'utilisateur du Modèle de Processus Métiers.
Niveaux Le mécanisme d'extension peut être mis en oeuvre à différents niveaux :
d'extension
Au niveau métaclasse Lorsque vous définissez une extension dans une
métaclasse, cette extension s'applique à toutes les instances de la métaclasse
sélectionnée. L'extension est globale
Au niveau instance Si vous définissez une extension dans un stéréotype

ou dans un critère, cette extension s'applique aux instances ayant le
stéréotype approprié ou qui vérifient la condition du critère. L'extension est
définie sur une base de niveau instance
Héritage Les extensions de profil prennent en charge l'héritage pour permettre de
réutiliser les extensions entre les métaclasses d'un parent commun. Les
extensions communes doivent être définies sur des métaclasses abstraites
pour que la métaclasse concrète hérite d'elles.
Extensions disponibles
Selon le niveau auquel vous définissez les extensions, différents éléments
sont disponibles.
Vous pouvez attacher plusieurs fichiers de ressource à un modèle, il s'agit
alors de plusieurs définitions étendues de modèle ainsi que du langage objet
ou de SGBD du modèle. Les extensions définies dans chaque fichier de
ressource s'affichent dans des pages distinctes pour indiquer leur origine.

Par exemple, dans un MPD, les attributs étendus peuvent être définis pour
une table dans le SGBD ainsi que dans les définitions étendues de modèle
attachées au modèle, ils sont affichés sur différents onglets dans la page
Attributs étendus de la feuille de propriétés de table.
Conflit d'extensions Un conflit se produit lorsque les extensions ayant des noms identiques sont
définies sur les mêmes métaclasses dans différents fichiers de ressources
attachés au même modèle.
Par exemple, le stéréotype <<document>> est défini pour les composants
dans deux définitions étendues de modèle attachées au même MOO. Dans
chaque définition étendue de modèle, le stéréotype <<document>> a un
symbole personnalisé différent. Un conflit se produit dès lors que vous créez
un composant et lui affectez le stéréotype <<document>> : PowerAMC va
sélectionner de façon aléatoire l'un des symboles.
En cas de conflit entre SGBD ou langage objet et définition étendue de
modèle, c'est le plus souvent la définition étendue de modèle qui prévaut.
200 PowerAMC
Extensions de Les extensions définies sur une métaclasse s'appliquent à toutes les instances
métaclasse de la métaclasse. Vous pouvez étendre les sémantiques d'une métaclasse à
l'aide des éléments suivants :
♦ Stéréotypes : ils sont utilisés pour sous-classifier les instances d'une
métaclasse
♦ Attributs étendus : ils sont utilisés pour enrichir la définition d'une
métaclasse ainsi que pour contrôler la génération
♦ Symbole personnalisé et outil personnalisé : ils permettent aux
utilisateurs de mieux identifier la métaclasse
♦ Vérifications personnalisées : elles sont utilisées pour affiner la
vérification de la métaclasse dans votre modèle
♦ Fichiers générés et templates : ils sont utilisés pour personnaliser la
génération pour la métaclasse
♦ Critères : ils sont utilisés pour évaluer des conditions sur une métaclasse
♦ Collections étendues : elles sont utilisées pour ajouter des collections à
des métaclasses
♦ Méthodes : elles peuvent être définies sur une métaclasse
♦ Transformations : elles sont utilisées pendant la génération de modèle
ou directement appliquées dans le modèle
♦ Gestionnaires d'événement : ils sont déclenchés lorsque certains
événements se produisent sur un objet
♦ Menus : ils permettent d'appeler des méthodes pour une instance de
métaclasse
Stéréotype et Les extensions définies pour un stéréotype ou pour un critère s'appliquent aux
critère instances de métaclasse ayant le stéréotype ou vérifiant la condition du
critère.
Vous pouvez définir les extensions suivantes dans un stéréotype ou dans un
critère :
♦ Attributs étendus : ils sont utilisés pour enrichir la définition de
l'instance de métaclasse ainsi que pour contrôler la génération
♦ Symbole personnalisé et outil personnalisé (l'outil personnalisé n'est
disponible que pour les stéréotypes) : ils permettent aux utilisateurs
d'identifier plus facilement l'instance de métaclasse
♦ Vérifications personnalisées : elles sont utilisées pour affiner la
vérification de l'instance de métaclasse dans votre modèle

♦ Fichiers générés et templates : ils sont utilisés pour personnaliser la

génération pour la métaclasse
♦ Collections étendues (uniquement disponibles pour les stéréotypes) :
elles sont utilisées pour ajouter des collections à des métaclasses
♦ Méthodes : elles peuvent être définies sur une métaclasse
♦ Transformations : elles sont utilisées pendant la génération de modèle
ou directement appliquées dans le modèle
♦ Gestionnaires d'événement (uniquement disponibles pour les
stéréotypes) : ils sont déclenchés lorsque certains événements se
produisent sur un objet
♦ Menus : ils permettent d'appeler des méthodes pour une instance de
métaclasse
Ajout d'une métaclasse dans un profil

Selon le type de fichier de ressources sur lequel vous travaillez, la liste des
métaclasses pré-existantes peut changer dans la catégorie Profile.
La procédure d'ajout d'une métaclasse requiert de sélectionner des éléments
parmi une large gamme de métaclasses PowerAMC existantes. Dans la boîte
de dialogue de sélection, vous pouvez utiliser l'outil Modifier le filtre des
métaclasses pour afficher toutes les métaclasses conceptuelles, concrètes ou
abstraites, dans la liste de sélection.
Pour plus d'informations sur le métamodèle PowerAMC, reportez-vous
au chapitre Métamodèle public PowerAMC.
Conventions de Toutes les métaclasses concrètes qui ont un nom et un code affichent la zone
dénomination de de liste déroulante Convention de dénomination de code. Cette liste permet
code de sélectionner un script de conversion du nom en code pour toutes les
instances de la métaclasse sélectionnée. Le processus assure la conversion
automatique des noms en codes en fonction de la convention sélectionnée, et
pourvu que la case Permet les conversions nom-code dans la page
Conventions de dénomination soit cochée.
202 PowerAMC
Vous pouvez choisir l'un des scripts de conversion suivants :
Convention de
dénomination de code Description
firstLowerWord Première lettre en minuscule, ensuite les premières
lettres des autres mots en majuscules
FirstUpperChar Première lettre de chaque mot en majuscules
lower_case Tous les mots en minuscules et séparés par un trait
de soulignement
UPPER_CASE Tous les mots en majuscules et séparés par un trait
de soulignement
Lorsque vous sélectionnez une convention de dénomination de code, le script

de conversion s'affiche comme un paramètre dans la page de script de la boîte
de dialogue des options de modèle dès que vous créez un nouveau modèle ou
modifiez la cible du modèle courant.
Pour plus d'informations sur les scripts de conversion et les conventions
de dénomination, reportez-vous à la section Macros .convert_name &
.convert_code, dans le chapitre Gestion des modèles dans le Guide des
Activer la sélection Lorsque vous ajoutez une métaclasse dans un profil, vous pouvez cocher la
pour la génération case Activer la sélection pour la génération de fichiers afin de faire apparaître
de fichiers les instances de métaclasse dans la page Sélection de la boîte de dialogue de
génération étendue. Si une métaclasse parent est sélectionnée pour la
génération de fichier, les métaclasses enfant sont également affichées dans la
page Sélection.
Pour ajouter une métaclasse dans un profil :

1 Pointez sur la catégorie Profile et cliquez le bouton droit de la souris,
puis sélectionnez Ajouter des métaclasses dans le menu contextuel.
La boîte de dialogue Sélection de métaclasses s'affiche.
2 Cliquez sur l'onglet approprié pour afficher la page contenant la
métaclasse que vous souhaitez sélectionner.
Vous pouvez utiliser l'outil de filtrage pour afficher les métaclasses que
vous souhaitez ajouter au profil.

3 Sélectionnez une ou plusieurs métaclasses.
4 Cliquez sur OK.

La catégorie correspondant aux métaclasses sélectionnées s'affiche sous
la catégorie Profile. Le nom et le parent de la métaclasse ne peuvent pas
être modifiés.
5 <facultatif> Cochez ou décocher la case Activer la sélection pour la

génération de fichiers.
6 <facultatif> Saisissez un commentaire dans la zone Commentaire.
204 PowerAMC
Ajout d'une métaclasse parent

Si la métaclasse parent ne s'affiche pas sous Profile, lorsque vous
cliquez sur l'outil Propriétés en regard de la métaclasse Parent, un
message s'affiche pour vous permettre d'insérer automatiquement le
noeud de la métaclasse sous Profile
Exclusion d'une métaclasse d'un modèle

La case à cocher Exclure du modèle est utilisée pour supprimer toute
référence à la métaclasse sélectionnée dans le modèle. Cette fonctionnalité
n'est pas disponible pour les métaclasses abstraites ou les métaclasses n'étant
pas des métaclasses de conception.
Cette fonctionnalité influe sur les menus, la palette, les feuilles de propriétés
etc, ce pour simplifier l'interface de votre modèle. Par exemple, si vous
n'utilisez pas les règles de gestion, vous pouvez cocher la Case Exclure du
modèle dans la feuille de propriétés de la métaclasse de règle de gestion.
Lorsque plusieurs définitions étendues de modèle et fichiers de ressources

sont définis dans un modèle, la métaclasse est exclue si l'un au moins des
fichiers de ressources exclut cette métaclasse et qu'aucun autre fichier de
ressources ne l'active de façon explicite.
Si un modèle contient déjà des instances de cette métaclasse, les objets sont
conservés mais il est impossible d'en créer de nouveaux.

Définition d'un stéréotype

Les stéréotypes sont utilisés pour classifier les instances et rassembler des
extensions pour une métaclasse qui prend en charge le concept de stéréotype.
Les stéréotypes peuvent également servir à créer une métaclasse à l'intérieur
d'une métaclasse donnée, dans cette section, nous les appellerons stéréotypes
métaclasse. Ce mécanisme transforme le stéréotype en une sorte de
métaclasse : toutes les instances portant le stéréotype métaclasse sont
groupées sous une métaclasse parent dans l'arbre de l'Explorateur ou dans la
boîte de dialogue de fusion. Un stéréotype métaclasse crée également un
sous-espace de nom dans une métaclasse, ce qui permet d'avoir des instances
de même nom mais avec différents stéréotypes métaclasse au sein d'une
même métaclasse.
Les stéréotypes peuvent également servir à créer des sous-classifications au
sein d'une métaclasse donnée. Vous pouvez donner à un stéréotype le statut
de métaclasse à l'intérieur d'une métaclasse existante.
Vous pouvez définir plusieurs stéréotypes pour une métaclasse donnée. Les
stéréotypes que vous créez peuvent être appliqués à n'importe quelle instance
de la métaclasse. Toutefois, les extensions définies dans un stéréotype ne
s'appliquent qu'aux instances auxquelles le stéréotype est appliqué. C'est pour
cette raison que l'utilisation des stéréotypes est considérée comme un
mécanisme d'extension par instance.
Héritage Les stéréotypes prennent en charge l'héritage : les caractéristiques du parent
d'un stéréotype sont héritées par les stéréotypes enfant.
Propriétés de stéréotype
Lorsque vous définissez un stéréotype, vous devez définir les propriétés
suivantes :
Nom Nom du stéréotype tel qui s'affichera dans la liste déroulante
Stéréotype de la feuille de propriétés de l'objet
Parent Nom du parent du stéréotype courant. Vous pouvez utiliser la
liste déroulante pour sélectionner un stéréotype défini dans la
même métaclasse ou dans une métaclasse parent. Vous pouvez
utiliser le bouton Propriétés pour sélectionner le stéréotype
parent dans l'arborescence et afficher ses propriétés
206 PowerAMC
Abstrait Le stéréotype ne peut pas être appliqué aux instances de
métaclasse, ce stéréotype ne s'affiche pas dans la liste
déroulante Stéréotype de la feuille de propriétés de l'objet, et ne
peut être utilisé que comme parent d'autres stéréotypes enfant.
Lorsque vous sélectionnez cette propriété, la case à cocher
Utiliser comme métaclasse n'est pas disponible
Utiliser comme Le stéréotype devient une sous-classification des instances de la
métaclasse métaclasse sélectionnée. Les instances de même stéréotype
seront regroupées dans la catégorie de la métaclasse au niveau
de l'Explorateur ou de la boîte de dialogue de fusion. Cette
option permet également de créer un sous-espace de nom de
façon à avoir dans la même métaclasse des instances de même
nom mais avec différents stéréotypes utilisés comme métaclasse
Outil Si vous cochez cette case, vous pouvez associer un outil dans
personnalisé une palette au stéréotype courant. Cette option est disponible
dans la palette pour les objets qui prennent en charge des symboles, et n'est
pas disponible pour des objets comme les attributs, par exemple
Commentaire Informations supplémentaires relatives au stéréotype
Pour plus d'informations sur l'affectation d'un outil personnalisé à un

stéréotype, reportez-vous à la section Affectation d'un outil à un stéréotype.
Création d'un stéréotype

Vous pouvez créer un ou plusieurs stéréotypes pour une métaclasse donnée.
Vous ne pouvez pas créer un stéréotype au sein d'un autre stéréotype ou au
sein d'un critère.
Pour créer un stéréotype:

1 Pointez sur une métaclasse, cliquez le bouton droit de la souris et
sélectionnez Nouveau→Stéréotype dans le menu contextuel.
Un nouveau stéréotype est créé avec un nom par défaut.
2 Saisissez un nom de stéréotype dans la zone Nom.
3 <facultatif> Sélectionnez un stéréotype parent dans la liste déroulante
Parent.
4 <facultatif> Sélectionnez la case Utiliser comme métaclasse si vous
souhaitez créer une sous-classification à l'intérieur de la métaclasse
courante.

5 <facultatif> Définissez une icône pour le stéréotype à l'aide de l'outil

Rechercher le fichier d'icône et de curseur de l'outil.
6 <facultatif> Cochez la case Outil personnalisé dans la palette pour
associer un outil au stéréotype, puis sélectionnez l'apparence de l'outil.
7 <facultatif> Saisissez un nom par défaut dans la zone Nom par défaut si
vous souhaitez créer un template de nom portant le stéréotype courant.
Une fois que vous avez créé le stéréotype, vous pouvez définir des
extensions telles qu'un outil personnalisé, ou bien des vérifications
personnalisées pour le stéréotype. Ces extensions seront appliquées aux
instances de métaclasse avec le stéréotype.
Utilisation d'un stéréotype comme métaclasse

Les stéréotypes peuvent être utilisés pour créer des sous-classifications à
l'intérieur d'une métaclasse donnée. Vous pouvez sélectionner la case Utiliser
comme métaclasse dans la feuille de propriétés du stéréotype et faire du
stéréotype une métaclasse dans la métaclasse courante.
Cette fonctionnalité permet par exemple d'avoir des objets portant des noms
identiques mais avec des stéréotypes différents dans un même espace de nom.
Elle regroupe également les instances par stéréotypes dans l'Explorateur, les
listes déroulantes ou la boîte de dialogue de fusion pour en faciliter
l'identification.
208 PowerAMC
Pour utiliser un stéréotype comme une métaclasse :

1 Pointez sur une métaclasse, cliquez le bouton droit de la souris, puis
sélectionnez Nouveau→Stéréotype dans le menu contextuel.
Un nouveau stéréotype est créé avec un nom par défaut.
2 Saisissez un nom d et un parent dans les champs correspondants.
3 Sélectionnez la case Utiliser comme métaclasse.
Attacher une icône à un stéréotype

Vous pouvez attacher une icône au stéréotype que vous avez défini pour
identifier les instances de la métaclasse portant le stéréotype. Lorsque vous
affecterez le stéréotype à une instance de métaclasse, celle-ci affichera l'icône
correspondante au lieu de l'icône habituelle dans l'interface PowerAMC.
Aucune icône n'est sélectionnée par défaut, vous pouvez utiliser l'outil
Parcourir pour sélectionner un fichier ayant l'extension .cur ou .ico. Vous
pouvez créer vos propres icônes ou curseurs à l'aide d'éditeurs tiers ou les
acheter à des graphistes.
Si vous sélectionnez la case à cocher Outil personnalisé dans la palette,
l'icône est automatiquement initialisée avec l'icône système, ceci ne vous
empêche pas de la modifier à l'aide de l'outil Parcourir.
Lorsque vous sélectionnez une nouvelle icône, celle-ci est copiée et
enregistrée dans le fichier de ressources. Cette icône s'affiche dans la liste des
icônes disponibles dans la catégorie Outils graphiques personnalisés de la
boîte de dialogue Personnalisation des barres d'outils :

Pour attacher une icône à un stéréotype :

1 Dans la page de propriétés du stéréotype, cliquez sur l'outil Rechercher
le fichier d'icône et de curseur de l'outil pour afficher une boîte de
dialogue standard d'ouverture de fichier dans laquelle vous pouvez
sélectionner un fichier ayant le suffixe .cur ou .ico..
Affectation d'un outil à un stéréotype

Vous pouvez attacher un outil au stéréotype que vous avez défini afin de
faciliter la création d'instances stéréotypées de la métaclasse. Tous les outils
personnalisés s'affichent dans une palette d'outils sous le même nom que le
fichier de ressources auquel ils appartiennent.
L'outil est identique à l'icône de stéréotype. Si vous ne sélectionnez pas
d'icône, l'icône système sera affectée à l'outil par défaut. Vous devez
sélectionner une icône pour modifier l'outil personnalisé du stéréotype.
Pour plus d'informations sur comment attacher une icône à un
stéréotype, reportez-vous à la section Attacher une icône à un stéréotype.
Pour attacher un outil à un stéréotype :

1 Dans la page feuille de propriétés d'un stéréotype, cochez la case Outil
personnalisé dans la palette pour activer les champs situés dans la partie
inférieure de la boîte de dialogue.
210 PowerAMC
2 <facultatif> Sélectionnez une icône pour modifier l'outil par défaut.

Vous pouvez cliquer dans la zone de test pour vérifier l'aspect du
curseur.
Définition de noms par défaut pour des objets stéréotypés

Vous pouvez définir un nom par défaut pour les objets créés à l'aide d'un
outil personnalisé de stéréotype.
Le nom par défaut peut s'avérer très utile lorsque vous concevez pour un
langage cible ou une application ayant des conventions de dénomination
strictes. Toutefois, le nom par défaut ne prévaut pas sur les conventions de
dénomination de modèle, de telle sorte que si un nom ne respecte pas ces
dernières, il est automatiquement modifié.

Vous pouvez utiliser la syntaxe %d pour définir la position du compteur

dans le nom par défaut. Par exemple, vous pouvez définir %d_boundary
comme nom par défaut pour les objets <<boundary>>. Dans ce cas, le
compteur s'affiche avant le nom de l'objet et le troisième objet boundary créé
dans le diagramme sera nommé 3_boundary:
212 PowerAMC
Définition d'un critère

Les critères sont un autre mécanisme d'extension plus générique pour les
métaclasses PowerAMC. Les critères sont également utilisés pour les objets
qui ne prennent pas en charge les stéréotypes, par exemple les objets de
MCD ou de MPD.
Un critère définit une condition avec les expressions utilisées dans la macro
.if du langage de génération par templates (GTL) PowerAMC. Vous pouvez
également utiliser les attributs étendus définis au niveau de la métaclasse
dans la condition du critère, mais vous ne pouvez pas utiliser ceux définis
dans le critère lui-même.
Lorsqu'une instance de métaclasse vérifie les conditions du critère, les
extensions définies sur le critère sont appliquées à cette instance.
Pour plus d'informations sur le langage de génération par templates
PowerAMC et sur la macro .if, reportez-vous au chapitre Guide de référence
de la génération.
Vous pouvez définir un ou plusieurs critères pour une métaclasse
sélectionnée. Les critères permettent de définir les mêmes extensions que les
stéréotypes.
Exemple Dans un MPD, vous pouvez souhaiter personnaliser les symboles des tables
de fait. Vous pouvez créer un critère nommé "type-fait" qui va tester le type
de la table en utilisant la condition suivante :
(%DimensionalType%) == "1"
DimensionalType est un attribut de l'objet BaseTable. Il dispose d'un jeu de
valeurs définies parmi lesquelles 1 correspond aux types dimensionnels de
fait. Vous pouvez afficher cet attribut dans la section Table de la bibliothèque
PdPDM située dans l'aide des objets de script PowerAMC (pdvbs10.chm).
Vous définissez ensuite un symbole personnalisé pour ce critère.
Pour plus d'informations sur les symboles personnalisés, reportez-vous
à la section Définition d'un symbole personnalisé dans un profil.
Pour définir un critère :

1 Pointez sur une métaclasse, cliquez le bouton droit de la souris, puis
sélectionnez Nouveau→Critère dans le menu contextuel.
Un nouveau critère est créé avec un nom par défaut.
2 Modifiez le nom par défaut dans la zone Nom.
3 Saisissez une condition dans la zone Condition.

Définition d'un critère
Dans la syntaxe du critère, vous pouvez utiliser n'importe quelle

expression valide utilisée par la macro .if, mais vous ne devez pas saisir
la macro elle-même.
Pour plus d'informations sur la macro .if, voir la section Utilisation
des macros , reportez-vous à la section Guide de référence de la
génération.
5 Cliquez sur OK.

Pour pouvez définir des extensions pour le nouveau critère.
214 PowerAMC
Définition d'un symbole personnalisé dans un

profil
PowerAMC permet de personnaliser le format des symboles afin de faire en
sorte que le diagramme reflète la sémantique de la métaclasse. Vous pouvez
personnaliser les symboles et le format modifié du symbole peut devenir une
préférence d'affichage par défaut.
Vous pouvez définir un symbole personnalisé par métaclasse, stéréotype ou
critère.
Si vous définissez un symbole personnalisé dans une catégorie de

métaclasse Toutes les instances de la métaclasse et un enfant de cette
métaclasse utiliseront le symbole personnalisé
Si vous définissez un symbole personnalisé dans un stéréotype ou

critère sélectionné Seules les instances ayant le stéréotype ou critère
sélectionné affichent le symbole personnalisé
Dans les autres cas Le format de symbole par défaut tel qu'affiché dans
les préférences d'affichage est utilisé
Personnalisation d'un symbole

Vous pouvez personnaliser le format d'un symbole à l'aide de la boîte de
dialogue Format de symbole. Les paramètres de format sont disponibles via
les différentes pages de cette boîte de dialogue :
♦ Taille : pour définir une taille, l'ajustement automatiquement et les
proportions
♦ Style de trait : pour définir la couleur, l'épaisseur, le style et les angles
des lignes et l'affichage des flèches sur les lignes
♦ Remplissage : pour définir le style et la couleur de remplissage
♦ Ombre : pour ajouter une ombre au symbole et définir sa couleur
♦ Police : pour définir le style et la taille de police
♦ Forme personnalisée : pour modifier la forme par défaut d'un symbole en
sélectionnant parmi des bitmaps, des métafichiers ou des icônes
Pour plus d'informations sur la boîte de dialogue Format de symbole,
reportez-vous à la section Modification de l'apparence d'un symbole dans le
chapitre Manipulations graphiques du manuel Guide des fonctionnalités
générales.
Définition d'un symbole personnalisé dans un profil
Définition d'un symbole personnalisé

Vous ne pouvez définir qu'un seul symbole personnalisé par métaclasse,
stéréotype ou critère. Les enfants de métaclasse héritent de tout symbole
personnalisé défini sur une métaclasse parent.
Lorsque vous créez un symbole personnalisé, le nom de ce symbole est
automatiquement affecté, vous pouvez taper un commentaire dans la zone
correspondante si vous souhaitez compléter la définition du symbole
personnalisé. Vous avez également la possibilité de modifier la taille par
défaut du symbole. La plupart des actions de personnalisation sont effectuées
dans la boîte de dialogue Format de symbole qui s'affiche lorsque vous
cliquez sur le bouton Modifier dans la page Symbole personnalisé.
Pour plus d'informations sur la boîte de dialogue Format de symbole,
reportez-vous à la section Modification de l'apparence d'un symbole dans le
chapitre Manipulations graphiques du manuel Guide des fonctionnalités
générales.
Pour définir un symbole personnalisé :

1 Pointez sur une métaclasse dans la catégorie Profile et cliquez sur le
bouton droit de la souris, puis sélectionnez Nouveau→Symbole
personnalisé.
ou
Pointez sur un stéréotype ou un critère dans une métaclasse, puis
sélectionnez Nouveau→Symbole personnalisé.
Un nouveau symbole est créé sous la catégorie sélectionnée.
3 Définissez une taille par défaut dans la zone de groupe Taille par défaut.
216 PowerAMC
4 Cliquez sur le bouton Modifier pour afficher la boîte de dialogue Format

de symbole.
5 Modifiez le format du symbole dans les différents pages de la boîte de

dialogue Format de symbole.
6 Cliquez sur OK.
7 Cliquez sur Appliquer dans l'éditeur de ressources.

Définition d'attributs étendus dans un profil

Les attributs étendus sont définis pour une métaclasse, un stéréotype ou un
critère. Ils sont utilisés pour compléter la définition de la métaclasse ou de
ses instances afin de :
♦ Contrôler la génération pour une cible de génération donnée. Par
exemple, la définition étendue de modèle pour BEA Weblogic contient
des attributs étendus tels que Weblogic-generator-type utilisés pour
définir un type de générateur
♦ Enrichir la définition des modèles
Les attributs étendus ont un type utilisé pour définir leur type de données et
les valeurs autorisées.
Création d'un type d'attribut étendu

Les types d'attribut étendu sont utilisés pour définir le type de données et les
valeurs autorisées pour des attributs étendus. Les types d'attribut étendu sont
créés dans le dossier Shared. Une fois définis, ces types sont disponibles dans
la liste déroulante Type de données dans la feuille de propriétés d'attribut
étendu.
Pour créer un type d'attribut étendu :

1 Pointez sur la catégorie Profile\Shared, cliquez le bouton droit de la
souris, puis sélectionnez Nouveau→Type d'attribut étendu dans le menu
contextuel.
Un nouveau type d'attribut étendu est créé sous la catégorie
Profile\Shared\Extended Attribute Types.
218 PowerAMC
2 Sélectionnez le type d'attribut étendu et saisissez un nom, un

commentaire, une liste de valeurs et une valeur par défaut dans les zones
appropriées dans le volet droit de l'éditeur.
Création d'un attribut étendu

Un attribut étendu est une autre extension de la définition d'une métaclasse.
Vous pouvez créer un attribut étendu :
♦ Dans la métaclasse si vous souhaitez l'appliquer à toutes les instances de
la métaclasse
♦ Dans un stéréotype ou un critère, si vous souhaitez appliquer l'attribut
étendu à des instances de métaclasse sélectionnées
Les attributs étendus définis dans la métaclasse parent sont hérités par les
métaclasses enfant. Il s'affichent dans l'onglet Attributs étendus d'une feuille
de propriétés d'objet.
Les attributs étendus sont utilisés de la façon suivante lors de la génération :
Si la case Template est cochée L'attribut étendu est considéré comme

un template de GTL et son code est remplacé par les valeurs du modèle lors
de la génération. Par exemple, l'attribut étendu roleBContainer contient le
template %Code%, il sera généré sous la forme "Customer".

Si la case Template est décochée L'attribut étendu est considéré

comme du texte lors de la génération. Par exemple, l'attribut étendu
roleBContainer contient le template %Code%, il sera généré sous la forme
%Code%.
Pour créer un attribut étendu :

bouton droit de la souris, puis sélectionnez Nouveau→Attribut étendu.
ou
sélectionnez Nouveau→Attribut étendu.
Un nouvel attribut étendu est créé sous la catégorie sélectionnée.
2 Sélectionnez le nouvel attribut étendu et saisissez un nom, un
commentaire, un type de données et une valeur par défaut dans les zones
appropriées dans le volet droit de l'éditeur.
220 PowerAMC
Définition d'une vérification personnalisée dans

un profil
Vous pouvez ajouter des vérification personnalisées sur des métaclasses
abstraites et concrètes. Toutefois, les vérifications personnalisées ne sont
pertinentes que sur les métaclasses de modélisation (par exemple, les règles
de gestion) ; elles ne doivent pas être définies sur des objets techniques tels
que les symboles ou éléments de rapport.
Pour plus d'informations sur les métaclasses abstraites et concrètes,
reportez-vous au chapitre Métamodèle public PowerAMC.
Vous pouvez créer des vérifications personnalisées à l'aide du langage de
script Visual Basic.
Pour plus d'informations sur le langage de script Visual Basic, reportez-
vous au chapitre Manipulation des objets via VBScript dans le manuel Guide
des fonctionnalités générales.
Les vérifications personnalisées peuvent être définies sur une métaclasse
mais aussi pour un stéréotype ou un critère.
Lorsque vous définissez une vérification sur une métaclasse Celle-

ci s'applique à toutes les instances de la métaclasse sélectionnée. Les
vérifications personnalisées définies sur une métaclasse abstraite s'affichent
dans toutes ses catégories enfant dans la boîte de dialogue Paramètres de
vérification de modèle. Par exemple, si vous définissez une vérification sur la
métaclasse Classifier, cette vérification s'affiche dans les catégories Classe et
Interface.
Lorsque vous définissez une vérification sur un stéréotype ou un

critère Vous liez la vérification personnalisée à un stéréotype ou à une
condition de critère particulière : si l'objet a le stéréotype approprié ou
remplit la condition, PowerAMC va appeler la vérification personnalisée lors
du processus de vérification du modèle.
Plusieurs vérifications personnalisées peuvent être ajoutées à une métaclasse
donnée, elles vont toutes s'afficher dans la boîte de dialogue Paramètres de
vérification de modèle dans laquelle vous pouvez modifier les paramètres
relatifs au degré de gravité ou à la correction automatique.

Définition d'une vérification personnalisée dans un profil
Propriétés de vérification personnalisée

Lorsque vous créez des vérifications personnalisées, vous devez définir les
propriétés générales suivantes :
Paramètre Description
Nom Nom de la vérification personnalisée. Ce nom s'affiche
sous la catégorie d'objet sélectionnée dans la boîte de
dialogue Paramètres de vérification de modèle. Ce nom
est également utilisé (concaténé) dans le nom de la
fonction de vérification, afin d'identifier cette dernière de
façon unique
Commentaire Informations supplémentaires relatives à la vérification
personnalisée
Message d'aide Texte affiché dans la zone de message qui s'affiche
lorsque l'utilisateur sélectionne Aide dans le menu
contextuel de la vérification personnalisée dans la boîte
de dialogue de vérification de modèle
Message de résultats Texte affiché dans la fenêtre Liste de résultats lors de
l'exécution des vérifications
Sévérité par défaut Permet de définir si la vérification personnalisée
correspond à une erreur (problème majeur dans la syntaxe
du modèle) ou un avertissement (problème mineur ou
simple recommandation)
Exécuter la Permet de vous assurer que cette vérification
vérification par personnalisée est sélectionnée par défaut dans la boîte de
défaut dialogue Paramètres de vérification de modèle
Exécuter la Permet d'autoriser la correction automatique pour la
correction vérification personnalisée
automatique
Exécuter la Permet de vous assurer que la correction automatique
correction correspondant à cette vérification personnalisée est
automatique par exécutée par défaut
défaut
La page Script de vérification permet de définir le corps de la fonction de

vérification personnalisée.
La page Script de correction automatique permet de définir le corps de la
fonction de correction automatique.
La page Script global permet de partager les fonctions de bibliothèque et les
attributs statiques dans le fichier de ressources.
222 PowerAMC
Définition du script d'une vérification personnalisée

Vous pouvez saisir le type d'une vérification personnalisée dans la page
Script de vérification des propriétés de vérification personnalisée. Par défaut,
la page Script de vérification affiche les éléments de script suivants :
♦ %Check% est le nom de la fonction, il est passé sur le paramètre obj. Il
est affiché sous forme de variable, cette variable étant une concaténation
de nom du fichier de ressource, du nom de la métaclasse courante, du
nom du stéréotype ou critère ainsi que du nom de la vérification elle-
même défini dans la page Général. Si l'un de ces noms comporte un
espace, ce dernier est remplacé par un trait de soulignement
♦ Commentaire expliquant le comportement attendu du script
♦ La ligne de valeur de résultat
Exemple Dans Sybase AS IQ, vous devez créer des vérifications supplémentaires sur
les index afin de vérifier leurs colonnes. La vérification personnalisée que
vous allez créer vérifie si les index de type HG, HNG, CMP ou LF sont liés
aux colonnes ayant comme type de données VARCHAR et si la longueur est
supérieure à 255.
Pour définir le script d'une vérification personnalisée :

bouton droit de la souris, puis sélectionnez Nouveau→Vérification
personnalisée.
ou
sélectionnez Nouveau→Vérification personnalisée.
Une nouvelle vérification personnalisée est créée sous la catégorie
sélectionnée.
2 Cliquez sur l'onglet Script de vérification dans la feuille de propriétés de
la vérification personnalisée pour afficher l'éditeur de script.
Par défaut, la fonction est déclarée au début du script. Vous ne devez pas
modifier cette ligne.
3 Saisissez un commentaire après la déclaration de la fonction afin de
documenter la vérification personnalisée.
4 Déclarez les différentes variables utilisées dans le script.
Dim c 'temporary index column
Dim col 'temporary column
Dim position
Dim DT_col

5 Déclarez le corps de la fonction.

%Check%= True
if obj.type = "LF" or obj.type = "HG" or obj.type =

"CMP" or obj.type ="HNG" then
for each c in obj.indexcolumns
set col = c.column
position = InStr(col.datatype,"(")
if position <> 0 then
DT_col = left(col.datatype, position -1)
else
DT_col = col.datatype
end if
if ucase(DT_col) = "VARCHAR" and col.length > 255
then
output "Table " & col.parent.name & "
Column " & col.name & " : Data type is not compatible
with Index " & obj.name & " type " & obj.type
%Check% = False
end if
6 Déclarez la fin de la fonction.
224 PowerAMC
Définition du script d'une correction automatique

Si la vérification personnalisée que vous avez définie prend en charge la
correction automatique, vous pouvez saisir le corps de cette fonction dans la
page Script de correction automatique de la feuille de propriétés de
vérification personnalisée.
La correction automatique est visible dans la boîte de dialogue Paramètres de
vérification de modèle, elle est sélectionnée par défaut si vous cochez la case
Exécuter la correction automatique par défaut dans la page Général de la
feuille de propriétés de la vérification personnalisée.
Par défaut, la page Script de correction automatique affiche les éléments de
script suivants :
♦ %Fix% est le nom de la fonction, il est passé sur le paramètre obj. Il est
affiché sous forme de variable, cette variable étant une concaténation de
nom du fichier de ressource, du nom de la métaclasse courante, du nom
du stéréotype ou critère ainsi que du nom de la correction. Si l'un de ces
noms comporte un espace, ce dernier est remplacé par un trait de
soulignement
♦ La variable outmsg est un paramètre de la fonction de correction. Vous
devez spécifier le message de correction qui va s'afficher lors de
l'exécution du script de correction
Nous allons reprendre l'exemple de la section Définition du script d'une
vérification personnalisée afin de définir un script de correction automatique
qui supprime de l'index les colonnes ayant un type de données incorrect.
Pour définir le script d'une correction automatique :

1 Cliquez sur l'onglet Script de correction automatique dans la feuille de
propriétés de vérification personnalisée.
Par défaut, la fonction est déclarée au début du script. Vous ne devez pas
modifier cette ligne.
2 Saisissez un commentaire après la déclaration de la fonction afin de
documenter la vérification personnalisée.
3 Déclarez les différentes variables utilisées dans le script.
Dim position
Dim DT_col

4 Déclarez le corps de la fonction.

%Fix% = False
If obj.type = "LF" or obj.type = "HG" or obj.type
= "CMP" or obj.type ="HNG" Then
For Each c In obj.IndexColumns
Set col = c.column
position = InStr(col.datatype,"(")
If position <> 0 Then
DT_col = Left(col.datatype, position -1)
Else
DT_col = col.datatype
End If
If (Ucase(DT_col) = "VARCHAR") And
(col.length > 255) Then
outmsg = "Automatic correction has
removed column " & col.Name & " from index."
c.Delete
%Fix% = True
End If
Next
End If
5 Déclarez la fin de la fonction.
226 PowerAMC
Utilisation du script global

La page Script global est utilisée pour stocker les fonctions et attributs
statiques qui peuvent être réutilisés entre les différentes fonctions. Cette page
affiche une bibliothèque de sous-fonctions disponibles.
Exemple Dans l'exemple Sybase AS IQ, vous pouvez utiliser une fonction appelée
DataTypeBase qui extrait le type de données d'un élément afin de mieux
l'analyser.
Cette fonction est définie comme suit :
Function DataTypeBase(datatype)
Dim position
position = InStr(datatype, "(")
If position <> 0 Then
DataTypeBase = Ucase(Left(datatype, position -1))
Else
DataTypeBase = Ucase(datatype)
End If
End Function
Dans ce cas, cette fonction a seulement besoin d'être référencée dans les
scripts de vérification et de correction automatique :
Function %Check%(obj)
Dim position
%Check%= True
If obj.type = "LF" or obj.type = "HG" or obj.type =
"CMP" or obj.type ="HNG" then
For Each c In obj.IndexColumns
Set col = c.column
If (DataTypeBase(col.datatype) = "VARCHAR") And
(col.length > 255) Then
Output "Table " & col.parent.name & " Column
" & col.name & " : Data type is not compatible with
Index " & obj.name & " type " & obj.type
%Check% = False
End If
Next
End If
End Function
Variables globales Vous pouvez également déclarer des variables globales dans le script global.
Ces variables sont réinitialisées chaque fois que vous exécutez la vérification
personnalisée.

Dépannage d'erreurs VB
Les scripts que vous avez définis sont exécutés lors de la vérification du
modèle.
Si des erreurs sont détectées lors de la vérification personnalisée, la
correction automatique ou le script global, une boîte de message s'affiche et
vous propose les actions suivantes :
Bouton Action
Ignorer Permet de sauter le script problématique et de reprendre la
vérification
Ignorer tout Permet de sauter tous les scripts problématiques et de reprendre le
processus avec les vérifications standard
Annuler Arrête la vérification du modèle
Déboguer Arrête la vérification du modèle, ouvre l'éditeur de ressources et
indique sur quelle ligne se trouve le problème. Vous pouvez
corriger les erreurs et redémarrer la vérification du modèle
Exécution d'une vérification personnalisée

Si les vérifications personnalisées sont définies dans différents fichiers de
ressources attachés au modèle courant, toutes les sections globales sont
fusionnées et toutes les fonctions pour toutes les vérifications personnalisées
sont ajoutées pour construire un script unique. Les erreurs potentielles dans
les sections de script global provenant de différentes sources vont provoquer
l'émission de messages d'erreur. L'utilisateur sera invité à ignorer et à
poursuivre la vérification du modèle sans les vérifications personnalisées, ou
à abandonner le processus de vérification afin de régler les problèmes de
script.
La boîte de dialogue Paramètres de vérification de modèle affiche toutes les
vérifications personnalisées définies sur les métaclasses, les stéréotypes et les
critères sous les catégories correspondantes. Une vérification personnalisée
définie sur une métaclasse abstraite s'affiche dans tous les enfants de cette
métaclasse.
228 PowerAMC
Définition de templates et de fichiers générés

dans un profil
Vous définissez maintenant des templates et des fichiers générés dans un
profil, pour une métaclasse, un stéréotype ou un critère sélectionné.
Que sont les Le langage de génération par template (GTL, Generation Template
templates et les Language) de PowerAMC permet de générer des morceaux de texte pour les
fichiers générés? métaclasses. Cette génération peut s'avérer utile pour produire du code (par
exemple, du code JAVA ou C++) et des rapports (extraire des informations
textuelles du modèle) ou pour produire au format d'échange (par exemple, au
format XMI).
Le GTL est utilisé pour générer un fichier (appelé fichier généré) pour une
métaclasse donnée et aussi pour générer du texte pour une métaclasse qui
sera incluse dans un fichier plus global généré pour une autre métaclasse. Ce
texte est appelé template. Il est constitué de texte brut, mélangé à des
variables qui sont composées d'informations provenant du modèle lui-même.
Un fichier est généré pour chaque instance de la métaclasse dans lequel il a
été défini. Si vous définissez un fichier généré pour un stéréotype ou pour un
critère, un fichier sera généré pour chaque instance avec le stéréotype
approprié ou répondant au critère.
Par exemple, si vous définissez un fichier généré dans la métaclasse du
modèle, un seul fichier sera généré par modèle. Toutefois, si vous définissez
un fichier généré dans la métaclasse de la classe, un fichier sera généré pour
chaque classe dans le modèle.
Pour plus d'informations sur la syntaxe du GTL, reportez-vous au
chapitre Guide de référence de la génération.
Création d'un template

La catégorie Template contient des éléments de template. Vous pouvez
accéder aux informations dans le modèle à l'aide de variables. Cette
information peut se présenter sous la forme de simples attributs (par exemple,
le nom d'une classe ou le type de données d'un attribut) ou d'une collection
d'objets (par exemple, la liste des attributs d'une classe) en fonction de la
métaclasse que vous avez définie dans le template.
Vous pouvez utiliser le métamodèle PowerAMC avec le fichier d'aide
pdvbs10.chm pour visualiser les interactions entre les métaclasses. Cela
devrait également vous aider à sélectionner la métaclasse dans laquelle
définir un template.

Définition de templates et de fichiers générés dans un profil
Vous utilisez le GTL pour définir un template. Les templates sont utilisés
dans les fichiers générés : lors de la génération, chaque template est évalué et
remplacé par sa valeur dans le fichier généré.
Les templates peuvent être créés dans la catégorie Shared lorsque vous les
appliquez à toutes les métaclasses. Ils peuvent également être créés au niveau
de la métaclasse ou pour un stéréotype ou critère donné.
Nouvelle syntaxe Dans les version précédentes de PowerAMC, vous pouviez lier l'utilisation
d'un template particulier à l'existence d'un stéréotype à l'aide de la syntaxe
suivante :
template name <<stéréotype>>
Dans la version courant de PowerAMC, vous pouvez créer un template dans
un stéréotype particulier afin de vous assurer que ce template est utilisé
uniquement pour les instances de métaclasse avec le stéréotype.
Outil Parcourir Vous pouvez utiliser l'outil Parcourir pour trouver tous les templates portant
(F12) le même nom. Pour ce faire, ouvrez un template, placez le curseur sur un nom
de template (entre les caractères %) et cliquez sur Parcourir (ou appuyez sur
F12). Vous affichez ainsi une fenêtre Résultats qui répertorie tous les
templates préfixés par le nom de leur métaclasse. Vous pouvez double-
cliquer sur un template dans la fenêtre Résultats pour localiser sa définition
dans l'éditeur de ressources.
Pour créer un template :

bouton droit de la souris, puis sélectionnez Nouveau→Template.
ou
sélectionnez Nouveau→Template.
Un nouveau template est créé sous la catégorie correspondante.
2 Saisissez un nom explicite dans la zone Nom. Il est déconseillé d'utiliser
des espaces dans les noms de template.
3 <facultatif, mais très utile> Saisissez un commentaire dans la zone
Commentaire afin d'expliquer le rôle du template.
4 Saisissez le corps du template à l'aide du GTL dans la zone centrale.
230 PowerAMC
Création d'un fichier généré

La catégorie Generated Files contient des entrées correspondant à des
fichiers. Ces entrées définissent les fichiers qui seront générés pour une
métaclasse donnée ou pour les instances d'une métaclasse avec un stéréotype
ou critère sélectionné.
Vous utilisez le GTL pour définir un fichier généré. Vous pouvez définir des
fichiers générés pour toutes les métaclasses ; toutefois, seuls les fichiers,
définis pour des objets appartenant à une collection de modèle ou de package
seront générés. Les sous-objets, par exemple les attributs, les colonnes ou les
paramètres ne prennent pas en charge la génération de fichier, mais il peut
être intéressant de voir le code généré pour ces sous-objets dans la page
Aperçu.
Vous pouvez identifier les collections de modèle ou de package dans le
métamodèle PowerAMC.
Pour plus d'informations sur la syntaxe GTL, reportez-vous au chapitre
Guide de référence de la génération.
Si une définition étendue de modèle complétant la génération d'un langage
objet contient un nom de fichier généré identique à un nom de fichier généré
défini dans le langage objet, le fichier généré défini dans la définition étendue
de modèle remplace alors le fichier généré dans le langage objet.
Propriétés de Dans la précédente version de PowerAMC, vous deviez définir un template
fichier généré correspondant au type de fichier à générer. Vous pouvez maintenant éditer
directement le template du fichier à générer dans la page de propriétés du
fichier généré.
Les propriétés d'un fichier généré sont les suivantes :
Nom Nom de l'entrée du fichier généré dans l'éditeur de
ressources
Nom de fichier Nom du fichier qui sera généré, il peut contenir des
variables

Définition de templates et de fichiers générés dans un profil
Codage Format du fichier généré, PowerAMC prend en charge
plusieurs formats. Vous pouvez utiliser le bouton Points
de suspension pour afficher la boîte de dialogue Format
de codage pour le texte en sortie dans laquelle vous
pouvez sélectionner un format dans une liste
déroulante. Dans cette boîte de dialogue, la case à
cocher Annuler si perte de caractère permet d'arrêter la
génération si cette dernière provoque la perte de
caractères
Commentaire Informations supplémentaires relatives aux fichiers
générés
Utiliser la hiérarchie Indique que la hiérarchie de packages doit être utilisée
des packages comme pour générer la hiérarchie des répertoires de fichiers
chemin d'accès
Template du fichier Template du fichier à générer. Vous pouvez ouvrir un
généré (zone de texte) éditeur à l'aide de l'outil Editer avec, et si vous utilisez
des templates, vous pouvez utiliser l'outil de recherche
pour rechercher tous les templates du même nom
(reportez-vous à la section Création d'un template)
Coloration Si la zone Nom de fichier est vide, aucun fichier n'est généré. Toutefois, il
syntaxique peut s'avérer utile car il permet d'afficher un aperçu du contenu du fichier
avant la génération. Vous pouvez utiliser la page Aperçu de l'objet
correspondant à tout moment pour ce faire.
Si la zone Nom de fichier contient un caractère '.' (point), aucun fichier n'est
généré, mais vous pouvez utiliser la page Aperçu, comme indiqué ci-avant,
en tirant profit de la coloration syntaxique. Vous pouvez ajouter des suffixes
après le point afin d'utiliser l'éditeur de votre choix (par exemple : .dtd pour
XML).
Pour définir un fichier généré :

bouton droit de la souris, puis sélectionnez Nouveau→Fichier généré.
ou
sélectionnez Nouveau→Fichier généré.
Une nouvelle entrée de fichier est créée sous la catégorie sélectionnée.
3 Saisissez le template du nom pour le fichier à générer dans la zone Nom
de fichier.
232 PowerAMC
4 Sélectionnez un format de codage.

5 <facultatif, mais très utile> Saisissez un commentaire dans la zone
Commentaire afin de décrire le contenu du fichier généré.
6 Cochez la case Utiliser la hiérarchie des packages comme chemin
d'accès si vous souhaitez conserver la hiérarchie de packages.
7 Saisissez la définition du fichier généré dans la zone de texte.

Définition d'une collection étendue dans un profil
Définition d'une collection étendue dans un

profil
Une collection étendue est utilisée pour définir un lien supplémentaire entre
une métaclasse sélectionnée ou un stéréotype d'une part et une autre
métaclasse ou une métaclasse stéréotypée d'autre part.
Dans le métamodèle PowerAMC, les associations entre classes représentent
des collections de métaclasses. La création d'une collection étendue équivaut
à tracer une association entre des métaclasses dans le métamodèle. Cette
fonctionnalité est utile lorsque vous souhaitez créer des collections
supplémentaires sur les métaclasses existantes, elle vous aide également à
gérer de nouveaux types d'objets tels que les objets étendus et les liens
étendus.
Lorsque vous définissez une collection étendue, vous devez sélectionner une
métaclasse ou un stéréotype dans lequel créer cette collection étendue et que
nous appellerons alors métaclasse parent. Vous devez également définir une
métaclasse cible ou une métaclasse stéréotypée. Cette métaclasse cible
s'affiche comme une nouvelle liste d'objets dans la feuille de propriétés de la
métaclasse parent. A l'inverse, la métaclasse parent s'affiche dans la page
Dépendances de la métaclasse cible.
Exemple Lorsque vous souhaitez attacher des documents contenant des spécifications
de cas d'utilisation aux différents packages d'un modèle, vous pouvez utiliser
une collection étendue. Vous créez une collection étendue dans la métaclasse
package et définissez FileObject comme métaclasse cible.
Propriétés d'une collection étendue

Lorsque vous créez une collection étendue, vous devez sélectionner la
métaclasse ou le stéréotype approprié dans lequel créer la collection. Le
choix de cet emplacement déterminera la portée de la collection étendue.
Vous devez également définir les propriétés suivantes :
Nom Nom de la collection étendue
Commentaire Informations supplémentaires relatives à la collection étendue
234 PowerAMC
Nom inverse Nom de la métaclasse parent qui va s'afficher dans la page
Dépendances de la métaclasse cible. Si vous ne saisissez pas
de valeur dans cette zone, un nom inverse est
automatiquement créé et affiché dans la page Dépendances
Type de cible Définit la métaclasse associée à la métaclasse ou au
stéréotype courant. La liste déroulante permet de sélectionner
le type d'objet qui peut être stocké dans la collection (dans
notre exemple, vous sélectionnez FileObject). La liste
déroulante affiche uniquement les métaclasses qui peuvent
être instanciées dans un modèle ou un package comme des
classes ou des tables. Vous ne pouvez pas sélectionner des
sous-objets tels que les attributs de classe ou des colonnes de
table. Assurez-vous de sélectionner un type de cible, faute de
quoi la définition de la collection étendue est ignorée
Stéréotype cible Filtre supplémentaire défini sur la collection étendue. Cette
zone répertorie tous les stéréotypes définis dans le profil
courant pour le type de cible sélectionné. Vous pouvez
également saisir un nouveau stéréotype dans cette zone
Lorsque vous créez une collection étendue sur un stéréotype, la liste d'objets
correspondante s'affiche uniquement si l'instance de la métaclasse parent a le
stéréotype approprié. Si vous changez le stéréotype, la liste disparaît.
Lorsque vous ouvrez un modèle contenant des collections étendues avec un
fichier de ressources qui ne prend pas en charge les collections étendues, les
collections étendues restent visibles dans les différentes feuilles de
propriétés. Ceci vous permet de supprimer des objets dans les collections qui
ne sont plus prises en charge.
Si vous copiez et collez un objet avec des collections étendues Les

objets associés ne sont pas copiés.
Si vous déplacez un objet avec des collections étendues Le lien

avec les objets associés est conservé (si nécessaire à l'aide d'un raccourci).
Création d'une collection étendue
Pour créer une collection étendue :

1 Pointez sur un noeud de métaclasse ou de stéréotype, cliquez le bouton
droit de la souris, puis sélectionnez Nouveau→Collection étendue.
Une collection étendue est créée.

Définition d'une collection étendue dans un profil
2 Saisissez un nom et un code.

3 <facultatif>> Saisissez un nom inverse dans la zone Nom inverse.
4 Sélectionnez une métaclasse dans la zone Type de cible.
5 <facultatif>> Sélectionnez ou saisissez un stéréotype pour la métaclasse
cible dans la zone Stéréotype cible.
236 PowerAMC
Définition d'une méthode dans un profil

Vous pouvez ajouter des méthodes dans n'importe quelle métaclasse
PowerAMC.
Les méthodes peuvent être définies sur des stéréotypes et des critères si vous
souhaitez limiter leur utilisation aux instances de métaclasse ayant des
stéréotypes corrects ou vérifiant certains critères. Les méthodes définies dans
une métaclasse parent sont héritées par les métaclasses enfant.
Une méthode contient un script qui sera exécuté lorsque la méthode sera
appelée, à partir d'une commande de menu par exemple. Le script de la
méthode est défini à l'aide de VBScript.
Pour plus d'informations sur VBScript, reportez-vous au chapitre
Manipulation des objets via VBScript dans le manuel Guide des
Propriétés d'une méthode

Lorsque vous créez une méthode, vous devez sélectionner la métaclasse
appropriée dans laquelle la créer. Ceci détermine la portée de la méthode. Par
exemple, si vous souhaitez qu'une méthode s'applique aux classes et
interfaces, vous devez la définir dans la métaclasse Classifier.
Lorsque vous créez une méthode, vous devez définir les propriétés
suivantes :
Nom Nom de la méthode qui identifie un script
Commentaire Informations supplémentaires relatives à la méthode
La page Script de méthode permet de définir le corps de la fonction de

méthode.
La page Script global permet de partager les fonctions de bibliothèques et
attributs statiques dans le fichier de ressource.

Vous pouvez également utiliser la page Script global pour déclarer des
variables globales. Dans ce cas, n'oubliez pas que les variables globales ne
sont pas réinitialisées chaque fois que la méthode est exécutée. Elles
conservent leurs valeur jusqu'à ce que vous modifiez le fichier de ressources,
ou jusqu'à la fin de la session PowerAMC. Ce comportement peut être la
source d'erreurs, tout particulièrement lorsque des variables font référence à
des objets qui peuvent être modifiés, voire supprimés. N'oubliez pas
d'initialiser la variable globale au début d'une méthode si vous ne souhaitez
pas conserver la valeur de l'exécution précédente.
Pour plus d'informations sur la définition d'un script et l'utilisation de la
page Script global, reportez-vous aux sections Définition du script d'une
vérification personnalisée et Utilisation du script global.
Les méthodes peuvent être utilisées comme commandes dans des menus
définis par l'utilisateur. Il est donc important de créer des méthodes avant de
créer des menus.
Pour plus d'informations sur les menus, reportez-vous à la section
Définition de menus dans un profil.
Création d'une méthode

Lorsque vous créez une méthode, vous devez définir la fonction de la
méthode dans la page Script de méthode. La page Script global est également
disponible et permet de réutiliser les fonctions et sous-procédures. Cette page
est commune aux gestionnaires d'événement et aux transformations.
Vous saisissez le script d'une vérification personnalisée dans la page Script
de méthode de la feuille de propriétés de méthode. Par défaut, la page Script
de méthode affiche les éléments de script suivants :
♦ %Mthd% est le nom de la fonction, il est passé sur le paramètre obj. Ce
nom est affiché sous forme de variable, cette variable est une
concaténation du nom du fichier de ressource, du nom de la métaclasse
courante, du nom du stéréotype ou critère, ainsi que du nom de la
méthode elle-même dans la page Général. Si l'un de ces noms contient
un espace, ce dernier est remplacé par un tiret bas.
♦ Un commentaire expliquant le comportement attendu du script
238 PowerAMC
Par exemple, vous pouvez créer une méthode pour une classe qui convertit
des classes en interfaces. Le script suivant copie les propriétés de base et
opérations de classe, supprime la classe pour éviter tout problème d'espace de
nom et crée la nouvelle interface. Notez que le script ne gère par les autres
propriétés de classe, ni l'affichage de l'interface.
Sub %Mthd%(obj)
' Convertit la class en interface
' Copie les propriétés de base de la classe

Dim Folder, Intf, ClassName, ClassCode
Set Folder = obj.Parent
Set Intf = Folder.Interfaces.CreateNew
ClassName = obj.Name
ClassCode = obj.Code
Intf.Comment = obj.Comment
' Copie les opérations de la classe

Dim Op
For Each Op In obj.Operations
' ...
Output Op.Name
Next
' Détruit la classe

obj.Delete
' Renomme l'interface

Intf.Name = ClassName
Intf.Code = ClassCode
End Sub
Pour créer une méthode :

1 Pointez sur le noeud d'une métaclasse, d'un stéréotype ou d'un critère,
cliquez le bouton droit de la souris, puis sélectionnez
Nouveau→Méthode.
Une méthode est créée.
3 <facultatif>> Saisissez un commentaire dans la zone Commentaire.
4 Saisissez le script dans la page Script de méthode.

5 <facultatif>> Réutilisez les fonctions stockées dans la page Script global.
240 PowerAMC
Définition des transformations dans un profil

Dans PowerAMC, une transformation définit un jeu d'actions à exécuter lors
d'une génération ou sur demande. Vous définissez une transformation dans la
catégorie Profile d'une définition étendue de modèle. Les transformations
peuvent être définies soit sur une métaclasse soit sur un stéréotype ou critère
sélectionné. Les transformations doivent être insérées dans un profil de
transformation pour pouvoir être utilisées lors de la génération de modèle
ou appliquées dans un modèle.
Pour plus d'informations sur le profil de transformations, reportez-vous
à la section Catégorie Transformation profile dans le chapitre Guide de
référence des définitions étendues de modèle.
Vous définissez une transformation lorsque vous avez besoin :
D'un utilitaire permettant de modifier des objets dans un modèle

Afin d'adapter le modèle à des besoins spécifiques. Par exemple, vous
pouvez créer une transformation dans un MOO qui convertit les classes
<<control>> en composants
ou
D'un moyen de modifier un objet tout en conservant la possibilité de

revenir sur cette modification Vous pouvez créer une transformation
pour effectuer une tâche et une autre transformation pour annuler cette tâche.
Cette fonctionnalité peut s'avérer très utile dans le cas d'une ingénierie par
va-et-vient. Supposez que vous génériez un MPD à partir d'un MOO afin de
créer une correspondance O/R. Si le MOO source contient des composants,
vous pouvez créer des transformations qui convertissent des classes à partir
de composants afin de générer facilement des tables dans un MPD et de les
mettre en correspondance. Toutefois, lorsque vous mettez à jour le MOO
source à partir du MPD généré, vous pouvez utiliser une autre transformation
qui va automatiquement recréer les composants à partir des classes
Propriétés d'une transformation

Lorsque vous créez une transformation, vous devez sélectionner la
métaclasse appropriée dans laquelle créer cette transformation. Vous
déterminez ainsi la portée de la transformation. Par exemple, si vous
souhaitez qu'une transformation soit appliquée aux classes et interfaces, vous
devez la définir dans la métaclasse Classifier.

Lorsque vous créez une transformation, vous devez définir les propriétés
suivantes :
Nom Nom de la transformation. Prenez soin de spécifier des noms
explicites afin de les identifier plus facilement dans les listes de
sélection
Commentaire Informations supplémentaires relatives à la transformation
utilisées pour expliquer le script
La page Script de la transformation est utilisée pour définir le corps de la

fonction de transformation. La fonction est écrite en VBScript.
La page Script global est utilisée pour le partage des fonctions de
bibliothèques et des attributs statiques dans le fichier de ressources.
sont pas réinitialisées chaque fois que la transformation est exécutée. Elles
conservent leurs valeur jusqu'à ce que vous modifiez le fichier de ressources,
ou jusqu'à la fin de la session PowerAMC. Ce comportement peut être la
source d'erreurs, tout particulièrement lorsque des variables font référence à
des objets qui peuvent être modifiés, voire supprimés. N'oubliez pas
d'initialiser la variable globale au début d'une transformation si vous ne
souhaitez pas conserver la valeur de l'exécution précédente.
La page Dépendances affiche une liste des profils dans lesquels la
transformation est utilisée.
Les transformations peuvent être utilisées :
♦ Dans un profil de transformation, pour être appliquées lors de la
génération de modèle
Pour plus d'informations sur les transformations utilisées lors de la
génération, reportez-vous à la section Génération avec des
transformations dans le chapitre Gestion des transformations du manuel
Guide des fonctionnalités générales.
♦ Dans un profil de transformation, sur la page post-génération, pour être
utilisées avec la fonctionnalité Appliquer des transformations
242 PowerAMC
Pour plus d'informations sur les transformations, utilisées lors de la

génération, reportez-vous à la section Application des transformations
dans un modèle, dans le chapitre Gestion des transformations du manuel
♦ Sous forme de commande dans un menu défini par l'utilisateur
Pour plus d'informations sur les menus, reportez-vous à la section
Définition de menus dans un profil.
Création d'une transformation

Lorsque vous créez une transformation, vous devez définir la fonction de
transformation dans la page Script de la transformation. La page Script global
est également disponible et permet de réutiliser des fonctions et sous-
procédures.
Par défaut, la page Script de la transformation affiche le script suivant :
Sub %Transformation%(obj, trfm)
obj représente l'objet dans le modèle pour lequel le script est exécuté ; trfm
est un objet transformation interne qui sert à accéder à un jeu de fonctions
helper dans le script.
Pour plus d'informations sur les fonctions helper, reportez-vous à la
section Méthodes helper de script pour les transformations.
Vérifications de Le script de transformation ne requiert pas autant de vérifications que les
script scripts standards. Dans un script standard, vous devez vérifier le contenu d'un
modèle pour éviter les erreurs. Par exemple, un script qui crée et renomme un
composant à partir d'une classe doit contenir un contrôle qui vérifie si le
composant n'existe pas déjà dans le modèle.
Ces vérifications ne sont pas requises dans un script de transformation car les
transformations sont toujours mises en oeuvre dans un modèle temporaire ne
contenant aucun objet. Ce modèle temporaire sera ensuite fusionné avec le
modèle cible de génération si l'option de conservation de modifications est
activée lors de la mise à jour.
Si vous créez une transformation en utilisant un script existant, vous pouvez
supprimer ces contrôles.
Objet Les objets transformation interne ne s'affichent pas dans l'interface de
transformation PowerAMC. Ils sont créés comme objets temporaires et passés au script de
interne sorte que l'utilisateur puisse accéder aux fonctions helper mais aussi pour
enregistrer l'exécution d'une séquence de transformations afin de pouvoir les
exécuter ultérieurement.

Les objets transformation interne sont préservés lorsque les transformations

sont utilisées par la fonctionnalité Appliquer les transformations ou dans un
menu. En effet, lorsque vous mettez à jour un modèle (le régénérez) dans
lequel ce type de transformations a été exécuté, les transformations doivent
être exécutées à nouveau dans le modèle source afin de préserver
l'équivalence entre les modèles source et cible.
Par exemple, MCD1 contient l'entité A, vous générez un MOO à partir de
MCD1 et la classe B est créée. Vous appliquez des transformations à la
classe B dans MOO1, ce qui crée la classe C. Vous souhaitez ensuite
régénérer MCD1 et mettre à jour MOO1 : la classe B sera générée à partir de
l'entité A mais la classe C est manquante dans le modèle généré, ce qui
risquerait de se manifester par une différence dans la boîte de dialogue de
fusion. Toutefois, grâce aux objets transformation interne, les transformations
qui ont été exécutée dans le MOO généré sont ré-exécutées et vous obtenez la
classe C et les modèles à fusionner sont encore plus similaires qu'avant.
Pour créer une transformation :

1 Pointez sur un noeud de métaclasse, de stéréotype ou de critère, cliquez
le bouton droit de la souris et sélectionnez Nouveau→Transformation.
Une transformation est créée.
4 Saisissez le script dans la page Script de la transformation.
244 PowerAMC
Méthodes helper de script pour les transformations

Les scripts de transformation ont accès à des méthodes helper spéciales via
l'objet transformation interne. Ces méthodes sont les suivantes:
Nom Définition Paramètres Renvoie

CopyObject Duplique un objet source : objet à dupliquer Une copie
existant et définit une étiquette* : identificateur du nouvel
source pour l'objet texte de l'objet objet
dupliqué
SetSource Définit l'objet source source : objet source —
d'un objet généré. Il cible : objet cible
est recommandé de étiquette* : identificateur
définir texte de l'objet
systématiquement
l'objet source afin de
pouvoir retrouver
l'origine d'un objet
généré
GetSource Extrait l'objet source cible : objet cible Objet
d'un objet généré étiquette* : identificateur source
texte de l'objet
GetTarget Extrait l'objet cible source : objet source Objet cible
d'un objet source étiquette* : identificateur
texte de l'objet
* étiquette facultative utilisée pour améliorer l'historique de la génération, voir le paragraphe

suivant
Historique de la Le mécanisme d'historique de la génération est utilisé pour extraire

génération l'identificateur de l'objet source afin d'identifier l'origine d'un objet cible et
l'afficher dans la page Version. Cette opération est rendue possible par le fait
qu'il existait une correspondance un-à-un entre les objets source et cible.
Maintenant qu'un objet source peut être transformé et avoir plusieurs cibles,
vous pouvez rencontrer des problèmes pour identifier l'origine d'un objet,
tout particulièrement dans la boîte de dialogue de fusion. Le mécanisme
suivant est utilisé pour aider à identifier l'origine d'un objet :
Si l'objet source est transformé en un seul objet La transformation

est utilisée comme identificateur interne de l'objet cible.

Si l'objet source est transformé en plusieurs objets Pour pouvez

définir une étiquette (tag) pour identifier le résultat de la transformation.
Cette étiquette est une valeur sélectionnée par l'utilisateur qui ne doit
comporter que des caractères alphanumériques. Il est recommandé d'utiliser
une valeur "stable", c'est-à-dire une valeur qui ne risque pas d'être modifiée
lors de générations successives, par exemple un stéréotype. Par exemple,
MOO1 contient la classe Customer, vous appliquez un script de
transformation à cet objet pour créer un EJB. Deux nouvelles classes sont
créées à partir de la classe source : une pour l'interface home, et l'autre pour
l'interface remote. Dans le script de transformation, vous devez affecter une
étiquette “home” pour l'interface home, et “remote” pour l'interface remote.
L'étiquette s'affiche entre signes <> dans la page Version pour un objet, en
regard de l'objet source.
Dans l'exemple suivant, vous utilisez le mécanisme de l'étiquette pour
identifier les classes attachées à un composant :
'setting tag for all classes attached to component
for each Clss in myComponent.Classes
if clss <> obj then
trfm.SetSource obj,Clss," GenatedFromEJB"+ obj.name +"target" +Clss.Name
For each ope in clss.Operations
if Ope.Name = Clss.Code Then 'then it is a constructor _Bean operation
trfm.SetSource obj,Ope," GenatedFromEJB"+ obj.name +"target" +Ope.Name
end if
if Ope.Name = Clss.Name Then 'then it is a constructor operation
end if
if Ope.name = "equals" Then 'then it is an equals operation and should be
tagged
end if
next
end if
next
246 PowerAMC
Définition d'un gestionnaire d'événement dans

un profil
Vous pouvez faire en sorte de lancer automatiquement un script lorsqu'un
événement se produit sur un objet. Cette fonctionnalité permet d'associer du
code VB Script à un événement en utilisant des gestionnaires d'événement.
Notions de base relatives aux gestionnaires d'événement

Vous pouvez associer un gestionnaire d'événement à une métaclasse ou à un
stéréotype ; les critères ne prennent pas en charge les gestionnaires
d'événement.
Chaque gestionnaire d'événement est doté d'une sémantique et de paramètres
prédéfinis. Lorsque vous associez un gestionnaire d'événement à un
stéréotype ou à une métaclasse, le script de gestionnaire d'événement est
initialisé avec les fonctions à mettre en oeuvre. Par exemple, le gestionnaire
d'événement CanCreate prend comme paramètre le parent dans lequel l'objet
sera créé :
Function %CanCreate%(parent)
' Implement your creation validation rule on <parent>
here
' and return True in case of success
%CanCreate% = True
End Function
Vous utilisez la page Script du gestionnaire d'événement pour définir la
fonctionnalité du gestionnaire d'événement et l'adapter à votre modèle et à
vos besoins. La page Script global est utilisée pour partager les fonctions de
bibliothèque et les attributs statiques dans le fichier de ressources.
sont pas réinitialisées chaque fois que le gestionnaire d'événement est
exécuté. Elles conservent leurs valeur jusqu'à ce que vous modifiez le fichier
de ressources, ou jusqu'à la fin de la session PowerAMC. Ce comportement
peut être la source d'erreurs, tout particulièrement lorsque des variables font
référence à des objets qui peuvent être modifiés, voire supprimés. N'oubliez
pas d'initialiser la variable globale au début d'une méthode si vous ne
souhaitez pas conserver la valeur de l'exécution précédente.

Définition d'un gestionnaire d'événement dans un profil
Plusieurs gestionnaires d'événement sont définis dans PowerAMC.

CanCreate Le gestionnaire d'événement CanCreate est utilisé pour mettre en oeuvre une
règle de validation de création. Certains objets ne peuvent pas être créés
n'importe où dans le modèle le gestionnaire d'événement CanCreate s'assure
que cette exigence est remplie. Par exemple, dans un MPM pour ebXML, un
processus ayant le stéréotype BusinessTransactions doit être créé sous un
processus ayant le stéréotype BinaryCollaboration. Le script du gestionnaire
d'événement CanCreate associé au processus ayant comme stéréotype
BusinessTransaction se présente comme suit :
Function %CanCreate%(parent)
if parent is Nothing or parent.IsKindOf(PdBpm.Cls_Process) then

%CanCreate% = False
else
%CanCreate% = True
end if
End Function
Si le gestionnaire d'événement CanCreate est défini sur un stéréotype et que

la valeur de retour de la fonction est True, vous pouvez utiliser l'outil
personnalisé pour crée l'objet personnalisé. Dans le cas contraire, l'outil
personnalisé n'est pas disponible, et la liste déroulante Stéréotype n'affiche
pas le stéréotype correspondant.
Si le gestionnaire d'événement CanCreate est défini sur une métaclasse et
que la valeur de retour de la fonction est True, vous pouvez alors créer l'objet
à partir de la palette d'outils, à partir de l'Explorateur d'objets ou bien dans
une liste.
Modèles importés ou obtenus par reverse engineering

Lorsque vous importez un modèle ou procédez à son reverse engineering,
les fonctions CanCreate sont ignorées car elles pourraient modifier le
modèle et y créer des divergences par rapport au modèle d'origine.
248 PowerAMC
Initialize Le gestionnaire d'événement Initialize est utilisé pour instancier des objets
avec des templates prédéfinis. Par exemple, dans un MPM, un processus
BusinessTransaction doit être un processus composite avec un sous-graphe
prédéfini. Le script du gestionnaire d'événement Initialize associé au
stéréotype de processus BusinessTransaction contient toutes les fonctions
nécessaires pour la création du sous-graphe. L'extrait de script suivant est un
sous-ensemble du gestionnaire d'événement Initialize pour un processus
BusinessTransaction.
...
' Search for an existing requesting activity symbol
Dim ReqSym
Set ReqSym = Nothing
If Not ReqBizAct is Nothing Then
If ReqBizAct.Symbols.Count > 0 Then
Set ReqSym = ReqBizAct.Symbols.Item(0)
End If
End If
' Create a requesting activity if not found

If ReqBizAct is Nothing Then
Set ReqBizAct = BizTrans.Processes.CreateNew
ReqBizAct.Stereotype =
"RequestingBusinessActivity"
ReqBizAct.Name = "Request"
End If
...
Si le gestionnaire d'événement Initialize est défini sur un stéréotype et que la
valeur de retour de la fonction est True, le script d'initialisation sera lancé
chaque fois que le stéréotype est affecté, soit à l'aide d'un outil personnalisé
dans la palette, soit à partir de la feuille de propriétés d'objet.
Si le gestionnaire d'événement Initialize est défini sur une métaclasse et si la
valeur de retour de la fonction est True, le script d'initialisation sera lancé
lorsque vous créez un nouvel objet à partir de la palette d'outils, à partir de
l'Explorateur d'objets, dans une liste, ou bien en utilisant l'outil Nouveau dans
une feuille de propriétés.
Si gestionnaire d'événement Initialize est défini sur la métaclasse model et si
la valeur de retour de la fonction est True, le script d'initialisation est lancé
lorsque vous affectez une cible (SGBD, langage objet, langage de processus,
langage de schéma) au modèle au moment de la création, lorsque vous
changez la cible du modèle ou lorsque vous affectez une définition étendue
de modèle à ce modèle.

Définition d'un gestionnaire d'événement dans un profil
Ajout d'un gestionnaire d'événement à une métaclasse ou à un

stéréotype
Lorsque vous ajoutez un gestionnaire d'événement à une métaclasse ou à un
stéréotype, vous devez sélectionner le type du gestionnaire d'événement, puis
définir le script qui sera exécuté lorsque l'événement se produit.
Pour ajouter un gestionnaire d'événement à une métaclasse ou à un

stéréotype :
1 Pointez sur une métaclasse ou sur un stéréotype, cliquez le bouton droit
de la souris, puis sélectionnez Nouveau→Gestionnaire d'événement.
Une boîte de sélection de gestionnaire d'événement s'affiche.
2 Sélectionnez un ou plusieurs gestionnaires d'événement, puis cliquez sur
OK.
Le gestionnaire d'événement est ajouté dans la catégorie Event Handler
de la métaclasse ou du stéréotype sélectionné.
3 Sélectionnez un gestionnaire d'événement.
La page Général de la feuille de propriétés de gestionnaire d'événement
s'affiche dans le volet droit.
4 Cliquez sur l'onglet Script du gestionnaire d'événement pour afficher la
page correspondante.
5 Saisissez le script du gestionnaire d'événement.
250 PowerAMC
6 Cliquez sur Appliquer, puis répétez l'étape précédente pour chaque

gestionnaire d'événement.

Définition de menus dans un profil

Vous pouvez ajouter des menus dans l'interface de PowerAMC et les remplir
avec des commandes qui appellent des fonctions de méthode ou des
transformations.
Les menus peuvent être définis sur des stéréotypes et critères si vous
souhaitez limiter leur utilisation aux instances de métaclasse ayant le
stéréotype approprié ou répondant à un critère spécifié.
Vous pouvez ajouter des menus sur l'interface de votre choix. Les menus
définis dans une métaclasse parent sont hérités par les métaclasses enfant.
Types de menu Vous pouvez créer des menus de type contextuel qui seront appelés à partir
d'un objet dans l'Explorateur d'objets ou à partir d'un symbole dans le
diagramme. Ces menus peuvent être définis sur n'importe quelle métaclasse.
Vous pouvez généraliser un menu contextuel en le définissant sur une
métaclasse parent telle que BaseObject.
Vous avez également la possibilité d'ajouter un sous-menu dans un menu
principal existant. Ces sous-menus peuvent être définis sur une métaclasse
de modèle ou de diagramme. Les métaclasses Model et Diagram supportent
en fait à la fois les menus contextuels et les sous-menus.
Contenu du menu Un menu peut contenir des commandes, des sous-menus et des
séparateurs :
♦ Une commande de menu appelle une méthode ou une transformation
définie dans la même métaclasse ou dans une métaclasse parent du menu
♦ Un sous-menu est un menu qui s'ouvre en cascade à partir d'un élément
de menu
♦ Un séparateur est une ligne utilisée pour organiser les commandes dans
un menu
Les menus définis sur une métaclasse parent sont hérités par les métaclasses
enfant.
252 PowerAMC
Propriétés d'un menu

Lorsque vous créez un menu, vous devez définir les propriétés suivantes :
Nom Nom du menu qui va apparaître dans l'interface PowerAMC.
Vous pouvez définir une touche de raccourci dans l'entrée de
menu en ajoutant une perluète immédiatement avant le
caractère à utiliser comme touche de raccourci, cette lettre sera
soulignée dans le menu
Commentaire Informations supplémentaires relatives au menu
Emplacement Liste des emplacements où la nouvelle entrée de menu doit
s'afficher. Cette liste est disponible uniquement si la métaclasse
sélectionnée est Model ou Diagram. Dans le cas des
métaclasses d'objet, la valeur unique est Menu contextuel de
l'objet, et donc cachée
Page Menu Zone de création du menu, vous pouvez utiliser des outils pour
faciliter l'ajout de commandes, de menus contextuels et de
séparateurs de menu dans le nouveau menu
Page XML Résumé XML de ce qui est défini dans la page Menu
Outils de la page Vous pouvez utiliser les outils suivants dans la page Menu pour créer des
Menu menus et commandes :
Outil Fonction
Affiche une boîte de dialogue de sélection permettant de sélectionner
une ou plusieurs méthodes ou transformations afin de créer des
commandes associées. Vous pouvez sélectionner parmi les méthodes
ou transformations définies dans la métaclasse courante et ses
métaclasses parent. Lorsque vous sélectionnez une méthode ou une
transformation, cette dernière n'est pas retirée de la liste, car vous
pouvez la réutiliser à différents niveaux de menu
Crée un séparateur sous l'élément sélectionné dans le niveau de menu
courant
Crée un sous-menu sous l'élément de menu sélectionné ou sous le

menu racine
Crée une nouvelle commande dans le menu. La création d'une

commande dans un menu ne se traduit pas par la création de la
méthode ou transformation correspondante dans la métaclasse
appropriée, vous devez créer vous-même la méthode ou
transformation sous la métaclasses appropriée et vous assurer de bien
utiliser le même nom que celui défini dans le menu

Outil Fonction
Supprime l'élément sélectionné dans l'arborescence de menu
Ajout d'une Lorsque vous ajoutez une commande à l'aide d'une méthode ou
commande transformation existante, le contenu suivant est ajouté dans le menu :
<Libellé> (<Nom de méthode/transformation>)
L'élément libellé est le nom de la commande tel qui s'affichera dans le menu.
Vous pouvez définir une touche de raccourci en ajoutant une perluète
immédiatement avant la touche de raccourci, ce caractère s'affiche souligné
dans le menu.
Le nom de méthode/transformation est le nom qui identifie le script.
Synchronisation Les méthodes ou transformations associées aux commandes de menu ne sont
pas synchronisées avec celles définies dans une métaclasse. Si vous modifiez
le nom ou le script d'une méthode ou transformation, vous devez utiliser
l'outil de recherche pour localiser et mettre à jour toutes les commandes qui
utilisent cette méthode ou transformation.
Création d'un menu

Vous pouvez créer des menus contextuels qui s'affichent lorsque vous pointez
sur un noeud dans l'Explorateur d'objets ou un symbole dans le diagramme et
cliquer le bouton droit de la souris. Les menus contextuels peuvent être
définis sur n'importe quelle métaclasse.
Vous pouvez créer des sous-menus dans une métaclasse de modèle ou de
diagramme afin d'ajouter des sous-menus aux menus PowerAMC suivants :
♦ Fichier→Exporter
♦ Outils
♦ Aide
Pour créer un menu :

1 Pointez sur une métaclasse, un stéréotype ou un critère, cliquez le bouton
droit de la souris puis sélectionnez Nouveau→Menu.
Un menu est créé.
254 PowerAMC
4 <uniquement pour les métaclasses Model et Diagram> Sélectionnez

l'emplacement du menu dans la liste déroulante Emplacement.
5 Cliquez sur l'outil Ajouter des commandes à partir de commandes et de
transformations dans la page Menu.
Une boîte de dialogue de sélection s'affiche.
6 Sélectionnez un ou plusieurs éléments, puis cliquez sur OK.
Les commandes sont ajoutées dans le menu. Chaque commande s'affiche
sur une ligne distincte, elle affiche un libellé et le nom de la méthode ou
de la transformation.
7 Editez le libellé pour l'adapter à l'interface.
Rappel
Les méthodes ou transformations de commande ne sont pas
synchronisées avec la définition de méthode ou de transformation.

Utilisation de profils : une étude de cas

Pour illustrer le concept de profil, vous allez construire une définition
étendue du modèle pour un MOO. Cette extension de modèle vous permet de
concevoir un diagramme robustness.
Diagramme Le diagramme robustness est utilisé pour combler le vide existant entre ce
Robustness que le système doit faire et comment il va s'y prendre pour accomplir sa
tâche. Dans l'analyse UML, le diagramme robustness se trouve entre les
diagrammes de cas d'utilisation et le diagramme de séquence. Il permet de
vérifier que le cas d'utilisation est correct et de vous assurer que vous n'avez
pas spécifié un comportement de système déraisonnable compte tenu du jeu
d'objets disponibles. Le diagramme robustness permet également de vérifier
qu'aucun objet ne manque dans le modèle.
Vous allez construire un diagramme robustness à l'aide du diagramme de
collaboration dans le MOO, avec une définition étendue de modèle contenant
un profil utilisateur. Ce profil comporte les extensions suivantes :
♦ Stéréotypes pour objets
♦ Outils personnalisés et symbole pour chaque stéréotype d'objet
♦ Vérifications personnalisées pour les liens d'instance
♦ Fichier généré pour produire une description des messages échangés
entre objets
Vous allez suivre cette étude de cas pour créer une nouvelle définition
étendue de modèle. Cette définition étendue de modèle correspond au fichier
de ressources Robustness.XEM, fourni par défaut et situé dans le dossier
\Fichiers de ressources\Définitions étendues de modèle du répertoire
d'installation de PowerAMC.
256 PowerAMC
Scénario
Vous allez construire la définition étendue de modèle robustness à partir d'un
exemple concret. Le cas d'utilisation suivant représente une transaction Web
de base : un client souhaite connaître la valeur de ses actions afin de décider
s'il va ou non les vendre. Il envoie une requête sur explorateur Internet pour
obtenir la valeur de l'action, la requête est transférée depuis l'explorateur vers
le serveur de bases de données via le serveur d'applications.
Vous allez utiliser le diagramme robustness pour vérifier ce diagramme de

cas d'utilisation.
Pour ce faire, vous allez utiliser un diagramme de collaboration standard et
l'étendre avec un profil.
Attachement d'une nouvelle définition étendue de modèle au

modèle
Dans votre espace de travail, vous avez déjà créé un MOO avec un
diagramme de cas d'utilisation contenant un acteur et trois cas d'utilisation.
Vous devez créer une nouvelle définition étendue de modèle et l'importer
dans le modèle courant avant de commencer la définition du profil.

Pour attacher une définition étendue de modèle au modèle :

1 Sélectionnez Outils→Ressources→Définitions étendues de
modèle→Modèle Orienté Objet.
La boîte de dialogue Liste des définitions étendues de modèle (MOO)
s'affiche.
2 Cliquez sur l'outil Nouveau dans la barre d'outils de la liste.
La boîte de dialogue Nouvelle définition étendue de modèle s'affiche.
3 Saisissez Robustness_Extension dans la zone Nom.
4 Conservez <Template par défaut> dans la zone Copier depuis.
5 Cliquez sur OK.
Une boîte de dialogue standard d'enregistrement s'affiche. Par défaut, le
nom du fichier est identique au nom de la définition étendue de modèle.
6 Cliquez sur Enregistrer.
L'éditeur de définition étendue de modèle s'affiche.
7 Décochez la case Compléter la génération de langage.
Cette définition étendue de modèle n'appartient pas à une famille de
langage objet et ne sera pas utilisée pour compléter une génération de
langage objet.
8 Cliquez sur OK pour fermer l'éditeur de définition étendue de modèle.
258 PowerAMC
9 Cliquez sur Fermer dans la boîte de dialogue Liste des définitions

étendues de modèle.
Une boîte de confirmation vous invite à enregistrer le fichier de
définition étendue de modèle.
10 Cliquez sur Oui.
11 Sélectionnez Modèle→Définitions étendues de modèle.
La boîte de dialogue Liste des définitions étendues de modèle s'affiche.
12 Cliquez sur l'outil Importer une définition étendue de modèle dans la
barre d'outils de la liste.
La boîte de dialogue Sélection des définitions étendues de modèle
s'affiche.
13 Cliquez sur l'onglet Général, puis cochez la case Robustness_Extension.
14 Cliquez sur OK, la définition étendue de modèle s'affiche dans la boîte

de dialogue Liste des définitions étendues de modèle.
15 Cliquez sur OK dans la liste.
16 Pointez sur le noeud du modèle dans l'Explorateur d'objets, cliquez le
bouton droit de la souris puis sélectionnez Nouveau→Diagramme de
collaboration dans le menu contextuel.
La feuille de propriétés du diagramme s'affiche.
17 Saisissez Robustness Diagram dans la zone Nom, puis cliquez sur OK
dans la feuille de propriétés.

Création de stéréotypes d'objet

Le modèle robustness analysis classifie les objets dans trois catégories :
♦ Objets Boundary qui sont utilisés par les acteurs lorsqu'ils
communiquent avec le système, il peut s'agit de fenêtres, d'écrans, de
boîtes de dialogue ou de menus
♦ Objets Entity qui représentent des données stockées telles qu'une base
de données, des tables de base de données ou tout type d'objet
temporaire tel qu'un résultat de recherche
♦ Objets Control qui sont utilisés pour contrôler les objets Interface et
Entité, et qui représentent un transfert d'informations
Pour mettre en oeuvre le modèle robustness analysis dans PowerAMC, vous
allez créer des stéréotypes pour des objets dans le diagramme de
collaboration. Ces stéréotypes correspondent aux trois catégories d'objets
définies ci-avant. Vous allez également attacher des outils personnalisés pour
créer une palette spécialement conçue pour créer des objets avec le
stéréotype <<Entity>>, <<Control>> ou <<Boundary>>.
Vous créez ces stéréotypes dans la catégorie Profile de la définition étendue
de modèle attachée à votre modèle.
Pour créer des stéréotypes d'objet :

1 Sélectionnez Modèle→Définitions étendues de modèle puis double-
cliquez sur la flèche en regard de Robustness_Extension dans la liste
pour afficher l'éditeur de ressources.
260 PowerAMC
2 Pointez sur la catégorie Profile, cliquez le bouton droit de la souris, puis

sélectionnez Ajouter des métaclasses.
3 Sélectionnez UMLObject dans la liste des métaclasses affichées dans la
page PdMOO, puis cliquez sur OK.
La catégorie UMLObject s'affiche sous Profile.
4 Pointez sur la catégorie UMLObject, cliquez le bouton droit de la souris
et sélectionnez Nouveau→Stéréotype.
Un nouveau stéréotype est créé sous la catégorie UMLObject.
5 Saisissez Boundary dans la zone Nom.
6 Cochez la case Outil personnalisé dans la palette.
7 Cliquez sur l'outil Recherche le fichier curseur de l'outil, puis
sélectionnez le fichier boundary.cur dans le dossier
\Exemples\Didacticiel.
8 Répétez les étapes 4 à 7 pour créer le stéréotypes et outils suivants :
Stéréotype Fichier de curseur

Entity entity.cur
Control control.cur
Vous devez à présent voir les 3 stéréotypes sous a catégorie de

métaclasse UMLObject.

9 Cliquez sur OK.

10 Cliquez sur Oui pour enregistrer la définition étendue de modèle.
La palette d'outils avec les outils de stéréotype s'affiche dans le
diagramme.
11 Déplacez la Liste des définitions étendues de modèle en bas de l'écran.

12 Cliquez sur l'un des outils, puis cliquez dans le diagramme de
collaboration.
Un objet ayant le stéréotype prédéfini est créé :
13 Cliquez sur le bouton droit de la souris pour libérer l'outil.
Définition de symboles personnalisés pour les stéréotypes

Vous allez définir un symbole personnalisé pour les entrées de UMLObject
associées au stéréotypes Boundary, Control ou Entity. La fonctionnalité de
symbole personnalisé permet d'appliquer les graphiques du diagramme
robustness dans votre diagramme de collaboration.
Pour définir des stéréotypes personnalisés pour les stéréotypes :

1 Double-cliquez sur la flèche en regard de Robustness_Extension dans la
liste des définitions étendues de modèle pour afficher l'éditeur de
ressources.
2 Pointez sur le stéréotype Boundary dans la catégorie UMLObject,
cliquez le bouton droit de la souris, puis sélectionnez
Nouveau→Symbole personnalisé.
Un symbole personnalisé est créé.
3 Cliquez sur le bouton Modifier.
La boîte de dialogue Format de symbole s'affiche.
4 Cliquez sur l'onglet Forme personnalisée.
5 Cochez la case Activer la forme personnalisée.
6 Sélectionnez Symbole prédéfini dans la liste déroulante Type de forme.
262 PowerAMC
7 Sélectionnez Boundary Object dans la liste déroulante liste déroulante

Nom de la forme.
8 Cliquez sur OK.

Le symbole personnalisé s'affiche dans la zone Exemple.

9 Répétez les étapes 2 à 8 pour les stéréotypes suivants :
Stéréotype Nom de la forme

Entity Entity Object
Control Control Object
10 Cliquez sur OK dans les boîtes de dialogue successives.

Le symbole de l'objet que vous aviez créé change en fonction du
stéréotype :
11 Dans le diagramme de collaboration, créez un objet correspondant à

chaque stéréotype.
264 PowerAMC
Votre diagramme contient maintenant 3 objets ayant des symboles

différents qui correspondent aux différents stéréotypes.
12 Sélectionnez Modèle→Objets pour afficher la liste des objets.

13 Cliquez sur l'outil Personnaliser les colonnes et filtrer dans la barre
d'outils de la liste, puis sélectionnez Stéréotype dans la liste des
colonnes.
Les stéréotypes d'objet s'affichent dans la liste. Vous allez définir le nom
et le code de chaque objet en fonction de leur stéréotype.
Objet Stéréotype Nom & code

Objet_1 <<Boundary>> Explorateur Internet
Objet_2 <<Control>> Serveur d'applications
Objet_3 <<Entity>> Serveur de bases de données

14 Cliquez sur OK dans la liste des objets.

15 Faites glisser l'acteur Client de l'Explorateur d'objets dans le diagramme
de collaboration afin de créer un symbole pour Client.
Création de liens entre objets et de messages entre objets

Vous allez créer des liens entre objets afin d'exprimer la collaboration entre
ces objets :
Source Destination
Client Explorateur Internet
Explorateur Internet Serveur d'applications
Serveur Serveur de bases de données
d'applications
Pour plus d'informations sur la création de liens entre objets dans le

diagramme de collaboration, reportez-vous à la section Création d'un lien
entre objets dans un diagramme de collaboration, dans le chapitre
Construction d'un diagramme de collaboration du manuel Guide de
l'utilisateur du MOO.
Vous pouvez définir des messages sur les différents liens entre objets afin
d'exprimer les données transportées par les liens.
Pour plus d'informations sur la création de messages sur les liens entre
objets dans le diagramme de collaboration, reportez-vous à la section
Création d'un message dans un diagramme de collaboration, dans le chapitre
Construction d'un diagramme de collaboration dans le manuel Guide de
l'utilisateur du MOO.
Vous allez créer les messages suivants :
Numéro
Direction Nom du message d'ordre
Client - Explorateur Internet Demande de cotation 1
Explorateur Internet - Serveur Demande valeur à serv. 2
d'applications app
Serveur d'applications - Serveur de Demande valeur à bd 3
bases de données
Serveur de bases de données - Serveur Renvoie valeur de bd 4
d'applications
266 PowerAMC
Numéro
Direction Nom du message d'ordre
Serveur d'applications - Explorateur Renvoie valeur de serv 5
Internet app
Explorateur Internet - Client Renvoie valeur 6
Création de vérifications personnalisées sur les liens d'instance

L'analyse Robustness implique certaines règles relatives au comportement
entre les objets. Par exemple, un acteur doit toujours communiquer avec un
objet Boundary (une interface), les objets Entity doivent toujours
communiquer avec les objets Control, etc. Pour représenter ces contraintes,
vous allez définir des vérifications personnalisées sur les liens entre objets.
Les vérifications personnalisées n'empêchent pas les utilisateurs de se livrer à
des actions incorrectes du point de vue de la syntaxe, mais leur permet de
définir des règles qui seront vérifiées par la fonctionnalité de vérification de
modèle.
Vous pouvez définir des vérifications personnalisées à l'aide de VB
Scripting.

Pour plus d'informations sur la syntaxe VBS, reportez-vous au chapitre

Accès aux objets à l'aide de VBScript dans le manuel Guide des
Pour créer des vérifications personnalisées sur les liens entre

objets :
1 Double-cliquez sur la flèche en regard de Robustness_Extension dans la
boîte de dialogue Liste des définitions étendues de modèle pour afficher
l'éditeur de ressources.
3 Sélectionnez InstanceLink dans la liste des métaclasses affichées dans la
La catégorie InstanceLink s'affiche sous Profile.
4 Pointez sur la catégorie InstanceLink, cliquez le bouton droit de la souris
et sélectionnez Nouveau→Vérification personnalisée.
Une nouvelle vérification est créée.
5 Saisissez Collaboration d'acteur incorrecte dans la zone Nom.
Cette vérification contrôle si les acteurs sont liés aux objets Interface. Le
fait de lier des acteurs aux objets Contrôle ou Entité n'est pas admis dans
robustness analysis.
6 Saisissez "Cette vérification s'assure que les acteurs ne communiquent
qu'avec les objets Boundary." dans la zone Message d'aide.
Ce texte s'affiche dans la boîte de message qui apparaît lorsque
l'utilisateur sélectionne Aide dans le menu contextuel de la vérification
(dans la boîte de dialogue Paramètres de vérification de modèle).
7 Saisissez " Les liens entre objets suivants sont incorrects :" dans la zone
Message de résultats.
8 Sélectionnez Erreur comme sévérité par défaut.
268 PowerAMC
9 Cochez la case Exécuter la vérification par défaut.
10 Cliquez sur l'onglet Script de vérification.

La page Script de vérification permet de saisir le script pour la
vérification supplémentaire.
11 Saisissez le script suivant dans la zone de texte.
Function %Check%(link)
' Default return is True
%Check% = True
' L'objet doit être un lien entre objets
If link is Nothing or not
link.IsKindOf(PdMOO.cls_InstanceLink) then
Exit Function
End If
' Extrait les extrémités du lien
Dim src, dst
Set src = link.ObjectA
Set dst = link.ObjectB
' Source est un acteur
' Appelle la fonction globale CompareObjectKind()
définie dans le volet Script global
If CompareObjectKind(src, PdMOO.Cls_Actor) Then
' Vérifie si la destination est un objet UML
avec le stéréotype "Boundary"
If not CompareStéréotype(dst,
PdMOO.Cls_UMLObject, "Boundary") Then
%Check% = False
End If
Elsif CompareObjectKind(dst, PdMOO.Cls_Actor) Then
' Vérifie si la source est un objet UML avec le
stéréotype "Boundary"
If not CompareStéréotype(src,
PdMOO.Cls_UMLObject, "Boundary") Then

%Check% = False
End If
End If
End Function
12 Cliquez sur l'onglet Script global.
La page Script global est la page dans laquelle vous stockez des
fonctions et des attributs statiques qui peuvent être réutilisés entre les
différentes fonctions.
13 Saisissez le script suivant dans la zone de texte.
' Cette fonction globale vérifie si un objet a un
type particulier
' ou s'il est un raccourci d'un type particulier
Function CompareObjectKind(Obj, Kind)
' La valeur par défaut est false
CompareObjectKind = False
' Vérifie l'objet
If Obj is Nothing Then
Exit Function
End If
' Cas particulier du raccourci, recherche de son
objet cible
If Obj.IsShortcut() Then
CompareObjectKind =
CompareObjectKind(Obj.TargetObject)
Exit Function
End If
If Obj.IsKindOf(Kind) Then
' Correct object kind
CompareObjectKind = True
End If
End Function
' Cette fonction globale vérifie si un objet a un
type particulier
' et compare sa valeur de stéréotype
Function CompareStéréotype(Obj, Kind, Value)
' La valeur par défaut est false
CompareStéréotype = False
' Vérifie l'objet
If Obj is Nothing or not
Obj.HasAttribute("Stéréotype") Then
Exit Function
End If
' Cas particulier du raccourci, recherche de son
objet cible
If Obj.IsShortcut() Then
CompareStéréotype =
CompareStéréotype(Obj.TargetObject)
Exit Function
End If
If Obj.IsKindOf(Kind) Then
' Type d'objet correcte
270 PowerAMC
If Obj.Stéréotype = Value Then

' Stéréotype correct
CompareStéréotype = True
End If
End If
End Function
Vous allez répéter les étapes 4 à 14 et créer une vérification s'assurant
qu'un lien entre objets n'est pas défini entre objets Boundary :
Définition de vérification Contenu

Nom Incorrect Boundary to Boundary Link
Message d'aide Cette vérification s'assurer qu'un lien
entre objets n'est pas défini entre
deux objets Interface
Message de résultats Les liens suivants entre objets
Interface sont incorrects :
Sévérité par défaut Erreur
Exécuter la vérification par défaut Coché
15 Saisissez la vérification suivante dans la page Script de vérification :

' La valeur par défaut est True

%Check% = True

Exit Function
End If

Dim src, dst
' Erreur si les deux extrémités sont des objets

'Boundary'
If CompareStéréotype(src, PdMOO.Cls_UMLObject,
"Boundary") Then
If CompareStéréotype(dst, PdMOO.Cls_UMLObject,
"Boundary") Then
%Check% = False
End If
End If
End Function

16 Répétez les étapes 4 à 14 et créez une vérification pour vérifier que seuls
les objets Control accèdent aux objets Entity :
Définition de la vérification Contenu

Nom Accès incorrect à un objet Entity
Message d'aide Cette vérification s'assure que seuls
les objets Control accèdent aux objets
Entity
Message de résultats Les liens suivants sont incorrects :
Sévérité par défaut Erreur
Exécuter la vérification par défaut Coché
17 Saisissez la vérification suivante dans la page Script de vérification :

' Default return is True
%Check% = True
Exit Function
End If
Dim src, dst
' Source est un objet UML avec le stéréotype
"Entity" ?
' Appelle la fonction globale CompareStéréotype()
définie dans le volet Script global
If CompareStéréotype(src, PdMOO.Cls_UMLObject,
"Entity") Then
' Vérifie si la destination est un objet UML
avec le stéréotype "Control"
If not CompareStéréotype(dst,
PdMOO.Cls_UMLObject, "Control") Then
%Check% = False
End If
Elsif CompareStéréotype(dst, PdMOO.Cls_UMLObject,
"Entity") Then
' Vérifie si la source est un objet UML avec le
stéréotype "Control"
If not CompareStéréotype(src,
PdMOO.Cls_UMLObject, "Control") Then
%Check% = False
End If
End If
End Function
272 PowerAMC
19 Cliquez sur OK dans l'éditeur de ressources.

20 Sélectionnez Outils→Vérifier le modèle pour afficher la boîte de
dialogue Paramètres de vérification de modèle.
Les vérifications personnalisées s'affichent dans la catégorie Liens entre
objets.

Vous pouvez tester les vérifications en créant des liens entre objets entre
Client et Serveur d'applications par exemple, puis en appuyant sur F4
pour lancer la vérification du modèle.
Pour plus d'informations la fonctionnalité de vérification de
modèle, reportez-vous aux sections correspondantes dans les différents
guides de l'utilisateur.
Génération d'une description sous forme de texte des messages

Vous allez générer une description sous forme de texte des messages qui
existent dans le diagramme de collaboration. La description doit fournir, pour
chaque diagramme du modèle, le nom de l'émetteur du message, le nom du
message et le nom de son récepteur.
Vous générez cette description à l'aide de templates et de fichiers générés, car
par défaut PowerAMC ne fournit pas cette fonctionnalité. Les templates et
fichiers générés utilisent le langage de génération par templates (GTL) de
PowerAMC. Les fichiers générés évaluent les templates définis sur les
métaclasses et génèrent le résultat de l'évaluation dans des fichiers.
Pour plus d'informations sur GTL, reportez-vous au chapitre Guide de
référence de la génération.
Quel template Pour générer une description des messages d'un diagramme de collaboration
définir et où le sous forme de texte, vous devez définir des templates sur les métaclasses
définir ? suivantes :
♦ Message : cette métaclasse contient des détails relatifs au numéro
d'ordre du message et au nom de ce message, à l'émetteur et au
récepteur, ce qui explique que vous définissez un template afin d'évaluer
le numéro d'ordre et la description du message dans cette métaclasse
♦ CollaborationDiagram : vous définissez dans cette métaclasse les
templates qui vont trier les messages dans le diagramme et rassembler
toutes les descriptions de message à partir du diagramme courant
Pour plus d'informations sur les métaclasses PowerAMC, reportez-vous
au métamodèle PowerAMC et à sa documentation dans le chapitre
Métamodèle public PowerAMC.
Le fichier généré est défini sur la métaclasse BasePackage afin de consulter
la totalité du modèle, c'est-à-dire le modèle lui-même et les packages qu'il
contient, ce afin de s'assurer que tous les messages dans le modèle et ses
packages soient décrits dans le fichier généré. Il y aura un seul fichier généré
puisque la métaclasse BasePackage n'a qu'une instance.
274 PowerAMC
Définition d'un template pour la génération

Un fichier généré utilise des templates définis dans des métaclasses. Le
premier template que vous devez définir porte sur les messages. Le rôle de ce
template est d'évaluer le numéro d'ordre de message et de fournir le nom de
l'émetteur, le nom du message et le nom du récepteur pour chaque message
dans le diagramme.
La syntaxe pour ce template est la suivante :
.set_value(_tabs, "", new)
.foreach_part(%SequenceNumber%, '.')
.set_value(_tabs, " %_tabs%")
.next
%_tabs%%SequenceNumber%) %Sender.ShortDescription% sends
message "%Name%" to %Receiver.ShortDescription%
La première partie du template vise à créer une indentation correspondant au
numéro de séquence du message. La macro foreach_parts boucle sur les
numéros d'ordre :
.set_value(_tabs, " %_tabs%")
Il passe en revue chaque numéro d'ordre et chaque fois qu'il trouve un point,
il ajoute trois espaces vides automatiquement pour réaliser l'indentation.
Cette procédure calcule la variable _tab, qui est ensuite utilisée pour créer
l'indentation appropriée en fonction des numéros d'ordre.
La dernière ligne contient le texte généré pour le template : pour chaque
numéro de séquence, la valeur de tabulation appropriée est créée, suivie du
nom de l'émetteur (brève description), le texte "sends message", puis le nom
du message, le texte "to", ainsi que le nom du récepteur.
Pour définir un template utilisé pour la génération :

1 Sélectionnez Modèle→Définitions étendues de modèle puis double-
cliquez sur la flèche en regard de Robustness_Extension dans la boîte de
dialogue Liste des définitions étendues de modèle pour afficher l'éditeur
de ressources.
3 Sélectionnez Message dans la liste des métaclasses affichées dans la
La catégorie Message s'affiche sous Profile.

4 Pointez sur la catégorie Message, cliquez le bouton droit de la souris et

sélectionnez Nouveau→Template.
Un nouveau template est créé.
5 Saisissez description dans la zone Nom du template
6 <facultatif> Saisissez un commentaire dans la zone Commentaire du
template.
7 Saisissez le code suivant dans la zone de texte :
.set_value(_tabs, "", new)
.if (%Separator% == ".")
.set_value(_tabs, " "%_tabs%)
.endif
.next
%_tabs%%SequenceNumber%) %Sender.ShortDescription%
sends message "%Name%" to %Receiver.ShortDescription%
Définition des templates pour la métaclasse du diagramme de collaboration

Une fois que vous avez défini le template utilisé pour évaluer le numéro
d'ordre de chaque message, vous devez créer un template pour trier ces
numéros d'ordre (compareCbMsgSymbols), ainsi qu'un autre template
pour extraire tous les messages du diagramme de collaboration
(description).
Le template compareCbMsgSymbols est de type booléen et permet de
vérifier si le numéro de message est supérieur à un autre numéro de message.
La syntaxe de ce template est la suivante :
.bool (%Item1.Object.SequenceNumber% >= %Item2.Object.SequenceNumber%)
276 PowerAMC
La valeur renvoyée pour ce template est utilisée avec le paramètre compare

dans le template description dont le code se présente comme suit :
Collaboration Scenario %Name%:
\n
.foreach_item(Symbols,,, %ObjectType% ==
CollaborationMessageSymbol, %compareCbMsgSymbols%)
%Object.description%
.next(\n)
Dans ce template, la première ligne est utilisée pour générer le titre du
scénario à l'aide du nom du diagramme de collaboration %Name%. Puis elle
crée une nouvelle ligne.
Ensuite, la macro pour chaque élément boucle sur chaque symbole de
message, vérifie puis trie le numéro de message, puis génère la description de
message à l'aide de la syntaxe définie dans la section précédente.
Pour définir des templates pour la métaclasse du diagramme de

collaboration :
2 Cliquez sur l'outil Modifier le filtre des métaclasses et sélectionnez
Afficher toutes les métaclasses.
3 Sélectionnez CollaborationDiagram dans la liste des métaclasses
affichées dans la page PdMOO, puis cliquez sur OK.
La catégorie CollaborationDiagram s'affiche sous Profile.
4 Pointez sur la catégorie CollaborationDiagram, cliquez le bouton droit
de la souris et sélectionnez Nouveau→Template.
5 Saisissez compareCbMsgSymbols dans la zone Nom du template.
template.
.bool (%Item1.Object.SequenceNumber% >=
%Item2.Object.SequenceNumber%)
9 Pointez sur la catégorie CollaborationDiagram, cliquez le bouton droit
de la souris et sélectionnez Nouveau→Template.

10 Saisissez description dans la zone Nom du template

template.
Collaboration Scenario %Name%:
\n
.foreach_item(Symbols,,, %ObjectType% ==
CollaborationMessageSymbol, %compareCbMsgSymbols%)
%Object.description%
.next(\n)
Définition d'un fichier généré

Vous allez définir un fichier généré afin de répertorier les messages de
chaque diagramme de collaboration existant dans votre modèle. Pour ce faire,
vous devez définir le fichier généré dans la métaclasse BasePackage. Cette
métaclasse est la classe commune pour tous les packages et modèles, elle
possède les objets, diagrammes et autres packages.
Le fichier généré contiendra le résultat de l'évaluation de la description
du template définie sur la métaclasse CollaborationDiagram. Le code du
fichier généré contient également une macro foreach_item macro afin de
boucler sur les différents diagrammes de collaboration du modèle.
278 PowerAMC
Pour définir un fichier généré :

2 Cliquez sur l'outil Modifier le filtre des métaclasses, sélectionnez
Afficher les métaclasses de modélisation abstraite, puis cliquez sur
l'onglet PdCommon.
3 Sélectionnez BasePackage dans la liste des métaclasses, puis cliquez sur
OK.
La catégorie BasePackage s'affiche sous Profile.
4 Pointez sur la catégorie BasePackage, cliquez le bouton droit de la souris
et sélectionnez Nouveau→Generated File.
Un nouveau fichier généré est créé.
5 Saisissez Descriptifs des collaborations dans la zone Nom.
Ce nom est utilisé dans l'éditeur de ressources.
6 Saisissez Descriptif de collaboration %Name%.txt dans la zone Nom de
fichier.
Il s'agit du nom du fichier qui sera généré. Il s'agira d'un fichier .txt, et il
contiendra le nom du modèle courant grâce à la variable %Name%.
7 Conservez la valeur de codage ANSI.
9 Décochez la case Utiliser la hiérarchie des packages comme chemin
d'accès, car vous n'avez pas besoin de générer la hiérarchie des fichiers.


.foreach_item(CollaborationDiagrams)
%description%
.next(\n\n)
11 Cliquez sur OK et acceptez d'enregistrer la définition étendue de modèle.

12 Cliquez sur OK pour fermer la boîte de dialogue Liste des définitions
étendues de modèle.
Aperçu de la description sous forme de texte du diagramme de collaboration

Puisque le fichier généré est défini dans la métaclasse BasePackage, vous
pouvez afficher un aperçu du texte généré dans la page Aperçu de la feuille
de propriétés du modèle. Vous pouvez également en profiter pour vérifier
que la syntaxe des templates et que ce que vous allez générer correspondent à
vos attentes.
Pour afficher un aperçu de la description sous forme de texte du

diagramme de collaboration :
1 Pointez sur l'arrière-plan du diagramme de collaboration, cliquez le
bouton droit de la souris, puis sélectionnez Propriétés.
La feuille de propriétés du modèle s'affiche.
2 Cliquez sur l'onglet Aperçu pour afficher la page correspondante.
280 PowerAMC
La page Aperçu affiche le contenu du fichier à générer.
3 Cliquez sur OK.

282 PowerAMC
C H A P I T R E 3
Guide de référence du langage objet
A propos de ce Ce document décrit la structure et le contenu des langages objet dans un

document MOO. Il sert de référence pour les langages objet pris en charge par
PowerAMC. Vous y trouverez une présentation générale de l'utilisation d'un
langage objet et ce, quelles que soient ses caractéristiques.
Sommaire
Section Page
Présentation du langage objet 284

Notions de base relatives à l'éditeur de langage objet 285
Avant de Ne modifiez pas un langage objet fourni avec PowerAMC. Créez toujours
commencer vos nouveaux langages objet à partir des fichiers d'origine. Un langage objet
est enregistré dans un fichier dont le nom est doté du suffixe XOL.
Les modifications que vous apportez dans un langage objet peuvent changer
la façon dont PowerAMC fonctionne, tout particulièrement en ce qui
concerne la génération d'objets. Vous devez tester en profondeur les objets
générés.
Pour plus d'informations sur la création d'un langage objet par copie
d'un langage objet existant, reportez-vous à la section Création d'un fichier de
ressources, dans le chapitre L'éditeur de ressources du manuel Guide des

Présentation du langage objet
Présentation du langage objet

Vous pouvez utiliser de nombreux langages objet différents dans un MOO.
Pour chaque langage objet, un fichier de définition standard est inclus qui
fournit une interface entre PowerAMC et le langage objet afin d'établir les
meilleures relations entre eux.
Attention
Ne modifiez pas les langages objet fournis avec PowerAMC. Pour chaque
langage objet que vous souhaitez modifier, vous devez créer un nouveau
langage objet. Pour ce faire, vous devez créer un nouveau langage objet à
partir de la boîte de dialogue Liste des langages objet
(Outils→Ressources→Langages objet), définir un nom et sélectionner le
fichier d'origine dans la liste déroulante Copier depuis. Vous pouvez ainsi
créer un nouveau langage objet identique au fichier d'origine (sauf en ce
qui concerne le nom).
Qu'est-ce qu'un Le langage objet est un composant requis lorsque vous travaillez avec des
langage objet ? modèles orienté objet (MOO). Chaque langage objet a sa propre définition de
langage objet au format XML qui contient les spécifications pour un langage
objet particulier dans un format lisible par un MOO. Il fournit la syntaxe et
les règles de création des objets et met en oeuvre les stéréotypes, types de
données, scripts et constantes pour un langage objet.
Chaque MOO est par défaut attaché à un langage objet. Lorsque vous créez
un nouveau MOO, vous devez choisir un langage objet : vous pouvez créer
un nouveau langage objet, ou bien utiliser l'un des langages objet fournis
avec le MOO.
La définition d'un langage objet est disponible dans sa feuille de propriétés
(Outils→Ressources→Langages objet. Vous pouvez sélectionner et
configurer des paramètres utilisés lors de la définition des objets ou de la
génération à partir d'un MOO.
Que contient un Tous les langages objet ont la même structure constituée d'un certain nombre
langage objet ? de catégories. Une catégorie peut contenir d'autres catégories, des entrées et
des valeurs. Ces entrées sont des paramètres reconnaissables par un MOO.
Les valeurs pour les entrées de langage objet varient selon le langage
considéré. Certaines entrées peuvent ne pas être disponibles si la
fonctionnalité ne s'applique pas au langage objet.
Exemples de Même si un langage objet particulier est utilisé pour illustrer un exemple, le
langage objet mécanisme expliqué dans ce chapitre s'applique à tous les langages objet pris
en charge dans un MOO.
284 PowerAMC
Chapitre 3 Guide de référence du langage objet
Notions de base relatives à l'éditeur de langage

objet
Vous utilisez l'éditeur de langage pour consulter ou modifier un langage objet
(fichier .XOL).
Pour afficher l'éditeur de langage :

♦ Sélectionnez Langage→Editer le langage objet courant.
ou
Sélectionnez Outils→Ressources→Langages objet puis double-cliquez
sur un langage objet existant.
La feuille de propriétés du langage objet s'affiche.
L'éditeur de langage objet permet de naviguer entre les différentes catégories

et entrées du langage objet. Selon l'élément sélectionné, le contenu de la
partie droite de la fenêtre change. Le terme Métaclasse est utilisé dans la
documentation PowerAMC pour identifier un objet en tant que métaclasse.
Les métaclasses contenues dans l'arborescence de l'éditeur de ressources sont
des catégories.

Notions de base relatives à l'éditeur de langage objet
Pour plus d'informations sur la manipulation des catégories et entrées

dans l'éditeur de langages objet, reportez-vous au chapitre L'éditeur de
ressources dans le manuel Guide des fonctionnalités générales.
Propriétés d'un langage objet

L'éditeur de langage objet contient les catégories suivantes, qui incluent des
propriétés spécifiques à chaque langage pris en charge :
Settings Contient des types de données, des constantes, des conventions
de dénomination et des catégories d'événements utilisés dans le
MOO
Generation Contient des objets de génération avec des options et des scripts
de commandes définis dans le fichier .XOL
Profil de Permet de créer des profils contenant des transformations
transformations utilisées au cours de la génération de modèle ou appliquées
dans un modèle
Profile Contient des templates, des stéréotypes, des attributs étendus
pour la génération
Un langage objet a une feuille de propriétés disponible lorsque vous cliquez

sur le noeud racine dans l'arborescence de l'éditeur de langage objet. Cette
dernière inclut les propriétés suivantes :
Nom Nom du langage objet
Code Code du langage objet
Nom de fichier Chemin d'accès et nom du fichier du langage objet. Cette
zone est remplie lorsque le langage objet est partagé. Si le
langage objet est une copie, la zone est vide. Vous ne
pouvez pas modifier le contenu de cette zone
Famille Classification utilisée pour impliquer un certain
comportement dans le modèle objet. Dans PowerAMC, la
famille est utilisée pour activer certaines fonctionnalités
dans le modèle. De telles fonctionnalités n'existent pas par
défaut dans le MOO standard. Voir l'exemple ci-après
Sous-famille Sous-classification qui peut être combinée avec la
classification en familles pour impliquer un certain
comportement dans le langage objet
286 PowerAMC
Activer le suivi Affiche les templates de génération utilisés pour le texte
généré dans la page Aperçu des feuilles de propriétés
d'objets
Commentaire Informations supplémentaires relatives au langage objet
Famille et sous- Les propriétés Famille et Sous-famille impliquent certains comportements

famille dans le langage objet. Par exemple, les langages objet des familles Java,
XML, IDL et PowerBuilder prennent en charge le reverse engineering.
Si vous sélectionnez Fichier→Reverse engineering→Langage objet, vous
pouvez vérifier que seuls les langages objet de ces familles sont disponibles
dans la liste déroulante Langage objet de la boîte de dialogue.
La sous-famille est utilisée pour affiner les fonctionnalités définies pour une
famille particulière ; par exemple, dans la famille Java, la sous-famille J2EE
permet de gérer les Entreprise Java beans ou de rendre possible la création de
servlets et de JSP.
Sous-famille Java Si vous travaillez sur un MOO Java créé dans la version 9.0, la sous-famille
EJB de Java est EJB 2.0 et elle prend en charge les EJB. Dans la version 9.5, la
sous-famille de Java est devenue J2EE, elle prend en charge les composants
J2EE (servlets, JSP et EJB).
Vous devez utiliser le nouveau langage objet Java fourni avec la version
courante pour pouvoir utiliser les composants J2EE. Si vous avez
personnalisé le langage objet Java dans la version précédente, vous devez
appliquer ces changements au nouveau langage objet Java.
Activer le suivi La case Activer le suivi permet de prévisualiser les templates utilisés lors de
la génération. Avant même de lancer la génération, vous pouvez afficher la
page Aperçu de l'objet impliqué dans la génération pour voir ses templates et
utiliser l'outil Réactualiser pour les afficher.
Lorsque vous double-cliquez sur une ligne de suivi dans la page Aperçu, la
définition de template correspondante s'affiche dans l'éditeur de ressources,
dans la catégorie Profile\Objet\Templates. Le code du template peut être
affiché dans des couleurs distinctes.
Pour plus d'informations sur ces couleurs, reportez-vous au paragraphe
Coloration syntaxique dans la section Catégorie Generated Files.

Catégorie Settings
La catégorie Settings contient des éléments permettant de personnaliser et de
gérer les fonctionnalités de génération de MOO. Les éléments spécifiques à
un langage objet ne sont pas détaillés dans cette section.
Data Types Tables pour les correspondances de types de données
Constants Liste de valeurs constantes
Namings Contient les valeurs par défaut des opérations getter et setter,
un caractère illégal ou des valeurs de nom de composant J2EE,
par exemple
Events Valeurs d'événement standard
Catégorie Data types

La catégorie Data types (types de données) montre la correspondance entre
les types de données internes et ceux du langage objet.
Les types de données suivants sont définis par défaut :
Constante Valeur par défaut

BasicDataTypes Types de données de base de langage objet. La
colonne Valeur indique le type de données conceptuel
utilisé pour la génération de MCD et de MPD.
BasicDataTypes représente les types de données les
plus utilisés
ConceptualDataTypes La colonne Valeur indique le type de données de
langage objet utilisé pour la génération des modèles
MCD et MPD. Les types de données conceptuels sont
les types de données internes de PowerAMC, et ils ne
peuvent pas être modifiés
AdditionalDataTypes Types de données supplémentaires ajoutés dans les
listes de types de données. La colonne Valeur indique
le type de données conceptuel utilisé pour la
génération des modèles MCD et MPD. Peut être
utilisé pour ajouter ou modifier vos propres types de
données
DefaultDataType Valeur de type de données sélectionnée par défaut
288 PowerAMC
Exemple Dans le langage objet XML-Schema, la catégorie Settings est développée

pour montrer la liste des valeurs pour Basic data types.
Catégorie Constants
La catégorie Constants contient les valeurs constantes suivantes définies par
défaut :
Null
True
False
Void
Bool
Cette catégorie contient une table de correspondances entre les constantes et
leurs valeurs par défaut. Les valeurs par défaut varient en fonction du langage
objet.
Catégorie Namings
La catégorie Namings contient des paramètres qui influent sur ce qui sera
inclus dans les fichiers que vous générez à partir d'un MOO. Vous pouvez
modifier les valeurs par défaut de cette catégorie pour personnaliser le
processus de génération dans PowerAMC.

Vous pouvez modifier les valeurs par défaut suivantes :
Constante Description
GetterName Nom et valeur pour les opérations getter
GetterCode Code et valeur pour les opérations getter
SetterName Nom et valeur pour les opérations setter
SetterCode Code et valeur pour les opérations setter
IllegalChar Liste des caractères illégaux dans le langage objet courant. Voir
l'exemple ci-après
Caractères illégaux La liste des caractères illégaux est utilisée lorsque vous créez un MOO, ou
bien quand vous changez le langage objet pour initialiser les listes de
caractères illégaux pour tous les codes de tous les objets du modèle. La liste
des caractères illégaux est visible après la création du modèle
(Outils→Options du modèle→Convention de dénomination).
Par exemple, les caractères suivants ne sont pas acceptés pour les noms ou
les codes dans XML-Schema :
"/!=<>""'()"
Catégorie Events
Vous pouvez utiliser cette catégorie pour définir des événements standard sur
les opérations. Vous pouvez trouver des événements existants par défaut tels
que les constructeur et destructeur, en fonction du langage objet.
Un événement est lié à une opération. Le contenu de la catégorie Events est
affiché dans la liste déroulante Evénement dans les feuilles de propriétés
d'opération. Il décrit les événements qui peuvent être utilisés par une
opération.
Dans PowerBuilder, par exemple, la catégorie Events est utilisée pour
associer les opérations aux événements PowerBuilder.
290 PowerAMC
Catégorie Generation
La catégorie Generation contient des catégories et des entrées permettant de
définir et d'activer un processus de génération. Vous pouvez utiliser les
catégories suivantes :
♦ Commandes de génération
♦ Tâches de génération
♦ Options de génération
Guide de référence de génération

Le processus de génération PowerAMC est défini dans le chapitre Guide
de référence de génération de ce manuel. Nous vous recommandons de
commencer par lire ce chapitre afin de vous familiariser avec les concepts
et fonctionnalités du processus de génération.
Catégorie Commands
La catégorie Commands permet d'écrire des commandes de génération. Les
commande de génération peuvent être exécutées à la fin du processus de
génération, une fois tous les fichiers générés. Vous pouvez par exemple
intégrer des commandes de compilation ou de création d'un fichier d'archives
à la fin du processus de génération à partir d'un MOO.
Toutes les commandes écrites dans la catégorie Commands sont disponibles
après la création dans la page Tâches de la boîte de dialogue de génération,
elles peuvent alors être exécutées à la fin de la génération. Vous pouvez
trouver des commandes par défaut dans le langage objet courant. Toutes les
commandes par défaut ne sont pas répertoriées ici car elles dépendent
entièrement du langage objet utilisé.
Les commandes doivent être incluses au sein de tâches pour être exécutées.
Pour plus d'informations sur le rôle des tâches, reportez-vous à la
section Catégorie Tasks.
Les commandes sont liées à un langage objet. Le texte qui définit le code de
la commande est écrit à l'aide du langage de génération par templates (GTL).
Il utilise les variables d'environnement qui peuvent correspondre aux
exécutables tels que javac.exe, par exemple.
Pour plus d'informations sur le GTL, reportez-vous au chapitre Guide
de référence de génération.

Les macros spécifiques sont disponibles dans le cadre de l'exécution des

commandes.
Pour plus d'informations sur les macros, reportez-vous à la section
Utilisation de macros dans le chapitre Guide de référence de génération.
Pour définir une commande pour la génération :

1 Pointez sur la catégorie Generation\Commands dans le langage objet et
cliquez le bouton droit de la souris.
2 Sélectionnez Nouvel élément.
La nouvelle entrée s'affiche avec un nom par défaut.

5 Saisissez le code de la commande dans la zone de texte vide en utilisant
les outils à votre disposition.
292 PowerAMC
Explication du code
des commandes
Suppression d'une commande de génération

Vous pouvez retirer une commande de génération dans le langage objet en
pointant sur l'objet et en cliquant le bouton droit de la souris, puis en
sélectionnant Supprimer. Une boîte de confirmation vous invite à
confirmer la suppression de la commande. Elle peut indiquer que la valeur
par défaut définie pour cette entrée sera utilisée, cette valeur par défaut est
stockée dans le template caché du langage objet.
Pour plus d'informations sur ces entrées, reportez-vous à la section
Ajout d'une catégorie ou d'une entrée dans un fichier de ressources, dans le
chapitre L'éditeur de ressources du manuel Guide des fonctionnalités
générales.
Catégorie Tasks
Une tâche est une liste de commandes à exécuter à l'issue de la génération.
Ces commandes doivent être référencées au sein des différentes tâches
définies pour la génération, une commande non référencée dans une tâche ne
peut pas être exécutée. Vous trouverez à la fin de cette section un exemple
comportant une commande et une tâche contenant cette commande.
Le mécanisme d'exécution de la commande fonctionne comme suit :
lorsqu'une tâche est sélectionnée dans la page Tâches de la boîte de dialogue
de génération, les commandes incluses dans la tâches sont extraites et le
template associé à la commande est évalué et exécuté.
Les tâches s'affichent dans la page Tâches de la boîte de dialogue de
génération et sont exécutées dans un ordre défini. Cet ordre peut être
facilement modifié en utilisant les flèches de déplacement dans la page
Tâches.

Vous devez créer la commande avant de créer la tâche qui contient cette
commande : dans l'exemple suivant, la tâche nommée Compile fait référence
à une commande nommée Javac (écrite dans la colonne Nom). Le code de la
commande Javac est situé dans la catégorie Commands.
Pour définir une tâche pour la génération :

1 Pointez sur la catégorie Generation\Tasks et cliquez le bouton droit de la
souris.

5 Dans la zone de groupe Commandes, cliquez sur l'outil Ajouter des
commandes, puis sélectionnez la ou les commandes que vous souhaitez
inclure dans la tâche courante.
Le nom de la ou des commandes s'affiche dans la colonne Nom.
6 <facultatif>> Double-cliquez sur la flèche au début de la ligne pour
afficher le code de la commande.
294 PowerAMC
Exemple Ouvrez le langage objet Java (Langage→Editer le langage objet courant),

créez et définissez une entrée de commande nommée DoCommand dans la
catégorie Generation\Commands :

Créez une entrée de tâches nommée Execute dans la catégorie

Generation\Tasks, cliquez sur l'outil Ajouter des commandes, puis
sélectionnez DoCommand :
La nouvelle tâche est disponible dans la page Commands de la boîte de

dialogue de génération. Le commentaire de la tâche est affiché par défaut. Si
aucun commentaire n'a été fourni, le nom de la tâche est affiché.
296 PowerAMC
Catégorie Options
La catégorie Options permet de personnaliser le processus de génération. Elle
contient des entrées par défaut qui représentent des options de génération.
Vous pouvez définir des options de génération à partir de la catégorie
Generation\Options dans le langage objet. Ces options définies par
l'utilisateur sont disponibles après la création dans la page Options de la boîte
de dialogue de génération.
Les options de génération peuvent être utilisées dans tous les templates.
Vous pouvez créer les différents types d'options suivants :
Type Description
Booléenne Lorsque ce type est sélectionné, une zone Valeur permet de choisir
entre Oui et Non
Chaîne Lorsque ce type est sélectionné, une zone Valeur permet de saisir la
chaîne
Liste Lorsque ce type est sélectionné, une zone Valeur s'affiche. Vous
pouvez ajouter une valeur à l'aide de l'outil Ajouter une valeur, puis
cocher la case correspondante
Le format des valeurs peut être affiché comme suit dans la page Options de la
boîte de dialogue de génération : lorsqu'un commentaire de valeur est
spécifié, il est affiché dans la liste à la place du nom de la valeur.
Par exemple, si une case Value:Attribute est cochée dans une liste
d'options nommée myListOption dans la catégorie Generation\Options, seule
la description Attribute est affichée dans la page Options de la boîte de
dialogue de génération. Toutefois, le GTL va évaluer
%GenOptions.MyListOption% à Value.
Vous pouvez trouver des options par défaut définies dans le langage objet.
Ces options ne sont pas répertoriées ici car elles dépendent du langage objet
que vous utilisez.
Pour plus d'informations sur la liste des options de votre langage objet,
reportez-vous au chapitre Génération pour un langage dans le manuel Guide
de l'utilisateur du Modèle Orienté Objet.
Pour définir une option pour la génération :

1 Pointez sur la catégorie Generation\Options et cliquez le bouton droit de
la souris.
2 Sélectionnez Nouveau.


4 Sélectionnez un type.
6 Selon le type de l'option, sélectionnez ou saisissez la valeur dans la zone
Valeur.
Exemple Ouvrez le langage objet (Langage→Editer le langage objet courant), puis

créez une entrée booléenne nommée UserDefined_Option dans la catégorie
Generation\Options :
298 PowerAMC
La nouvelle option est disponible dans la page Options de la boîte de

dialogue de génération (Langage→Générer du code Java). Le commentaire
de l'option est affiché par défaut. Si aucun commentaire n'a été fourni, le nom
de l'option est affiché.
Exemple La valeur d'une option peut être obtenue dans un template à l'aide de la
syntaxe suivante :
'%' 'GenOptions.'<option-name> '%'
Par exemple, si vous définissez une option booléenne nommée
GenerateComment, %GenOptions.GenerateComment% sera évaluée à true
ou false dans un template, selon la valeur spécifiée dans la page Options de la
boîte de dialogue de génération.
Suppression d'une option de génération

Vous pouvez supprimer une option de génération dans le langage objet en
pointant sur l'entrée, en cliquant le bouton droit de la souris, puis en
confirmer la suppression. Elle peut indiquer que la valeur par défaut
définie pour cette entrée sera utilisée, cette valeur par défaut est stockée
dans le template caché du langage objet.
générales.


une sous famille.
Générales.
Catégorie Profile
Chaque objet a une catégorie identifiée par son nom qui peut contenir les
♦ Criteria
♦ Stereotypes
♦ Extended attributes
♦ Generated Files et Templates
♦ Custom Check
♦ Custom Symbol et outil
♦ Methods
♦ Transformations
♦ Menus
Pour plus d'informations sur les vérifications personnalisées et les
symboles personnalisés, reportez-vous aux sections Définition d'une
vérification personnalisée dans un profil et Définition d'un symbole
personnalisé dans un profil, dans le chapitre Gestion des profils.
Ces objets sont des métaclasses (du métamodèle), puisque chaque objet est
représenté sous forme de métaclasse dans le métamodèle.
Pour plus d'informations sur le métamodèle, reportez-vous au chapitre
Métamodèle public PowerAMC.
300 PowerAMC
Catégorie Shared La catégorie Profile inclut également une catégorie Shared utilisée pour
stocker des entrées réutilisables telles que les types d'attributs étendus et les
templates partagés.
Pour plus d'informations sur les éléments de la catégorie Profile,
reportez-vous au chapitre Gestion des profils.
Catégorie Criteria
Les critères (catégorie Criteria) sont un mécanisme d'extension générique
pour les métaclasses PowerAMC. Ils peuvent être utilisés pour des objets qui
ne prennent pas en charge les stéréotypes dans un MCD ou dans un MPD.
Un critère définit une condition avec les expressions utilisées dans la macro
.if du langage de génération par templates (GTL) de PowerAMC. Lorsqu'une
instance de métaclasse vérifie la condition du critère, les extensions définies
sur le critère sont appliquées à cette instance.
Pour plus d'informations sur les critères, reportez-vous à la section
Définition d'un critère, dans le chapitre Gestion des profils.
Catégorie Stereotypes
Dans la catégorie Stereotypes, vous pouvez définir des stéréotypes pour des
objets qui prennent en charge les stéréotypes. Vous pouvez modifier les
stéréotypes par défaut existants, ou bien définir de nouveaux stéréotypes pour
n'importe quel objet du modèle.

Lorsque vous modifiez les valeurs d'un stéréotype pour un objet, les
changements s'appliquent à tous les objets existants et tous les objets du
même type que vous créez dans le modèle.
Pour plus d'informations sur les stéréotypes, reportez-vous à la section
Définition d'un stéréotype, dans le chapitre Gestion des profils.
Catégorie Extended attributes

Les attributs étendus définis pour un objet sont créés en plus des attributs
standard. Les noms d'attributs étendus peuvent être utilisés en tant que
variables dans les scripts définis dans le langage objet.
Chaque attribut étendu peut être nécessaire pendant la génération, c'est
pourquoi nous vous déconseillons de les modifier. Il est préférable de créer
une copie de sauvegarde pour chaque langage objet avant de commencer à
les modifier.
Par défaut, les valeurs d'attributs étendus que vous définissez dans le langage
objet s'affichent dans la page Attributs étendus de la feuille de propriétés de
l'objet.
Pour plus d'informations sur les attributs étendus, reportez-vous à la
section Définition d'attributs étendus dans un profil, dans le chapitre Gestion
des profils.
Si vous souhaitez compléter la définition des objets de modèle et étendre le
métamodèle, vous devez définir des attributs étendus dans une définition
étendue de modèle. De tels attributs étendus ne sont alors pas utilisés lors du
processus de génération.
reportez-vous à la section Gestion des définitions étendues de modèle, dans
le chapitre Gestion des objets, dans le manuel Guide des fonctionnalités
générales.
302 PowerAMC
Exemple Dans le langage objet C#, l'attribut étendu virtual est utilisé pour
identifier l'opération :
Catégorie Generated Files

Certains objets de la catégorie Profile incluent une entrée Generated Files qui
contient une liste de fichiers. Ces entrées définissent les fichiers qui seront
générés pour une métaclasse donnée ou pour les instances d'une métaclasse
ayant un stéréotype ou correspondant à un critère sélectionné.
Exemple La catégorie Generated Files pour les objets fichiers dans Java contient
l'entrée EmbeddedArtifact qui s'applique à tous les fichiers incorporés de
type Artifact à générer. L'entrée EmbeddedArtifact contient la zone Nom de
fichier qui contient le template pour le nom des fichiers à générer.

Dans la partie inférieure, on trouve une zone de texte qui affiche le code du
template du fichier à générer.
Pour plus d'informations sur l'entrée Generated Files, reportez-vous à la

section Définition de templates et de fichiers générés dans un profil, dans le
chapitre Gestion des profils.
Codage Vous pouvez définir le format pour les fichiers générés dans la zone Codage
pour chaque fichier que vous générez. Un format de codage par défaut vous
est fourni, mais vous pouvez également cliquer sur le bouton Points de
suspension en regard de la zone Codage pour changer de codage. Vous
affichez ainsi la boîte de dialogue Format de codage pour le texte en sortie
dans laquelle vous pouvez sélectionner un format dans une liste déroulante.
Cette boîte de dialogue inclut les propriétés suivantes :
Codage Format de codage du fichier généré
Annuler si perte de Permet d'arrêter la génération si des caractères ne peuvent
caractère pas être identifiés et risquent d'être perdus dans le codage
courant
304 PowerAMC
Coloration Si la zone Nom de fichier de l'entrée Generated Files est vide, aucun fichier
syntaxique n'est généré. Toutefois, il peut s'avérer utile de laisser cette colonne vide de
façon à afficher un aperçu du contenu du fichier avant génération. Vous
pouvez utiliser à cet effet la page Aperçu de l'objet correspondant à tout
moment.
Au cours de la génération, le template dans Nom de fichier est évalué et si
l'une des extensions suivantes est rencontrée, le code est affiché dans l'éditeur
et avec la coloration syntaxique correspondante (exemple : .cs pour C++) :
Extension Coloration syntaxique

.java Java
.c C
.h C
.sru PowerBuilder
.html HTML
.xml XML
.xsd XML
.dtd XML
.xmi XML
.jsp XML
.wsdl XML
.asp XML
.aspx XML
.asmx XML
.cpp CPP
.hpp CPP
.cs C++
.cls Visual Basic 6
.vb Visual Basic 6
.vbs VB Script
.sql SQL
.idl CORBA
.txt Editeur de texte par défaut

Il y a deux scénarii possibles lors de la génération :

♦ Un fichier est généré
♦ Aucun fichier n'est généré
Fichier généré Le mécanisme de la génération de fichiers est le suivant pour chaque objet
ayant une entrée Generated Files qui n'est pas vide :
Un fichier est généré lorsque la zone Nom de fichier contient le nom du

fichier ou le template du nom du fichier à générer. Vous pouvez saisir le nom
du fichier à générer comme suit :
♦ nom_fichier.suffixe (par exemple, ejb-jar.xml)
♦ %suffixenom_fichier% (par exemple, %asmxFileName%)
306 PowerAMC
Dans cet exemple, un fichier appelé ejb-jar.xml situé dans le dossier META-
INF est généré.
Aucun fichier Dans cet exemple, aucun fichier n'est généré car le contenu de la zone Nom
généré de fichier commence par un caractère . (point). Le contenu du fichier n'est
disponible que dans la page Aperçu de la feuille de propriétés du composant
(EJB - Entity Bean).

Catégorie Templates
Les templates sont utilisés pour définir ce que vous souhaitez générer pour
l'objet courant.
Pour plus d'informations sur l'utilisation des templates, reportez-vous à
la section Définition de templates, dans le chapitre Guide de référence de
génération.
Exemple Le template suivant est défini pour les opérations dans Java. Il définit les
règles relatives à l'affichage de la visibilité. Il est également disponible dans
la catégorie Templates pour les attributs et les classes.
Pour plus d'informations sur la catégorie Templates, reportez-vous à la

section Définition de templates et de fichiers générés dans un profil, dans le
308 PowerAMC
Utilisation de la touche F12 pour trouver des templates

Vous pouvez afficher tous les templates du même nom en utilisant la
touche F12. Pour ce faire, ouvrez un template, placez le curseur sur un
nom de template entre caractères %, puis appuyez sur la touche F12. Vous
affichez ainsi une fenêtre qui affiche tous les templates avec en préfixe le
nom de la métaclasse correspondante.
Exemple : placez le curseur sur %definition% dans un template, appuyez
sur F12. La fenêtre affiche tous les <nom_métaclasse>::definition. Vous
pouvez ensuite double-cliquer sur le template de votre choix dans la
fenêtre Parcourir afin de placer le curseur directement sur le template
sélectionné.
Comment les Dans l'exemple suivant, la catégorie Generated Files pour les classificateurs
fichiers générés et contient une entrée 'Java Source'. Cette entrée contient le template nommé
les templates %source% dans la zone de texte.
fonctionnent
ensemble ?

Lorsque vous ouvrez la catégorie Templates pour les classificateurs, le

template nommé 'source' est affiché. Lorsque le fichier est généré pour un
classificateur donné ou pour les instances d'un classificateur avec un
stéréotype ou critère sélectionné, le template évalué est le template 'source'.
Le nom du fichier généré correspond à l'entrée dans la zone Nom de fichier.
Roles d'association Vous pouvez définir des collections d'implémentation pour les associations.
Les attributs d'association évalués sont : Nom de rôle, Visibilité, Multiplicité,
Implémentation (RoleAContainer ou RoleBContainer), Classe de mise en
oeuvre, Ordre, Navigable, Modifiable, Valeur initiale, Persistant, Volatile,
Multiplicité minimale, Multiplicité maximale, Classificateur (ClassA ou
ClassB). Vous devez définir le rôle actif dans l'association à l'aide des
attributs RoleAActive ou RoleBActive. Lorsque vous référencez par
exemple RoleAActive, le rôle A de l'association devient actif et le script
d'implémentation peut récupérer les attributs correspondant au rôle A.
310 PowerAMC
C H A P T E R 4
Guide de référence du langage de

processus
A propos de ce Ce document décrit la structure et le contenu des langages de processus dans

document un MPM. Il sert de référence pour les langages de processus pris en charge
par PowerAMC. Vous y trouverez une présentation générale de l'utilisation
d'un langage de processus et ce, quelles que soient ses caractéristiques.
Sommaire
Section Page
Présentation du langage de processus 312
Notions de base relatives à l'éditeur de langage de processus 314
Avant de Ne modifiez pas un langage de processus fourni avec PowerAMC. Créez

commencer toujours vos nouveaux langages de processus à partir des fichiers d'origine.
Un langage de processus est enregistré dans un fichier dont le nom est doté
du suffixe XPL.
Les modifications que vous apportez dans un langage de processus peuvent
changer la façon dont PowerAMC fonctionne, tout particulièrement en ce qui
générés.
Pour plus d'informations sur la création d'un langage de processus par
copie d'un langage de processus existant, reportez-vous à la section Création
d'un fichier de ressources, dans le chapitre L'éditeur de ressources du manuel

Présentation du langage de processus
Présentation du langage de processus

Vous pouvez utiliser de nombreux langages de processus différents dans un
MPM. Pour chaque langage de processus, un fichier de définition standard
est inclus et fournit une interface entre PowerAMC et le langage de processus
afin d'établir les meilleures relations possibles entre eux.
Attention
Ne modifiez pas les langages de processus fournis avec PowerAMC. Pour
chaque langage de processus que vous souhaitez modifier, vous devez
créer un nouveau langage de processus. Pour ce faire, vous devez créer un
nouveau langage de processus à partir de la boîte de dialogue Liste des
langages de processus (Outils→Ressources→Langages objet), définir un
nom et sélectionner le fichier d'origine dans la liste déroulante Copier
depuis. Vous pouvez ainsi créer un nouveau langage de processus
identique au fichier d'origine (sauf en ce qui concerne le nom).
Qu'est-ce qu'un Le langage de processus est un composant requis lorsque vous travaillez avec
langage de des Modèles de Processus Métiers (MPM). Chaque langage de processus a sa
processus ? propre définition de langage de processus au format XML qui contient les
spécifications pour un langage de processus particulier dans un format lisible
par un MPM. Il fournit la syntaxe et les règles de génération des objets et la
mise en oeuvre des stéréotypes, des scripts et des constantes pour un langage
de processus.
Chaque MPM est par défaut attaché à un langage de processus. Lorsque vous
créez un nouveau MPM, vous devez choisir un langage de processus : vous
pouvez créer un nouveau langage de processus, ou bien utiliser l'un des
langages de processus fournis avec le MPM.
La définition d'un langage de processus est disponible dans sa feuille de
propriétés (Outils→Ressources→Langages de processus. Vous pouvez
sélectionner et configurer des paramètres utilisés lors de la définition des
objets ou de la génération à partir d'un MPM.
Que contient un Tous les langages de processus ont la même structure constituée d'un certain
langage de nombre de catégories. Une catégorie peut contenir d'autres catégories, des
processus ? entrées et des valeurs. Ces entrées sont des paramètres reconnaissables par un
MPM.
Les valeurs pour les entrées de langage de processus varient selon le langage
fonctionnalité ne s'applique pas au langage de processus.
312 PowerAMC
Chapter 4 Guide de référence du langage de processus
Exemples de Même si un langage de processus particulier est utilisé pour illustrer un

langage de exemple, le mécanisme expliqué dans ce chapitre s'applique à tous les
processus langages de processus pris en charge dans un MPM.

Notions de base relatives à l'éditeur de langage de processus

de processus
Vous utilisez l'éditeur de langage pour consulter ou modifier un langage de
processus (fichier .XPL).
Pour afficher l'éditeur de langage :

♦ Sélectionnez Langage→Editer le langage de processus courant.
ou
Sélectionnez Outils→Ressources→Langages de processus puis double-
cliquez sur un langage de processus existant.
La feuille de propriétés du langage de processus s'affiche.
L'éditeur de langage de processus permet de naviguer entre les différentes

catégories et entrées du langage de processus. Selon l'élément sélectionné, le
contenu de la partie droite de la fenêtre change. Le terme Métaclasse est
utilisé dans la documentation PowerAMC pour identifier un objet en tant que
métaclasse. Les métaclasses contenues dans l'arborescence de l'éditeur de
ressources sont des catégories.
dans l'éditeur de langages de processus, reportez-vous au chapitre L'éditeur
de ressources dans le manuel Guide des fonctionnalités générales.
314 PowerAMC
Propriétés d'un langage de processus

L'éditeur de langage de processus contient les catégories suivantes, qui
incluent des propriétés spécifiques à chaque langage pris en charge :
Settings Contient des types de données, des constantes, des conventions
de dénomination et des catégories d'événements utilisés dans le
MPM
Generation Contient des objets de génération avec des options et des scripts
de commandes définis dans le fichier .XPL
Transformation Contient un groupe de transformations utilisées lors de la
profile génération de modèle
Un langage de processus a une feuille de propriétés disponible lorsque vous

cliquez sur le noeud racine dans l'arborescence de l'éditeur de langage de
processus. Cette dernière inclut les propriétés suivantes :
Nom Nom du langage de processus
Code Code du langage de processus
Nom de fichier Chemin d'accès et nom du fichier du langage de processus.
Cette zone est remplie lorsque le langage de processus est
partagé. Si le langage de processus est une copie, la zone
est vide. Vous ne pouvez pas modifier le contenu de cette
zone
comportement dans le modèle objet. Dans PowerAMC, la
défaut dans le MPM standard. Voir l'exemple ci-après
comportement dans le langage de processus
d'objets
Commentaire Informations supplémentaires relatives au langage de
processus

Famille et sous- Les propriétés Famille et Sous-famille impliquent certains comportements

famille dans le langage de processus. Par exemple, les langages de processus de la
famille Service Orchestration sont SOA, BPEL4WS et Sybase Integration
Orchestrator.
La sous-famille est utilisée pour affiner les fonctionnalités définies pour une
famille particulière.
♦ Commands
♦ Tasks
♦ Options

316 PowerAMC
Catégorie Commands
génération, une fois tous les fichiers générés.
trouver des commandes par défaut dans le langage de processus courant.
Toutes les commandes par défaut ne sont pas répertoriées ici car elles
dépendent entièrement du langage de processus utilisé.
Les commandes sont spécifiquement liées à un langage de processus. Le texte
qui définit le code de la commande est écrit à l'aide du langage de génération
par template (GTL, Generation Template Language).
de référence de la génération.
commandes.

1 Pointez sur la catégorie Generation\Commands dans le langage de
processus et cliquez le bouton droit de la souris.




Vous pouvez retirer une commande de génération dans le langage de
processus en pointant sur l'objet et en cliquant le bouton droit de la souris,
puis en sélectionnant Supprimer. Une boîte de confirmation vous invite à
stockée dans le template caché du langage de processus.
générales.
Catégorie Tasks
318 PowerAMC

Tâches.
commande.

souris.


Exemple Ouvrez le langage de processus Sybase Integration Orchestrator

(Langage→Editer le langage de processus courant), créez et définissez une
entrée de commande nommée CreateDefaultFolders dans la catégorie
Generation\Commands :
320 PowerAMC
Créez une entrée de tâches nommée CreateXSDFiles dans la catégorie

Generation\Tasks, vous pouvez vous assurer qu'elle contient la commande
CreateXSDFiles :
La nouvelle tâche est disponible dans la page Commands de la boîte de

dialogue de génération. Le commentaire de la tâche est affiché par défaut. Si
aucun commentaire n'a été fourni, le nom de la tâche est affiché.

Catégorie Options
La catégorie Options permet de personnaliser le processus de génération. Elle
contient des entrées par défaut qui représentent des options de génération.
Generation\Options dans le langage de processus. Ces options définies par
Type Description
entre Oui et Non
chaîne
Le format des valeurs peut être affiché comme suit dans la page Options de la
boîte de dialogue de génération : lorsqu'un commentaire de valeur est
Vous pouvez trouver des options par défaut définies dans le langage de
processus. Ces options ne sont pas répertoriées ici car elles dépendent du
langage de processus que vous utilisez.
Pour plus d'informations sur la liste des options de votre langage de
processus, reportez-vous au chapitre Génération pour un langage dans le
manuel Guide de l'utilisateur du Modèle Orienté Objet.
la souris.

322 PowerAMC

Valeur.
Exemple Ouvrez le langage de processus (Langage→Editer le langage de processus

courant), puis créez une entrée booléenne nommée Options_Utilisateur dans
la catégorie Generation\Options :


dialogue de génération. Le commentaire de l'option est affiché par défaut. Si
aucun commentaire n'a été fourni, le nom de l'option est affiché.
Exemple La valeur d'une option peut être obtenue dans un template à l'aide de la
syntaxe suivante :
'%' 'GenOptions.'<option-name> '%'
Par exemple, si vous définissez une option booléenne nommée
GenerateComment, %GenOptions.GenerateComment% sera évaluée à true
ou false dans un template, selon la valeur spécifiée dans la page Options de la
boîte de dialogue de génération.

Vous pouvez supprimer une option de génération dans le langage de
processus en pointant sur l'entrée, en cliquant le bouton droit de la souris,
puis en sélectionnant Supprimer. Une boîte de confirmation vous invite à
dans le template caché du langage de processus.
générales.
324 PowerAMC
Catégorie Settings
La catégorie Settings contient des éléments permettant de personnaliser et de
gérer les fonctionnalités de génération de MPM. Les éléments spécifiques à
un langage de processus ne sont pas détaillés dans cette section.
Implementation Disponible uniquement pour un MPM exécutable. Rassemble
les options qui influencent les possibilités de mise en oeuvre
du processus
DataHandling Disponible uniquement pour un MPM exécutable. Rassemble
les options qui permettent de générer les données dans le
langage
Choreography Rassemble des objets qui permettent de modéliser le graphe
des activités (début, fin, décision, synchronisation,
transition...)
Catégorie Implementation
La catégorie Implementation (uniquement disponible pour le MPM
exécutable) contient les valeurs constantes suivantes définies par défaut :

LoopTypeList Cette liste définit le type de boucle pris en charge
par le langage. La valeur doit être un entier
OperationTypeList Cette liste définit le type d'opération pris en charge
par le langage. Une opération d'un type non pris en
charge ne peut pas être associée à un processus. La
valeur doit être un entier
EnableEmissionCorrelation Ce paramètre permet la définition d'une corrélation
pour un message émis
EnableProcessReuse Ce paramètre permet à un processus d'être mis en
oeuvre par un autre processus


AutomaticInvokeMode Ce paramètre indique si le type d'action d'un
processus mis en oeuvre par une opération peut être
automatiquement déduit du type d'opération.
Les valeurs possibles sont les suivantes :
♦ La valeur 0 (valeur par défaut) indique

que le type d'action ne peut pas être déduit
et doit être spécifié
♦ La valeur 1 est réservée pour les langages
dans lesquels le processus doit recevoir
une opération Demande-réponse et une
opération One-way et doit appeler une
opération Request-response et une
opération Notification
♦ La valeur 2 est l'inverse pour les langages
dans lesquels le processus reçoit
systématiquement une opération
Sollicitation-Réponse et une opération
Notification tandis que les opérations
Request-response et One-way sont
toujours appelées
Exemple Dans le langage de processus BPEL4WS, la catégorie Settings est

développée pour montrer la liste des valeurs pour la liste Type d'opération.
326 PowerAMC
Catégorie DataHandling
La catégorie DataHandling (uniquement disponible pour le MPM exécutable)
contient les valeurs constantes suivantes définies par défaut :
EnableMessageOnFlow Ce paramètre indique si un format de message
peut ou non être associé à un flux. La valeur par
défaut est Oui
EnableMessageVariable Ce paramètre permet à une variable de stocker la
totalité d'un format de message. Dans ce cas, le
format de message apparaîtra dans la liste
déroulante Type de données de la variable
Catégorie Choreography
La catégorie Choreography contient les valeurs constantes suivantes définies
par défaut :
EnableMultipleStarts Lorsque défini à Non, ce paramètre vérifie
qu'un processus composite ne comporte pas
plusieurs débuts
EnableTopLevelChoreography Lorsque défini à Non, ce paramètre vérifie
qu'aucun flux ou objet de chorégraphie (début,
fin, décision...) n'est défini directement sous le
modèle ou sous un package. Ces objets peuvent
être définis uniquement sous un processus
composite

Catégorie Profile
Chaque métaclasse dans le profil a une catégorie identifiée par son nom qui
contient plusieurs catégories telles que Stereotypes, Extended attributes,
Methods, etc.
Le profil est un mécanisme d'extension utilisé pour personnaliser un
métamodèle en lui ajoutant des sémantiques supplémentaires. Les profils sont
utilisés pour créer des catégories d'objets (stéréotypes et critères),
personnaliser les graphiques d'objets, ajouter des métadonnées
supplémentaires aux objets (attributs étendus), définir des possibilités de
génération nouvelles ou modifiées (templates), ajouter des méthodes, des
transformations, et des collections étendues sur les métaclasses et menus.
Pour plus d'informations sur la catégorie Profile, reportez-vous au

une sous famille.
Générales.
328 PowerAMC
C H A P I T R E 5
Guide de référence du langage XML
A propos de ce Ce document décrit la structure et le contenu des langages XML dans un

document modèle XML. Il sert de référence pour les langages XML pris en charge par
PowerAMC. Vous y trouverez une présentation générale de l'utilisation d'un
langage XML et ce, quelles que soient ses caractéristiques.
Sommaire
Section Page
Présentation du langage XML 330
Notions de base relatives à l'éditeur de langage XML 331
Avant de Ne modifiez pas un langage XML fourni avec PowerAMC. Créez toujours
commencer vos nouveaux langages XML à partir des fichiers d'origine. Un langage XML
est enregistré dans un fichier dont le nom est doté du suffixe XPL.
Les modifications que vous apportez dans un langage XML peuvent changer
la façon dont PowerAMC fonctionne, tout particulièrement en ce qui
générés.
Pour plus d'informations sur la création d'un langage XML par copie
d'un langage XML existant, reportez-vous à la section Création d'un fichier
de ressources, dans le chapitre L'éditeur de ressources du manuel Guide des

Présentation du langage XML
Présentation du langage XML

Vous pouvez utiliser de nombreux langages XML différents dans un modèle
XML. Pour chaque langage XML, un fichier de définition standard est inclus
qui fournit une interface entre PowerAMC et le langage XML afin d'établir
les meilleures relations entre eux.
Attention
Ne modifiez pas les langages XML fournis avec PowerAMC. Pour chaque
langage XML que vous souhaitez modifier, vous devez créer un nouveau
langage XML. Pour ce faire, vous devez créer un nouveau langage XML à
partir de la boîte de dialogue Liste des langages XML
(Outils→Ressources→Langages XML), définir un nom et sélectionner le
fichier d'origine dans la liste déroulante Copier depuis. Vous pouvez ainsi
créer un nouveau langage XML identique au fichier d'origine (sauf en ce
qui concerne le nom).
Qu'est-ce qu'un Le langage XML est un composant requis lorsque vous travaillez avec des
langage XML ? modèles XML. Chaque langage XML a sa propre définition de langage XML
au format XML qui contient les spécifications pour un langage XML
particulier dans un format lisible par un modèle XML. Il fournit la syntaxe et
les règles de création des objets et met en oeuvre les stéréotypes, types de
données, scripts et constantes pour un langage XML.
Chaque modèle XML est par défaut attaché à un langage XML. Lorsque
vous créez un nouveau modèle XML, vous devez choisir un langage XML :
vous pouvez créer un nouveau langage XML, ou bien utiliser l'un des
langages XML fournis avec le modèle XML.
La définition d'un langage XML est disponible dans sa feuille de propriétés
(Outils→Ressources→Langages XML. Vous pouvez sélectionner et
configurer des paramètres utilisés lors de la définition des objets ou de la
génération à partir d'un modèle XML.
Que contient un Tous les langages XML ont la même structure constituée d'un certain nombre
langage XML ? de catégories. Une catégorie peut contenir d'autres catégories, des entrées et
des valeurs. Ces entrées sont des paramètres reconnaissables par un modèle
XML.
Les valeurs pour les entrées de langage XML varient selon le langage
fonctionnalité ne s'applique pas au langage XML.
Exemples de Même si un langage XML particulier est utilisé pour illustrer un exemple, le
langage XML mécanisme expliqué dans ce chapitre s'applique à tous les langages XML
pris en charge dans un modèle XML.
330 PowerAMC
Chapitre 5 Guide de référence du langage XML

XML
Vous utilisez l'éditeur de langage XML pour consulter ou modifier un
langage XML (fichier .XPL).
Pour afficher l'éditeur de langage XML :

♦ Sélectionnez Langage→Editer le langage XML courant.
ou
Sélectionnez Outils→Ressources→Langages XML puis double-cliquez
sur un langage XML existant.
La feuille de propriétés du langage XML s'affiche.
L'éditeur de langage XML permet de naviguer entre les différentes catégories

et entrées du langage XML. Selon l'élément sélectionné, le contenu de la
partie droite de la fenêtre change. Le terme Métaclasse est utilisé dans la
documentation PowerAMC pour identifier un objet en tant que métaclasse.
Les métaclasses contenues dans l'arborescence de l'éditeur de ressources sont
des catégories.
dans l'éditeur de langages XML, reportez-vous au chapitre L'éditeur de
ressources dans le manuel Guide des fonctionnalités générales.

Notions de base relatives à l'éditeur de langage XML
Propriétés d'un langage XML

L'éditeur de langage XML contient les catégories suivantes, qui incluent des
propriétés spécifiques à chaque langage pris en charge :
Settings Contient des tables de conversion de types de données
Generation Contient des options de génération, des tâches et des scripts de
commande définis dans le fichier .XPL
Transformation Contient un groupe de transformations utilisé lors de la
profile génération de modèle
Un langage XML a une feuille de propriétés disponible lorsque vous cliquez

sur le noeud racine dans l'arborescence de l'éditeur de langage XML. Cette
dernière inclut les propriétés suivantes :
Nom Nom du langage XML
Code Code du langage XML
Nom de fichier Chemin d'accès et nom du fichier du langage XML. Cette
zone est remplie lorsque le langage XML est partagé. Si le
langage XML est une copie, la zone est vide. Vous ne
pouvez pas modifier le contenu de cette zone
comportement dans le modèle XML. Dans PowerAMC, la
défaut dans le modèle XML standard
comportement dans le langage XML
d'objets
Commentaire Informations supplémentaires relatives au langage XML
332 PowerAMC
♦ Commandes de génération
♦ Tâches de génération
♦ Options de génération

Catégorie Commands
génération, une fois tous les fichiers générés.
trouver des commandes par défaut dans le langage XML courant. Toutes les
commandes par défaut ne sont pas répertoriées ici car elles dépendent
entièrement du langage XML utilisé.

Les commandes sont liées à un langage XML. Le texte qui définit le code de
la commande est écrit à l'aide du langage de génération par templates (GTL).
de référence de génération.
commandes.

1 Pointez sur la catégorie Generation\Commands dans le langage XML et
cliquez le bouton droit de la souris.


Vous pouvez retirer une commande de génération dans le langage XML
en pointant sur l'objet et en cliquant le bouton droit de la souris, puis en
stockée dans le template caché du langage XML.
Ajout d'une catégorie ou d'une entrée dans un fichier de ressources, dans
le chapitre L'éditeur de ressources du manuel Guide des fonctionnalités
générales.
334 PowerAMC
Catégorie Tasks
Tâches.
commande.

souris.


Catégorie Options
La catégorie Options permet de personnaliser le processus de génération.
Elle contient des entrées par défaut qui représentent des options de
génération.
Generation\Options dans le langage XML. Ces options définies par
Type Description
entre Oui et Non
chaîne
Le format des valeurs peut être affiché comme suit dans la page Options de
la boîte de dialogue de génération : lorsqu'un commentaire de valeur est
Vous pouvez trouver des options par défaut définies dans le langage XML.
Ces options ne sont pas répertoriées ici car elles dépendent du langage XML
que vous utilisez.
Pour plus d'informations sur la liste des options de votre langage XML,
reportez-vous au chapitre Génération pour un langage dans le manuel Guide
de l'utilisateur du Modèle Orienté Objet.
la souris.

336 PowerAMC

Valeur.
Exemple Ouvrez le langage XML (Langage→Editer le langage XML courant), puis

créez une entrée booléenne nommée UserDefined_Option dans la catégorie
Generation\Options :


dialogue de génération. Le commentaire de l'option est affiché par défaut. Si
aucun commentaire n'a été fourni, le nom de l'option est affiché.

Vous pouvez supprimer une option de génération dans le langage XML en
pointant sur l'entrée, en cliquant le bouton droit de la souris, puis en
dans le template caché du langage XML.
Ajout d'une catégorie ou d'une entrée dans un fichier de ressources, dans
le chapitre L'éditeur de ressources du manuel Guide des fonctionnalités
générales.
338 PowerAMC
Catégorie Settings
La catégorie Settings contient la sous-catégorie Data types qui montre la
correspondance entre les types de données internes et ceux du langage XML.
Les types de données suivants sont définis par défaut :
Type de données Description

ConceptualDataTypes La colonne Valeur indique le type de données de
langage XML utilisé pour la génération des modèles
MCD et MPD. Les types de données conceptuels sont
les types de données internes de PowerAMC, et ils ne
peuvent pas être modifiés
XsmDataTypes Types de données pour les générations depuis le
modèle XML
Catégorie Profile
Chaque métaclasse dans le profil a une catégorie identifiée par son nom qui
contient plusieurs catégories telles que Stereotypes, Extended attributes,
Methods, etc.
Le profil est un mécanisme d'extension utilisé pour personnaliser un
métamodèle en lui ajoutant des sémantiques supplémentaires. Les profils
sont utilisés pour créer des catégories d'objets (stéréotypes et critères),
personnaliser les graphiques d'objets, ajouter des métadonnées
supplémentaires aux objets (attributs étendus), définir des possibilités de
génération nouvelles ou modifiées (templates), ajouter des méthodes, des
transformations, et des collections étendues sur les métaclasses et menus.
Pour plus d'informations sur la catégorie Profile, reportez-vous au

d'une génération de modèle, lorsque vous souhaitez appliquer des
Générales.

Profiles d'un fichier de ressources. Chaque profil est identifié par le modèle
dans lequel le fichier de ressource est défini, par un type de modèle, une
famille et une sous famille.
340 PowerAMC
C H A P I T R E 6
Guide de référence des définitions

étendues de modèle
Sujet Ce document décrit la structure et le contenu d'une définition étendue de

modèle PowerAMC. Ce guide sert de référence pour l'utilisation des
définitions étendues de modèle.
Sommaire
Section Page
Gestion des définitions étendues de modèle 342
Utilisation des définitions étendues de modèle 353
Génération pour une définition étendue de modèle 366

Gestion des définitions étendues de modèle

Les définitions étendues de modèle permettent de personnaliser et d'étendre
les métaclasses et les paramètres de génération PowerAMC.
Attention
Il est préférable de ne pas modifier les définitions étendues de modèle
fournies avec PowerAMC. Pour chaque définition étendue de modèle
d'origine que vous souhaitez modifier, créez une nouvelle définition
étendue de modèle. Pour ce faire, vous devez créer la nouvelle définition
étendue de modèle à la partir de la boîte de dialogue Liste des définitions
étendues de modèle, définir un nom et sélectionner le fichier d'origine
dans la liste déroulante Copier depuis. Cette méthode permet de créer une
nouvelle définition étendue de modèle identique au fichier d'origine,
excepté son nom.
Pour plus d'informations sur la création d'une nouvelle définition

étendue de modèle à partir d'une définition étendue de modèle existante,
reportez-vous à la section Création d'un fichier de ressources dans le chapitre
L'éditeur de ressources du manuel Guide des fonctionnalités générales.
Qu'est-ce qu'une Un modèle étendu contient une définition de profil et des paramètres de
définition étendue génération. Le profil est un jeu d'extensions de métamodèle définies sur les
de modèle? métaclasses.
Pour plus d'informations sur les profils, reportez-vous au chapitre
Gestion des profils.
Les paramètres de génération sont utilisés pour développer ou compléter la
génération d'objets PowerAMC par défaut ou pour une génération distincte.
Les définitions étendues de modèle sont dotées d'un type, tout comme les
modèles dans PowerAMC. Vous pouvez créer une définition étendue de
modèle pour un type de modèle spécifique et vous ne pouvez pas partager ces
fichiers entre modèles de type différent.
Vous pouvez définir une ou plusieurs définitions étendues de modèle pour un
modèle. Certaines définitions étendues de modèle sont fournies avec
PowerAMC, et vous pouvez créer vos propres extensions. Les définitions
étendues de modèle sont globales pour un modèle, elles ne peuvent donc pas
être attachées à un package particulier.
Pour plus d'informations sur la génération de définitions étendues de
modèle, reportez-vous à la section Génération pour une définition étendue de
modèle.
342 PowerAMC
Chapitre 6 Guide de référence des définitions étendues de modèle
Que contient une Toutes les définitions étendues de modèle ont la même structure composée de
définition étendue catégories. Une catégorie peut contenir d'autres catégories, des entrées, et
de modèle ? des valeurs. Ces entrées sont des paramètres reconnaissables par
PowerAMC.
Les valeurs pour les catégories de définition étendue de modèle varient d'une
définition étendue de modèle à l'autre. Certaines entrées peuvent ne pas
exister dans un fichier de définition étendue de modèle si elles ne sont pas
applicables à cette définition étendue de modèle particulière.
Comment utiliser Vous pouvez créer des définitions étendues de modèle génériques et
les définitions spécifiques.
étendues de
modèle ? ♦ Une définition étendue de modèle générique est une bibliothèque
d'extensions de métamodèle, ainsi que des paramètres de génération. Ce
fichier est stocké dans une partie centrale et peut être référencé par des
modèles afin de garantir la cohérence des données et permettre à
l'utilisateur de gagner du temps
♦ Une définition étendue de modèle spécifique est incorporée dans un
modèle et développe des définitions d'objet et des paramètres de
génération dans ce modèle particulier
Création d'une définition étendue de modèle

Lorsque vous créez une nouvelle définition étendue de modèle, vous pouvez
choisir de :
♦ Créer un fichier de définition étendue de modèle générique à réutiliser
entre les modèles
♦ Créer une définition étendue de modèle spécifique, adaptée aux besoins
d'un modèle particulier
La procédure de création diffère selon le type de définition étendue de
modèle que vous souhaitez créer.

Création d'une définition étendue de modèle générique

Vous pouvez créer des définitions étendues de modèle génériques pour
partager des informations entre différents modèles de même type.
Pour créer une définition étendue de modèle générique :

1 Ouvrez un modèle.
modèle→Type de modèle.
3 Cliquez sur l'outil Nouveau pour afficher la boîte de dialogue Nouvelle
4 Saisissez un nom pour la nouvelle définition étendue de modèle dans la

zone Nom.
5 <facultatif> Sélectionnez un template dans la liste déroulante Copier
depuis. Cette liste déroulante affiche les définitions étendues de modèle
existantes.
6 Cliquez sur OK.
Une boîte de dialogue standard d'enregistrement s'affiche.
7 Saisissez un nom et sélectionnez un répertoire pour la nouvelle définition
étendue de modèle. Si vous n'enregistrez pas la définition étendue de
modèle dans le répertoire par défaut de PowerAMC, elle ne s'affiche pas
dans la boîte de dialogue Liste des définitions étendues de modèle. Vous
devez cliquer sur l'outil Chemin pour sélectionner le répertoire dans
lequel vous avez enregistré le fichier.
344 PowerAMC
La boîte de dialogue Propriétés de la définition étendue de modèle

s'affiche. La page Général affiche les catégories sous forme
d'arborescence avec un éditeur dans la partie droite.
9 Définissez la définition étendue de modèle.

10 Cliquez sur OK.
La définition étendue de modèle est enregistrée dans un fichier ayant
pour suffixe .XEM.
La boîte de dialogue Liste des définitions étendues de modèle affiche la
nouvelle définition étendue de modèle si vous avez enregistré le fichier
dans le répertoire par défaut de PowerAMC.

11 Cliquez sur Fermer.
Importation d'un fichier de définition étendue de modèle

Si vous voulez intégrer une définition étendue de modèle générique
dans un modèle, vous pouvez importer le fichier de définition étendue
de modèle correspondant.
Pour plus d'informations sur l'importation de définitions étendues

de modèle, reportez-vous à la section Importation d'une définition
étendue de modèle dans un modèle.
Création d'une définition étendue de modèle spécifique pour un modèle

Vous pouvez créer une définition étendue de modèle adaptée à un modèle
particulier, dans ce cas, il a le même type que le modèle courant.
Pour créer une définition étendue de modèle spécifique pour un

modèle :
1 Ouvrez un modèle.
3 Cliquez sur l'outil Ajouter une ligne pour créer une nouvelle définition
étendue de modèle.
5 Cliquez sur l'outil Propriétés pour afficher la feuille de propriétés de la
346 PowerAMC
La boîte de dialogue Propriétés de la définition étendue de modèle

s'affiche.
6 Définissez la définition étendue de modèle.

7 Cliquez sur OK.
Vous revenez à la boîte de dialogue Liste des définitions étendues de
modèle.
8 Cliquez sur OK.
Exportation d'une définition étendue de modèle

Si vous souhaitez partager entre différents modèles une définition
étendue de modèle créée pour un modèle particulier, vous pouvez
exporter cette définition étendue de modèle afin de la réutiliser avec
d'autres modèles.
Pour plus d'informations sur l'exportation de définitions étendues

de modèle, reportez-vous à la section Exportation d'une définition

Importation d'attributs étendus depuis les versions antérieures

Vous pouvez importer dans la version courante de PowerAMC les attributs
étendus définis dans une version antérieure. Le processus d'importation
transfère la plupart des attributs étendus contenus dans un modèle ou dans un
fichier EXA vers une définition étendue de modèle.
Vous pouvez importer des attributs étendus de l'une des façons suivantes :
♦ En ouvrant un modèle comportant des attributs étendus et qui a été
enregistré avec une version antérieure de PowerAMC
♦ En ouvrant un fichier ayant pour suffixe .EXA
Importation d'attributs étendus de modèle depuis une version antérieure

Lorsque vous ouvrez un modèle enregistré avec PowerAMC version 5 ou 6,
et que ce modèle contient des attributs étendus, ces derniers sont
automatiquement importés dans une définition étendue de modèle spécifique
incorporée au modèle importé.
Si vous ouvrez un modèle comportant des attributs étendus PowerBuilder, la
définition étendue de modèle PowerBuilder est automatiquement attachée au
modèle importé.
Pour plus d'informations sur l'importation d'attributs étendus
PowerBuilder, reportez-vous à la section Importation de modèles contenant
des attributs étendus PowerBuilder créés dans une version antérieure dans le
chapitre Gestion des modèles physiques de données dans le manuel Guide de
l'utilisateur du MPD.
Pour importer des attributs étendus de modèle depuis une version

précédente :
1 Ouvrez un modèle enregistré à l'aide d'une version antérieure de
PowerAMC.
348 PowerAMC
Une nouvelle définition étendue de modèle s'affiche dans la liste, elle a

comme nom par défaut Attributs importés.
3 Double-cliquez sur la nouvelle définition étendue de modèle pour

afficher sa feuille de propriétés.
Vous pouvez observer le contenu de la catégorie Extended Attributes
dans la catégorie Profile\métaclasse et voir les attributs étendus
importés.
Importation d'attributs étendus à partir d'un fichier .EXA

Vous pouvez importer un fichier d'attribut étendu (suffixe .EXA) dans une
définition étendue de modèle générique, disponible pour tous les modèles
d'un même type. Vous pouvez ainsi récupérer les attributs étendus définis
dans une version antérieure de PowerAMC.
Pour importer les attributs étendus à partir d'un fichier .EXA :

modèle→Modèle Physique de Données.
2 Cliquez sur l'outil Importer des attributs étendus.
Une boîte de dialogue standard d'ouverture de fichier s'affiche.
3 Sélectionnez un fichier d'attributs étendus doté du suffixe .EXA.
4 Cliquez sur OK.

5 Sélectionnez le nom et le chemin de la nouvelle définition étendue de

modèle (doté d'un suffixe .XEM) qui sera créée à partir du fichier .EXA.
6 Cliquez sur OK.
La nouvelle définition étendue de modèle s'affiche dans la boîte de
dialogue Liste des définitions étendues de modèle.
7 <facultatif> Double-cliquez sur la nouvelle définition étendue de modèle
pour afficher sa feuille de propriétés.
Importation d'une définition étendue de modèle dans un modèle

Vous pouvez importer un fichier de définition étendue de modèle générique
dans votre modèle courant. Lorsque vous importez une définition étendue de
modèle existante, vous réutilisez le profil et les paramètres de génération
définis dans une bibliothèque disponible sur votre machine.
Lorsque vous importez une définition étendue de modèle, vous l'attachez au
modèle. Vous pouvez choisir l'une des options d'importation suivantes :
Option
d'importation Description
Partage : Utiliser Vous utilisez une version partagée de la définition étendue
des définitions de modèle. Cette définition est partagée par tous les
étendues de modèle modèles, voire par tous les utilisateurs d'une équipe de
partagées conception. Toute modification dans les propriétés de la
définition étendue de modèle sont appliquées à tous les
modèles qui partagent la définition étendue de modèle
Copie : Créer une Vous créez une copie de la définition étendue de modèle
copie des définitions dans le modèle. Vous pouvez modifier cette définition
étendues dans votre modèle. Toute modification apportée aux
sélectionnées propriétés de la définition étendue de modèle n'est
appliquée qu'au seul modèle courant
Conventions de dénomination
Lorsque vous importez une définition étendue de modèle et la copiez dans
un modèle, le nom et le code de la définition étendue de modèle peut être
modifié afin de respecter les conventions de dénomination définies dans la
boîte de dialogue Options du modèle.
350 PowerAMC
Pour importer une définition étendue de modèle dans un modèle :

2 Cliquez sur l'outil Importer une définition étendue de modèle.
La boîte de dialogue Sélection des définitions étendues de modèle
s'affiche.
3 Utilisez l'outil Chemin pour sélectionnez le répertoire dans lequel les
fichiers de définition étendue de modèle sont stockés.
4 Sélectionnez le bouton radio Partage ou Copie.
5 Cliquez sur OK.

La définition étendue de modèle importée depuis le fichier est
répertoriée dans la boîte de dialogue Liste des définitions étendues de
modèle.
Exportation d'une définition étendue de modèle

Vous pouvez exporter une définition étendue de modèle créée dans un
modèle si vous souhaitez partager cette définition avec d'autres modèles.
L'exportation permet de créer un fichier ayant le suffixe .XEM qui sera
stocké dans votre répertoire de bibliothèques de définitions étendues de
modèle. Lorsque vous exportez une définition étendue de modèle, la
définition étendue de modèle spécifique reste incorporée dans le modèle.

Une définition étendue de modèle créée dans un modèle ne s'affiche pas dans
la boîte de dialogue Liste des définitions étendues de modèle. En revanche,
une définition étendue de modèle exportée s'affiche dans la boîte de dialogue
Liste des définitions étendues de modèle.
Pour exporter une définition étendue de modèle dans un modèle :

2 Sélectionnez une définition étendue de modèle dans la liste.
3 Cliquez sur l'outil Exporter une définition étendue de modèle.
4 Saisissez un nom et sélectionnez un répertoire pour la définition étendue
de modèle.
La définition étendue de modèle est enregistrée dans un répertoire de
bibliothèques dans lequel elle peut être partagée par différents modèles.
352 PowerAMC
Utilisation des définitions étendues de modèle

Vous utilisez les définitions étendues de modèle pour :
♦ Etendre le métamodèle PowerAMC et développer la définition des
métaclasses à l'aide des profils
♦ Compléter les cibles et commandes de génération d'un langage objet
♦ Générer pour une définition étendue de modèle
Editeur de Vous pouvez consulter ou modifier une définition étendue de modèle à l'aide
définitions de l'éditeur de définition étendue de modèle.
étendues de
modèle L'éditeur de définition étendue de modèle permet de naviguer parmi les
catégories et entrées. Lorsque vous sélectionnez une catégorie dans l'éditeur
de définition étendue de modèle, le nom, le code et le commentaire associé
s'affichent dans la partie droite de la fenêtre. Lorsque vous sélectionnez une
entrée dans l'éditeur, le nom, la valeur et le commentaire associé s'affiche
dans la partie droite de la fenêtre.
Pour plus d'informations sur l'utilisation de l'éditeur de définition
étendue de modèle, reportez-vous au chapitre L'éditeur de ressources dans le
manuel Guide des fonctionnalités générales.
Une définition étendue de modèle contient les principales catégories
suivantes :
Generation Utilisé pour définir et/ou activer une génération
Profile Utilisé pour définir des extensions pour les métaclasses
PowerAMC afin de définir des stéréotypes, des critères, des
attributs étendus, des fichiers générés, des templates de
génération, des symboles personnalisés et des vérifications
personnalisées
Ces catégories sont analysées plus en détails dans les sections suivantes du
présent chapitre.

Propriétés d'une définition étendue de modèle

Une définition étendue de modèle a une feuille de propriétés qui s'affiche
lorsque vous cliquez sur le noeud racine dans l'arborescence. Les propriétés
suivantes sont définies :
Nom Nom de la définition étendue de modèle. Ce nom doit être
unique dans un modèle dans le cas des définitions étendues
de modèle génériques ou spécifiques
Code Code de la définition étendue de modèle. Ce code doit être
unique dans un modèle pour les définitions étendues de
modèle génériques ou spécifiques
Nom de fichier Chemin et nom du fichier de la définition étendue de
modèle. Cette zone est renseignée lorsque la définition
étendue de modèle est partagée. Si la définition étendue de
modèle est une copie, la zone est vide. Vous ne pouvez pas
modifier le contenu de cette zone
Famille Utilisé pour classifier une définition étendue de modèle. La
famille est conçue pour aider à établir un lien entre le
langage objet d'un MOO et une définition étendue de
modèle. Lorsque la famille de langage objet correspond à la
famille de la définition étendue de modèle, suggère que la
définition étendue de modèle peut être utilisée pour
compléter le langage objet. Par exemple, lorsqu'une
définition étendue de modèle a comme famille JAVA, elle a
été conçue pour fonctionner avec le langage objet JAVA.
Cette fonctionnalité n'est disponible que pour le MOO
Sous-famille Utiliser pour affiner la famille. Par exemple, EJB 2.0 est
une sous-famille de Java
Rattachement Utilisé pour lier la définition étendue de modèle au langage
automatique objet courant. Si la case Rattachement automatique est
cochée, la définition étendue de modèle correspondante
sera sélectionnée dans la page Définitions étendues de
modèle de la boîte de dialogue Nouveau modèle
Catégorie Utilisé pour regrouper des définitions étendues de modèle
concurrentes pour la génération. Par exemple, une catégorie
appelée "Serveurs d'applications" peut être créée pour
regrouper des définitions étendues de modèle dédiées aux
différents serveurs. Les définitions étendues de modèle de
même catégorie ne peuvent pas être générées simultanément
Activer le suivi Lorsque cette option est sélectionnée, affiche les templates
de génération utilisés pour le texte généré dans la page
Aperçu d'une feuille de propriétés d'objet
354 PowerAMC
Compléter la Indique que la définition étendue de modèle est utilisée
génération de pour compléter la génération d'un langage objet. Voir la
langage section ci-après
Commentaire Commentaires relatifs à la définition étendue de modèle
page Aperçu de l'objet impliqué dans la génération pour voir ses templates.
dans la catégorie appropriée. Le code du template peut être affiché dans des
couleurs distinctes.
Pour plus d'informations sur la coloration syntaxique, reportez-vous à la
section Création d'un fichier généré dans le chapitre Gestion des profils.
Cibles de génération
L'entrée Category influence le format de la page Cibles de la boîte de
dialogue de génération. Les définitions étendues de modèle sont regroupées
par catégorie sur cette page : chaque définition étendue de modèle s'affiche
en regard d'un bouton radio et au sein de la catégorie à laquelle elle
appartient. Si vous ne définissez aucune catégorie, la définition étendue de
modèle est considérée comme cible de la génération.

Dans l'exemple suivant, la catégorie Serveur d'applications rassemble deux

définitions étendues de modèle exclusives ; vous devez sélectionner l'une
d'entre elles. "Autre génération" correspond à une définition étendue de
modèle dans laquelle l'entrée Category n'est pas définie.
Complément de la génération de langage

Les définitions étendues de modèle peuvent être utilisées pour étendre la
génération ou pour compléter la génération d'un langage objet. Dans le
dernier cas, la case Compléter la génération de langage doit être cochée
pour autoriser la génération de la définition étendue de modèle avec le
langage objet.
Langage objet PowerBuilder

PowerBuilder ne prend pas en charge les définitions étendues de modèle
pour compléter la génération.
Les éléments de génération du langage objet sont fusionnés avec ceux de la

définition étendue de modèle avant la génération.
Fichiers générés Tous les fichiers générés dans les définitions étendues de modèle et les
langages objets sont générés. Dans le cas de fichiers générés ayant des noms
identiques, le fichier de la définition étendue de modèle remplace celui défini
dans le langage objet.
356 PowerAMC

Un profil de transformation est un groupe de transformations utilisé lors de la
génération de modèle lorsque vous souhaitez appliquer des changements à
des objets contenus dans le modèle source ou cible.
chapitre Gestion des transformations, dans le manuel Guide des
Vous définissez un profil de transformation d'une définition étendue de
modèle, d'un langage objet, d'un SGBD ou d'un langage de processus.
Chaque processus est identifié par le modèle dans lequel le fichier de
ressources courant est défini, par un type de modèle, par une famille et une
sous-famille.
Propriétés d'un profil de transformation

Les propriétés d'un profil de transformation sont les suivantes :
Propriétés Description
Nom Nom du profil de transformation
Commentaire Informations supplémentaires relatives au profil de
transformation
Type de modèle Spécifie le type de modèle avec lequel le profil de
transformation peut être utilisé. Permet de filtrer les profils
lors de la génération. Par exemple, si vous sélectionnez MOO
alors que la définition étendue de modèle courante est celle
d'un MPD, le profil de transformation peut être utilisé lors de
la génération d'un MPD vers un MOO (ou depuis un MOO
vers un MPD)
Famille et Sous- Si le type de modèle prend en charge un fichier de ressource
famille cible, vous pouvez également définir une famille et une sous-
famille pour filtrer l'affichage des profils dans la boîte de
dialogue de génération.
La famille est utilisée pour établir un lien entre le fichier de
ressources d'un modèle et une définition étendue de modèle.
Lorsque la famille du fichier de ressources correspond à la
famille de la définition étendue de modèle, cela suggère que
la définition étendue de modèle complète le fichier de
ressources
Les profils de transformation affichent deux listes de transformations

ordonnées.

Pré-génération
La page Pré-génération du profil affiche une liste ordonnée de
transformations qui sont exécutées avant la génération dans le modèle source.
Ces transformations sont exécutées lorsque le modèle courant dans lequel
vous avez créé la définition étendue de modèle est le modèle source et que
les contraintes définies pour les type de modèle, famille et sous-famille sont
respectées.
Tout objet créé lors de la pré-génération est automatiquement ajouté à la liste
des objets utilisés lors de la génération.
Par exemple, vous pouvez définir un profil de transformation à l'aide d'une
transformation qui annule la création des EJB à partir des classes avant de
générer un MOO dans un MPD, ce afin d'établir une meilleur correspondance
entre les classes et tables lors de la génération.
Post-génération
La page post-génération du profil affiche une liste ordonnée de
transformations qui sont exécutées à l'issue de la génération. Ces
transformations sont exécutées après la génération, si le modèle dans lequel
vous avez créé la définition étendue de modèle est la cible de la génération.
Par exemple, vous définissez un profil de transformation avec des
transformations qui appliquent automatiquement les conventions de
dénomination appropriées aux objets générés.
Création d'un profil de transformation

Par défaut, la catégorie Transformation Profile ne s'affiche pas dans
l'arborescence de la définition étendue de modèle.
Vous pouvez créer plusieurs profils de transformation dans la même
définition étendue de modèle : chaque profil correspondant à un scénario de
génération spécifique ; par exemple lorsque le MCD est la source et que la
cible est un MPD, etc.
Transformations
Un profil de transformation est une liste de transformations qui doit être
définie préalablement dans la catégorie Profile\Tranformations de la

358 PowerAMC
Pour créer un profil de transformation :

1 Pointez sur la racine de l'arborescence de la définition étendue de
modèle, cliquez le bouton droit de la souris, puis sélectionnez Ajouter
des éléments dans le menu contextuel.
2 Sélectionnez Transformation Profiles dans la boîte de dialogue de
sélection, puis cliquez sur OK.
La catégorie Transformation Profiles s'affiche dans l'arborescence de la
3 Pointez sur la catégorie Transformation Profiles, cliquez le bouton droit
de la souris puis sélectionnez Nouveau dans le menu contextuel.
Un nouveau profil est créé.
4 Saisissez un nom et un commentaire dans la page Général.
5 <facultatif>> Sélectionnez un type de modèle dans la zone Type de
modèle. Vous pouvez également sélectionner une famille et une sous-
famille dans les zones correspondantes.
6 Cliquez sur l'onglet Pré-génération pour afficher les transformations pré-
génération.
7 Cliquez sur l'outil Ajouter des transformations pour sélectionner les
transformations à appliquer au modèle courant avant la génération. Ces
transformations ont été précédemment définies dans la catégorie
Profile\Tranformations.
8 Répétez les mêmes étapes dans la page Post-génération.
9 Cliquez sur Appliquer dans l'éditeur de définition étendue de modèle
pour enregistrer le profil de transformation.
La catégorie Generation contient des catégories et des entrées servant à
définir et à activer un processus de génération. Vous pouvez utiliser les
♦ Commands, pour lancer des commandes lors de la génération
♦ Options, pour définir des options relatives à la génération
♦ Tasks, pour stocker des commandes et pour définir des templates pour la
génération et pour les requêtes O/R et R/R

Une définition étendue de modèle peut être utilisée pour compléter la

génération du modèle objet, ou bien pour une génération étendue. Vous
pouvez définir cette option à l'aide de la case à cocher Compléter la
génération de langage, située dans la feuille de propriétés de la définition
Commandes et tâches
La catégorie Commands permet de définir les commandes de génération. Les
commandes de génération peuvent être exécutées à la fin de la génération,
une fois les fichiers générés.
Le texte qui définit le code de la commande est écrit à l'aide du langage de
génération par templates (GTL). Il fait appel à des variables d'environnement
qui correspondent à des exécutables. Vous pouvez également utiliser des
macros dans vos commandes.
de référence de la génération.
dans la page Tâches de la boîte de dialogue de génération depuis laquelle
elles peuvent être exécutées à la fin de la génération. Une tâche est une liste
de commandes à exécuter après la génération. Chaque tâche est répertoriée
dans la page Tâches de la boîte de dialogue de génération, en regard du nom
de la définition étendue de modèle. Vous pouvez les sélectionner et utiliser
les flèches pour définir leur ordre.
Si une entrée de la liste des commande n'est pas référencée dans une entrée
de la liste des tâches, elle ne sera pas exécutée lors de la génération.
Lorsqu'une tâche est sélectionnée dans la page Tâches de la boîte de dialogue
de génération, les commandes qu'elle inclut sont extraites et le template
associé à chaque commande est évalué et exécuté.
360 PowerAMC
Dans l'exemple suivant, des tâches sont définies dans la définition étendue de
modèle Weblogic ; les autres tâches proviennent du langage objet du modèle
(Java):
Création d'une Vous devez créer des commandes avant de pouvoir créer des tâches.
commande
Pour créer une commande :
1 Pointez sur la catégorie Commands, cliquez le bouton droit de la souris
et sélectionnez Nouveau dans le menu contextuel.
Une nouvelle commande est créée.


les différents outils de la barre d'outils.
Création d'une
tâche Pour créer une tâche :
1 Pointez sur la catégorie Tasks, cliquez le bouton droit de la souris et
sélectionnez Nouveau dans le menu contextuel.
Une nouvelle tâche est créée.
Le commentaire de la tâche s'affiche dans la boîte de dialogue de
génération.
4 Cliquez sur l'outil Ajouter des commandes.
La boîte de dialogue Ajout de commandes s'affiche.
5 Sélectionnez une ou plusieurs commandes, puis cliquez sur OK.
La commande s'affiche dans la liste des commandes.
362 PowerAMC
6 Utilisez les flèches situées sous la liste pour définir l'ordre des
commandes.
Options
La catégorie Options permet de personnaliser le processus de génération.
Vous pouvez définir les types d'entrées suivants dans la catégorie Options :
Entrée Définition Exemple

Boolean Option à évaluer avec deux EnableComment : Yes / No
valeurs possibles : Yes ou No
String Chaîne de caractères d'une Valeur WebLogicPassword
seule ligne. Tous les
caractères sont admis dans la
valeur
List Liste de chaînes au format WebLogicDeploymentType permet
<value>[:<label>] de spécifier si vous souhaitez
déployer ou redéployer : vous
pouvez choisir "deploy" ou "update"
dans la liste des valeurs

Chaque entrée a un nom et un commentaire, elle correspond à une option de

génération. Le nom est utilisé si aucun commentaire n'est spécifié, dans le cas
contraire, le commentaire s'affiche dans la colonne Options de la page
Options de la boîte de dialogue de génération.
Ces options s'affichent dans la page Options de la boîte de dialogue de
génération si les conditions suivantes sont remplies :
♦ La définition étendue de modèle contient au moins un fichier généré
♦ La définition étendue de modèle contient au moins une tâche
Ces deux conditions permettent d'afficher et de sélectionner la définition
étendue de modèle dans la page Cibles de la boîte de dialogue de génération :
364 PowerAMC
Lorsque la définition étendue de modèle est sélectionnée, les options

s'affichent dans la page Options :
Vous pouvez utiliser les opérations de génération dans tous les templates et
toutes les commandes de génération. Pour connaître la valeur d'une option de
génération, utilisez la syntaxe suivante : %GenOptions.<Options
name>%.
Par exemple, pour évaluer EnableComment, vous pouvez utiliser la syntaxe
suivante :
.if (%GenOptions.EnableComment%)
%Comment%
.endif ( )

Génération pour une définition étendue de modèle
Génération pour une définition étendue de

modèle
Vous attachez une définition étendue de modèle à un modèle afin de :
♦ Compléter la génération principale du modèle
♦ Générer pour une cible séparée
Compléter la Les paramètres de génération d'une définition étendue de modèle influent sur
génération le contenu de la boîte de dialogue de génération. Le tableau suivant montre
principale que vous pouvez personnaliser la génération à partir de l'éditeur de définition
Boîte de dialogue
de génération Définition étendue de modèle
Page Cibles La page Cibles s'affiche si vous avez coché la case
Compléter la génération de langage dans la feuille de
propriétés de la définition étendue de modèle et si cette
définition étendue de modèle contient au moins une tâche
et un fichier généré
Page Options Définition des options dans Generation\Options à l'aide
d'entrées de type Booléenne, Liste et Chaîne
Page Tâches Définit les commandes à l'aide des entrées de commandes
et de références à ces commandes dans des tâches
Générer pour une Les définitions étendues de peuvent être utilisées pour créer de nouvelles
cible séparée cibles de génération. Dans ce cas, la case Compléter la génération de langage
doit être décochée et la définition étendue de modèle doit contenir des
entrées GeneratedFiles.
Cette génération est disponible pour tous les modules PowerAMC, à tout
moment vous pouvez générer pour une génération étendue en sélectionnant
Outils→Génération étendue.
366 PowerAMC
C H A P I T R E 7
Guide de référence de la génération
Sujet
Ce chapitre fournit une référence complète sur les concepts utilisés dans le
langage de génération par templates (GTL, Generation Template Language)
disponible dans PowerAMC. Vous y trouverez également des conseils relatifs
à l'utilisation du GTL.
Sommaire
Section Page
Définition du langage de génération par template (GTL) 368

Définition des concepts utilisés dans le langage de génération par
template 370
Conseils et techniques de génération 409

Définition du langage de génération par template (GTL)
Définition du langage de génération par

template (GTL)
Vous avez la possibilité de définir vos propres préférences de génération

dans un langage objet (fichier .XOL) ou bien dans une définition étendue de
modèle (fichier .XEM) et personnaliser ainsi le processus de génération en
utilisant le langage de génération par template (GTL).
Le langage de génération par template est un langage basé sur des templates
utilisés par PowerAMC pour la génération de texte. Ce langage vous permet
une meilleure adaptation et un contrôle total de la génération car la logique
de génération est entièrement contenue dans le langage objet ou la définition
étendue de modèle que vous avez la possibilité d'éditer. En outre, il vous
permet d'ajouter facilement des modules de génération de code
supplémentaires adaptés à vos besoins.
Présentation du Le langage de génération par template permet de générer du texte pour
processus chaque objet (appelé métaclasse) contenu dans un modèle. Ce type de
génération peut permettre de produire du code, générer des rapports (extraire
de l'information textuelle du modèle) ou produire un format tel que XMI
permettant l'échange avec d'autres applications.
Vous pouvez générer un fichier par métaclasse (par exemple, une classe dans
un MOO ou une table dans un MPD), mais vous pouvez également générer
du texte pour une métaclasse qui sera inclus dans un fichier plus global
généré pour un autre objet.
Ce fragment de texte est appelé template. Il se compose de texte mêlé de
variables qui correspondent à des données provenant du modèle.
Vous pouvez accéder à n'importe quelle information contenue dans le modèle
par l'intermédiaire de variables. Ces informations peuvent être de simples
attributs (par exemple le nom d'une classe, un type de données d'attribut, etc.)
ou une collection d'objets (par exemple, la liste des attributs d'une classe). Le
GTL permet également de tester des variables, et d'utiliser certaines macros
dans le but de générer une disposition particulière.
Le processus de génération évalue quelles sont les métaclasses pour
lesquelles des fichiers doivent être générés, puis, sur cette base, crée un
fichier pour chaque objet dans le modèle qui appartient à cette métaclasse.
Lors de la génération, chaque template et chaque variable est évalué et
remplacé par sa valeur dans le fichier généré.
368 PowerAMC
Chapitre 7 Guide de référence de la génération
Concepts pris en Le langage de génération par template prend en charge des concepts orientés
charge objet tels que les héritages et le polymorphisme et permet donc de réutiliser
les objets et d'assurer plus facilement leur maintenance. Il met également à
votre disposition des macros conditionnelles, itératives et de format de texte
permettant de spécifier la logique des templates. Les macros fournissent les
structures de programmation génériques pour le test des variables (par
exemple : .if) et permettent l'itération entre les éléments dépendant d'un objet
(par exemple : .foreach.).
Java pour les Dans ce chapitre, la plupart des exemples utilisent le langage Java. Toutefois,
exemples le mécanisme décrit dans cette section est également applicable à tous les
langages objets et à toutes les définitions étendues de modèle.

Définition des concepts utilisés dans le langage de génération par template
Définition des concepts utilisés dans le langage

de génération par template
Les concepts suivants sont utilisés dans le langage de génération par
template.
Définition de templates
Un template se compose de texte et de variables, et peut également contenir

des macros. Il s'agit d'un fragment de texte généré pour un objet. Il se
comporte comme un type de propriété particulier dont la valeur est recalculée
chaque fois que vous l'obtenez. Le contenu d'un template est constitué par le
code généré au format texte.
Un template est associé à une métaclasse donnée, vous pouvez définir autant
de templates que vous le souhaitez pour une métaclasse donnée, cette
dernière est disponible pour tous les objets (instances) de cette métaclasse.
Une métaclasse est une classe du métamodèle (ou classe abstraite). Il peut
s'agir d'un attribut d'entité provenant d'un Modèle Conceptuel de Données
(MCD), d'une table d'un Modèle Physique de Données (MPD), d'une
opération d'un Modèle Orienté Objet (MOO), etc …Les templates permettent
d'accéder complètement aux attributs et collections du métamodèle
PowerAMC ainsi qu'à tous les éléments du modèle.
Les templates sont utilisés pour générer des fichiers, leur rôle est de produire
du texte à des fins de génération. Lors de la génération, l'évaluation d'un
template génère toujours du texte qui peut être stocké dans un fichier et
utilisé pour rassembler des informations sur un objet donné.
Un template peut également faire référence à n'importe quel template (y
compris à lui-même) afin de promouvoir la récursion et le partage de code de
template, le second template est évalué et sa valeur est située dans le résultat
du premier template.
Exemple Exemple de template :
.foreach_item (Parameters)
%definition%
.next(", ")
370 PowerAMC
Exemples
Vous allez trouver des exemples spécifiques de l'utilisation des templates
dans les différentes sections de ce chapitre.
Un template est construit à l'aide de la syntaxe suivante :

template = <template-complexe>
template-complexe = (<macro-bloc> | <macro-simple> |
<simple-template<)*
template-simple = (<texte> | <bloc-variables> | <bloc-
conditionnel>)*
Pour plus d'informations sur certaines parties de la syntaxe ci-dessus,
reportez-vous à leur définition dans la suite de ce chapitre.
Vous pouvez utiliser des templates simples ou complexes. Un template
simple ne contient pas de macros, tandis qu'un template complexe en
contient.
Exemple de La syntaxe d'un template simple se présente comme suit :
template simple %Visibility% %DataType% %Code% [= %InitialValue]
Lorsqu'il est évalué, ce template qui contient les 4 variables Visibility,

DataType, Code et InitialValue qui seront remplacées par les valeurs
provenant de l'objet courant dans le modèle. Compte tenu du fait que le signe
= et la valeur de la dernière variable InitialValue se trouvent entre crochets,
cette section du template ne sera générée que si InitialValue n'est pas void.
Exemple de La syntaxe d'un template complexe peut se présenter comme suit :
template complexe
Chaque variable entre % peut être le nom d'un attribut, ou bien une propriété
de l'objet courant, ou encore le nom d'un template.
Pour plus d'informations sur les variables, reportez-vous à la section
Définition des variables.

Exemple de Dans Java, ouvrez la catégorie Profile\Operation\Templates dans le langage

templates Java objet pour afficher tous les templates utilisés pour la génération d'opérations
existant dans le MOO.
Définition des variables
Les variables sont des valeurs qualifiées encadrées par des caractères % et
éventuellement précédés par des options de format. Au moment de
l'évaluation, elles sont remplacées par la valeur correspondante dans la portée
de la traduction courante.
Une variable peut avoir l'un des types suivants :
♦ Attribut d'un objet
♦ Membre d'une collection ou d'une collection étendue
♦ Template
♦ Variable d'environnement
Par exemple, la variable %Name% d'une interface peut être directement
évaluée dans une macro et remplacée par le nom de l'interface dans le fichier
généré.
Respect de la casse
Attention, la casse des caractères est prise en compte pour les noms de
variable. La première lettre d'un nom de variable doit être une majuscule,
comme dans %Code%.
Syntaxe des
variables Les variables suivantes sont représentées avec leur syntaxe possible :
Variable Syntaxe
bloc-variable '%' ['.' <options-format> ':'] <variable> '%'
variable [<portée-externe> '.'] [<objet-variable> '.'] [<portée-objet>
'.']<membre-objet>
[<portée-externe> '.'] [<objet-variable> '.'] [<portée-
collection> '.']<membre-collection>
[<portée-externe> '.']<variable-locale>
[<portée-externe> '.'] <global-variable>
372 PowerAMC
Variable Syntaxe
membre-objet <propriété>
[<code-cible> '::'] [<nom-métaclasse> '::'] <nom-
template>['('<liste-paramètres>')']
[<code-cible> '::']<attribut-étendu>
[' * ']+ <valeur-locale> ['('<liste-paramètres>')']
membre-collection 'First'
'IsEmpty'
'Count'
local-variable <objet-local>
[' * '] <valeur-locale>
variable-globale <objet-global>
<valeur-globale>
'$' <variable-environnement>
objet-variable <objet-global>
<objet-local>
portée-externe [<portée-externe> '.'] 'Outer'
portée-objet [<portée-objet> '.'] <objet-membre-objet>
<portée-collection> '.' <collection-membre-objet>
objet-membre-objet <propriété-typeobjet>
objet-membre- 'First'
collection
portée-collection [<portée-objet> '.'] <collection>
[<portée-objet> '.'] <collection étendue>*
* La collection inverse d'une collection étendue ne peut pas être évaluée avec le langage de
génération par template
Pour plus d'informations sur les collections étendues, reportez-vous à la

section Définition d'une collection étendue dans un profil, dans le chapitre
Gestion des profils.

Membres d'objet
Un membre d'objet peut être une propriété standard, un template ou un

attribut étendu. Il peut y avoir trois types de propriété standard : boolean,
string ou object. La valeur d'une propriété standard peut être :
♦ 'true' ou 'false' s'il s'agit d'une propriété de type boolean
♦ 'null' ou 'notnull' s'il s'agit d'une propriété de type object
La valeur d'un template est le résultat de sa conversion (remarquez qu'un
template peut être défini par rapport à lui-même, c'est-à-dire de façon
récursive).
La valeur d'un attribut étendu peut également être un template, auquel cas
elle est convertie. Ceci permet de définir les templates sur une base objet
(instance) plutôt que sur une base métaclasse.
Pour éviter les conflits de nom lorsque l'évaluation d'un template s'étend sur
plusieurs cibles, il est possible de préfixer à la fois les attributs étendus et les
templates par le code de leur cible parent. Par exemple :
%Java::strictfp% ou %C++::definition%
Les noms de template peuvent également être préfixés par le nom de leur
métaclasse parent. Ceci vous permet d'invoquer un template redéfini, en
contournant de fait le mécanisme de résolution de template dynamique. Par
exemple : %Classifier::definition%
Vous avez également la possibilité de spécifier une liste de paramètres. Les
valeurs de paramètre ne doivent pas contenir de caractères % et être séparées
par des virgules. Les paramètres sont transmis sous forme de variables
locales @1, @2, @3… définies dans la portée de la conversion du template.
Si le template MyTemplate est défini de la façon suivante :
Parameter1 = %@1%
Parameter2 = %@2%
L'évaluation de %MyTemplate(MyParam1, MyParam2)% va produire :
Parameter1 = MyParam1
Parameter2 = MyParam2
374 PowerAMC
Opérateur de La syntaxe ['*']+ <valeur-locale> ['('<liste-paramètres>')']

déréférencement renvoie le membre d'objet défini par l'évaluation de ['*']+ <valeur-
locale>. Si le membre d'objet spécifié est un template, une liste de
paramètres peut être spécifiée. Le fait d'appliquer l'opérateur astérisque
correspond à une double évaluation (l'opérateur * agit comme un opérateur
de déréférencement).
Supposons qu'une variable locale soit définie de la façon suivante :
.set_value(C, Code)
Dans ce cas, %C% va renvoyer "Code" et %*C% va renvoyer le résultat de
l'évaluation de %Code%. En d'autres termes, %*C% peut être considéré
comme %(%C%)% (la dernière syntaxe étant incorrecte).
Membres de collection
Les membres de collection disponibles sont les suivants :
Nom Type Description

First Object Renvoie le premier élément de la collection
IsEmpty Boolean Permet de tester si une collection est vide. True si la
collection est vide, false dans le cas contraire
Count Integer Nombre d'éléments de la collection
Remarque : Count est tout particulièrement utile pour définir des critères
basés sur la finle de la collection, par exemple (Attributes.Count>=10).
Variables locales
Les variables locales ne sont visibles dans la portée que si elles sont définies
dans ses portées internes.
Les variables locales peuvent être définies en utilisant les macros set_object
et set_value.
Pour plus d'informations sur les macros set_object et set_value,
reportez-vous aux sections Macro set_object et Macro set_value.

Opérateur de Les variables définies via la macro set_object sont référencées comme des
déréférencement objets locaux, tandis que celles définies à l'aide de la macro set_value sont
appelées valeurs locales. L'opérateur de déréférencement * peut être appliqué
aux valeurs locales.
L'opérateur * permet l'évaluation des variables dont le nom est la valeur de la
variable locale spécifiée.
'%'['.' <options-format> ':'] '*' <variable-locale>'%'
Par exemple, le code suivant :
.set_value(i, Code)
%*i%
Equivaut à :
%Code%
Variables globales
Les variables globales sont disponibles quelle que soit la portée courante.
Certaines variables spécifiques au langage de génération par template sont
répertoriées dans le tableau suivant :
Nom Type Description

ActiveModel Object Modèle actif
GenOptions struct Permet d'accéder aux options de génération
définies par l'utilisateur
PreviewMode boolean True si en mode Aperçu, false en mode de
génération de fichier
CurrentDate String Date et heure système courante, mises en forme en
fonction des paramètres régionaux en vigueur
CurrentUser String Login utilisateur courant
NewUUID String Renvoie un nouvel UUID
Portée externe
Une portée externe peut être accessible à l'aide du mot clé Outer. Le fait de
spécifier une portée change la portée de la conversion courante utilisée pour
l'évaluation de la variable.
376 PowerAMC
Pour plus d'informations et des exemples sur la portée externe,

reportez-vous aux illustrations de la section Définition de la portée de la
conversion.
Portée de l'objet
Pour accéder aux membres d'un objet qui n'est pas actif dans la portée de la
conversion courante, il est possible de spécifier une portée d'objet. Le fait de
spécifier une portée d'objet change la portée de la conversion courante
utilisée pour évaluer la variable.
Le caractère '.' (point) se comporte comme un opérateur d'indirection comme
dans le langage de programmation Java, le côté droit correspond à un
membre de l'objet référencé par le côté gauche.
Portée de la collection
Pour accéder aux membre d'une collection, vous pouvez spécifier une portée
de collection. Le caractère '.' (point) se comporte comme un opérateur
d'indirection comme dans le langage de programmation Java, le côté droit
correspond à un membre de la collection référencée par le côté gauche.
Par exemple :
Définition d'options de formatage de variable
Les variables ont une syntaxe qui impose un format à leurs valeurs. Les
utilisations classiques de ces options sont les suivantes :
♦ Forcer les valeurs en majuscules ou un minuscules
♦ Tronque les valeurs
♦ Met le texte entre apostrophes ou entre guillemets
Vous pouvez incorporer des options de format dans la syntaxe d'une variable
comme suit :
%.format:variable%

Les options de format pour les variables sont les suivantes :
Option Description
n (n représente un Extrait les n premiers caractères. Des espaces ou des zéros
entier) sont ajoutés à gauche pour compléter la largeur et justifier le
résultat à droite
-n Extrait les n derniers caractères. Des espaces ou des zéros
sont ajoutés à droite pour compléter la largeur et justifier le
résultat à gauche
L Convertit les caractères en minuscules
U Convertit les caractères en majuscules
c Initiale majuscule et les autres caractères en minuscules
A Supprime automatique le retrait à droite et aligne le texte sur
le bord gauche
D Affiche la valeur d'interface d'une propriété d'objet avec un
nom différent dans la ligne de code. Dans l'exemple suivant,
la valeur pour la visibilité sera 'public', tandis que cette valeur
est stockée sous la forme '+' dans le MOO.
%Visibility% = +
%.D:Visibility% = public
F Combiné avec L et U, applique la conversion sur le premier
caractère
T Les espaces de gauche et de droite sont supprimés de la
variable
q Place la variable entre apostrophes
Q Place la variable entre guillemets
X Ignore les caractères interdits pour XML
Vous pouvez combiner les codes de format. Par exemple, %.U8:CHILD%

convertir les 8 premiers caractères du code de la table CHILD en majuscules.
378 PowerAMC
Définition de la portée de la conversion
Les templates sont instanciés via un processus appelé conversion. La

conversion est effectuée dans une portée définie et consiste à remplacer les
variables par leurs valeurs correspondante dans le cadre défini par la portée
Tous les templates sont définis par rapport aux classes du métamodèle, ils
sont considérés comme des propriétés d'un type particulier qui utilisent le
résultat de leur conversion comme valeur.
Une portée est un contexte pour l'évaluation d'un template, il inclut l'objet
actif et les variables locales. A un point donné de la conversion, un seul objet
est actif ; il s'agit de l'objet auquel le template est appliqué. Au sein d'une
portée de conversion, tous les attributs et collections de métamodèle définis
dans la métaclasse de l'objet actif et ses parents sont visibles, de même que
les attributs étendus et templates correspondantes. Lorsque le moteur de
conversion commence à évaluer un template, une nouvelle portée de
conversion est créée.
Pour plus d'informations sur les collections d'objets, reportez-vous à la
section Associations et collections, dans le chapitre Métamodèle public
PowerAMC.
Lorsqu'une portée est créée il s'agit de la portée de la conversion

courante, l'ancienne portée de conversion constituant la portée externe de la
portée de conversion courante
Lorsqu'une portée est quittée sa portée externe est restaurée comme

étant la portée de conversion courante
Pour plus d'informations sur la portée externe, reportez-vous à la

section Définition des variables.

De nouvelles portées peuvent être créées lors de l'évaluation d'un template

qui force l'objet à changer. Par exemple, la macro foreach_item, qui
permet l'itération sur les collections définit une nouvelle portée, de même que
la macro foreach_line. La portée externe est restaurée à la fin du bloc.
Pour plus d'informations sur ces deux macros, reportez-vous aux
sections Macro foreach_item et Macro foreach_line.
Les portées imbriquées forment une hiérarchie qui peut être affichée sous la
forme d'une arborescence, la portée de plus haut niveau étant la racine.
Exemple L'exemple suivant montre le mécanisme de la portée à l'aide d'un template de
classe :
Conversion d'un raccourci
Les raccourcis sont déréférencés lors de la conversion : la portée de l'objet

cible remplace la portée du raccourci.
Par exemple, le fichier généré suivant défini dans la métaclasse package
fournit la liste des classes contenues dans le package. Si un raccourci vers
une classe est trouvé, le code de son objet cible suivi de (Raccourci) est
généré, suivi par l'ID de l'objet parent, puis par l'ID du raccourci, ce qui
montre clairement que la portée du raccourci est remplacée par la portée de
l'objet cible du raccourci :
.foreach_item(Classes)
.if (%IsShortcut%)
%Code% (Raccourci)
oid = %ObjectID%
shortcut oid = %Shortcut.ObjectID%
.else
%Code%
380 PowerAMC
%Shortcut%
.endif
.next(\n)
Ce comportement est l'inverse de celui du VB Script, dans lequel la
conversion des raccourcis récupère le raccourci lui-même.
Si un raccourci externe a le statut fermé, il est ignoré lors de la conversion et
n'apparaît pas dans le fichier généré.
Si vous souhaitez générer le raccourci lui-même plutôt que l'objet auquel il
fait référence, vous pouvez utiliser la variable %Shortcut%.
Définition d'un héritage
Les templates sont définis par rapport à une classe de métamodèle donnée et
sont hérités par ses enfants. Ils sont hérités par tous les enfants de la
métaclasse pour laquelle ils sont définis. Ce mécanisme est utile pour
partager le code de template entre différentes métaclasses ayant un parent en
commun.
Exemple Exemple d'héritage : Un classificateur/définition est disponible via l'héritage
d'une classe et d'une interface. Dans l'exemple suivant, le template de
définition spécifié sur la métaclasse parent est utilisé dans l'évaluation du
template de contenu sur la métaclasse enfant.
Redéfinition d'un template
La redéfinition d'un template signifie qu'un template défini par rapport à une
métaclasse peut être redéfini sur une classe enfant, auquel cas le template de
la métaclasse parent est dit redéfini. La nouvelle définition masque la
première pour les objets de la métaclasse enfant.
Pour pouvoir utiliser la définition d'une métaclasse parent particulière, le
langage de génération par template fournit l'opérateur qualifiant "::".

Exemple
Le même nom de template "isAbstract" est utilisé dans deux catégories

différentes : Classifier et Class. "false" est la valeur d'origine qui a été
redéfinie par la nouvelle valeur "true". Vous pouvez récupérer la valeur
d'origine en utilisant la syntaxe suivante : <metaclassName::template>, dans
ce cas :
%isAbstract%
%Classifier::isAbstract%
Définition du polymorphisme
Les templates sont liés de façon dynamique. En d'autres termes, le choix du

template à évaluer et effectué au moment de la conversion en fonction du
type d'objet auquel il est appliqué. Ce mécanisme est comparable au
mécanisme d'invocation de méthode virtuelle en vigueur dans les langages
orientés objet.
Le polymorphisme est obtenu en permettant la redéfinition du template dans
les classes dérivées. Par exemple, il peut être utile dans Java de définir
Generated Files sur le classificateur. Le polymorphisme permet au code de
template défini sur un classificateur d'utiliser des templates définis sur ses
enfants (classe, interface), le template utilisé n'a pas à être défini sur la
métaclasse parent. Combinée avec les héritages, cette fonctionnalité permet
de partager le code de template.
Exemple
382 PowerAMC
Le contenu de %definition% est celui défini dans Classifier pour une

interface, et celui défini dans Class pour une classe.
Définition d'une surcharge de template
Vous pouvez avoir plusieurs définitions du même template qui s'appliquent à

différentes conditions. Si tel est le cas, le template n'est défini que pour les
objets qui satisfont à la condition (les templates sont toujours liés de façon
dynamique). La fonctionnalité de surcharge peut être utilisée comme un
mécanisme de commutation très puissant : vous pouvez trier les éléments par
ordre alphabétique afin d'obtenir une meilleure lisibilité lorsque vous
rassemblez différentes versions du même template. Elle permet également
d'améliorer la lisibilité en évitant d'utiliser des conditions .if trop longues.
Au moment de la conversion, le moteur de conversion évalue chaque
condition successivement jusqu'à ce qu'il en trouve une qui soit vérifiée, puis
prend alors la définition de template correspondante. Si aucune condition
n'est vérifiée, le template non conditionnel, s'il est défini, est utilisé par défaut
(voir syntax1 dans l'illustration suivante).
Les conditions doivent être mutuellement exclusives pour garantir un
comportement déterministe.
Les templates peuvent également être définis sous des critères ou des
stéréotypes, auxquels cas les conditions correspondantes sont combinées.
Pour plus d'informations sur les critères et les stéréotypes, reportez-
vous aux sections Définition d'un critère et Définition d'un stéréotype, dans le
Exemple
Pour plus d'informations sur <condition-simple>, reportez-vous à la

section Macro if.
Définition des séquences d'échappement
Des séquences d'échappement sont des séquences de caractères spécifiques

utilisées pour configurer la présentation du fichier généré.

Les séquences d'échappement suivantes peuvent être utilisées dans des

templates :
Séquence
d'échappement Description
\n Caractère de passage à la ligne, crée une nouvelle
ligne
\t Caractère de tabulation, crée une tabulation
\\ Crée une barre oblique inverse
\ au début d'une ligne Crée un caractère de suite (ignore la nouvelle ligne)
. au début d'une ligne Ignore la ligne
.. au début d'une ligne Crée un caractère point (pour générer une macro)
%% Crée un caractère pourcent
Pour plus d'informations sur les séquences d'échappement, reportez-

vous à la section Utilisation de nouvelles lignes dans la chaîne d'en-tête et de
fin.
Utilisation de macros
Les macros peuvent être utilisées pour exprimer la logique, et pour boucler
sur des collections d'objets. Chaque mot clé de macro doit être précédé d'un
caractère "." (point) et doit être le premier caractère, autre qu'un espace, sur
une ligne. Prenez soin de respecter la syntaxe des macros en termes de
passage à la ligne.
Vous pouvez définir une macro dans un template, ou dans une commande.
Vous pouvez définir trois types de macros, comme indiqué dans le tableau
suivant :
Macro Syntaxe
Macro de bloc <if> | <vbscript> | <unique> | <lowercase> |
<uppercase> | <replace> | <delete> | <block>
Macro de <foreach_item> | <foreach_line> | <foreach_part>
boucle
Macro simple <bool> | <set_object> | <set_value> |
<execute_vbscript> | <execute_command> |
<abort_command> | <change_dir> | <create_path> |
<log> | <warning> | <error>
384 PowerAMC
Macro de bloc
Les macros de bloc se composent d'un mot clé de début et d'un mot clé de fin
délimitant un bloc auquel la macro est appliquée.
Leur structure se présente comme suit :
'.'<nom-macro> ['(' <paramètres> ')' ]
<bloc-entrée-macro>
'.'end<nom-macro> [ '(' <tail> ')' ]
<fin> est une constante de type chaîne facultative et qui est ajoutée au texte
généré, s'il existe.
Macro de boucle
Les macros de boucle sont utilisées pour l'itération. A chaque itération, une
nouvelle portée est créée. Le template spécifié dans le bloc est converti
simultanément conformément à la portée d'itération.
'.'foreach_<nom-macro> ['(' <paramètres> [',' <head>
[',' <fin>]] ')' ]
<template-complexe>
'.'next [ '(' <séparateur> ')' ]
<head> et <fin> sont des constantes de type chaîne facultatives. <head> est
générée avant, et <fin> est ajoutée après le texte généré, s'il existe.
Un <séparateur> peut également être spécifié comme argument pour le mot
clé .next, il est placé entre des évaluations non vide de <template-complexe>.
Macro simple
Les macros simples sont les macros qui ne sont constituées que d'une seule
ligne.
Délimiteurs de paramètres de macro

Les paramètres de macro peuvent être délimités par des guillemets. Les
délimiteurs sont requis lorsque la valeur du paramètre inclut des virgules,
des accolades et des espaces de début ou de fin. La séquence
d'échappement pour les guillemets au sein d'un paramètre est \".

Macro if
La macro if est utilisée pour la génération conditionnelle, et a la syntaxe

suivante :
if= .if[not] <condition>
<template-complexe>
[(.elsif[not] <condition>
<template-complexe>)*]
[.else
<template-complexe>]
.endif ['(' <fin> ')']
condition= '(' <condition> ')' or '(' <condition> ')'|
'(' <condition> ')' and '(' <condition> ')' |
'(' <condition> ')' |
<condition-simple>
simple-condition= <variable> [ <opérateur-
comparaison> <condition-rhs> ]
opérateur-comparaison= '==' |
'!=' |
'<=' |
'>=' |
'<' |
'>' |
condition-rhs= <template-simple> |
<constante> |
true |
false |
null |
notnull |
constante= '"' <texte> '"'
386 PowerAMC
Paramètres Paramètre Type Description

<fin> Texte Ajouté à la sortie, si elle existe
Lorsqu'une condition simple se compose d'une seule variable sans opérateur

de comparaison, la condition est fausse lorsque la valeur de la variable est
"false", "null" ou la chaîne null, dans le cas contraire elle est considérée
comme true.
Les opérateurs de comparaison <, >, >=, et <= permettent de comparer des
entiers si les deux opérandes sont des entiers, dans le cas contraire, elles
induisent une comparaison de chaînes intelligente qui prend en compte des
nombres incorporés (exemple : Class_10 est supérieur à Class_2).
Macro vbscript
La macro vbscript est utilisée pour incorporer du code VB script dans un

template. Il s'agit d'une macro de bloc.
La syntaxe d'une macro vbscript est la suivante :
.vbscript ['(' <liste-param-script> ')']
<bloc-entrée-vbscript>
.endvbscript ['(' <fin> ')']

<liste-param- Liste d'arguments de Paramètres passés sur le script via le
script> template-simple tableau ScriptInputArray
(facultatif) séparés par des
virgules
<bloc-entrée- Texte Texte VB script
vbscript>
<fin> Texte Ajouté à la sortie, si elle existe
Résultat Le résultat de la valeur ScriptResultArray.

Exemple :
.vbscript(hello, world)
ScriptResult = ScriptInputArray(0) + " " +
ScriptInputArray(1)
.endvbscript

Le résultat est le suivant :

hello world
Remarque : l'objet actif de la portée de conversion courante est accessible via
la collection ActiveSelection en tant que ActiveSelection.Item(0).
Pour plus d'informations sur ActiveSelection, reportez-vous à la section
Propriétés globales, dans le chapitre Manipulation des objets via VBScript,
dans le manuel Guide des fonctionnalités générales.
Macro unique
L'objet de la macro unique est de définir un bloc dans lequel l'unicité de

chaque ligne du texte généré est garantie. Cette macro peut être utile pour
calculer les importations, inclusions, typedefs ou de déclarations anticipées
dans des langages tels que Java, C++ ou C#.
.unique
<bloc-entrée-unique>
.endunique['(' <fin> ')']

<bloc-entrée- Template Paramètre utilisé pour saisir du texte
unique> complexe
<fin> Texte Ajouté au résultat, s'il y en a un
Résultat Le résultat est le bloc fourni en entrée dans lequel chaque ligne redondante a
été supprimée.
Exemple :
.unique
import java.util.*;
import java.lang.String;
%imports%
.endunique
388 PowerAMC
Macro lowercase
La macro .lowercase transforme en minuscules toutes les lettres majuscules

d'un bloc de texte.
.lowercase
<bloc-entrée-minuscules>
.endlowercase
Cette macro est particulièrement utile lorsque vous travaillez sur les
conventions de dénomination.
Pour plus d'informations les conventions de dénomination, reportez-
vous à la section Définition des conventions de dénomination, dans le
chapitre Gestion des modèles du manuel Guide des fonctionnalités générales.
<bloc-entrée- Template Un paramètre est utilisé pour spécifier du texte
minuscules> complexe
Résultat Le résultat est le bloc utilisé en entrée et dans lequel toutes les majuscules ont
été converties en minuscules.
Dans l'exemple suivant, la variable %Comment% a pour valeur 'BONJOUR'
qui est convertie en 'bonjour.
.lowercase
%Comment%
.endlowercase
Macro uppercase
La macro .lowercase transforme en majuscules toutes les lettres minuscules

d'un bloc de texte.
.uppercase
<bloc-entrée-uppercase>
.enduppercase


uppercase> complexe
Résultat Le résultat est le bloc utilisé en entrée et dans lequel toutes les minuscules ont
été converties en majuscules.
Dans l'exemple suivant, la variable %Comment% a pour valeur 'bonjour' and
qui est convertie en 'BONJOUR.
.uppercase
%Comment%
.enduppercase
Macro replace
La macro .replace remplace toutes les occurrences d'une chaîne par une autre
chaîne dans un bloc de texte.
La macro .replace remplace l'ancienne chaîne <ancienne-chaîne> par la
chaîne <nouvelle-chaîne> dans le bloc de texte <Bloc>.
.replace '(' <ancienne-chaîne> ',' <nouvelle-chaîne> ')'
<bloc-entrée-replace>
.endreplace

<ancienne- Texte Chaîne contenant les caractères à remplacer
chaîne> par <nouvelle-chaîne>
<nouvelle- Texte Chaîne contenant les caractères qui
chaîne> remplacent <ancienne-chaîne>
390 PowerAMC
Paramètre Type Description

<bloc-entrée- Template Un paramètre est utilisé pour spécifier du
replace> complexe texte
Résultat Le résultat est que toutes les occurrences de la chaîne <ancienne-chaîne> sont
remplacées par des instances de la chaîne <nouvelle-chaîne> dans le bloc
spécifié.
Dans l'exemple suivant, 'GetCustomerName' est converti en
'SetCustomerName'.
.replace( get , set )
GetCustomerName
.endreplace
Dans l'exemple suivant, la variable %Name% a pour valeur 'Customer
Factory' et est convertie en 'Customer_Factory'.
.replace(" ", "_")
%Name%
.endreplace
Macro delete
La macro .delete supprime toute les occurrences d'une chaîne dans un bloc de
texte. Dans le script suivant, elle supprime la chaîne <chaîne-suppr> dans le
bloc.
.delete '('<chaîne-suppr> ')'
<bloc-entrée-delete>
.enddelete
<chaîne-suppr> Texte Chaîne à supprimer dans le bloc
delete> complexe

Résultat Le résultat est que toutes les occurrences de la chaîne <chaîne-suppr> sont
supprimées dans le bloc spécifié.
Dans l'exemple suivant, 'GetCustomerName' est converti en 'CustomerName'.
.delete( get )
GetCustomerName
.enddelete
Dans l'exemple suivant, la variable %Code% a la valeur 'm_myMember' et
est convertie en 'myMember'.
.delete(m_)
%Code%
.enddelete
Macro block
La macro .block est utilisée pour ajouter un en-tête et/ou une fin à son
contenu lorsque ce dernier n'est pas vide.
.block ['('<en-tête> ')']
<bloc-entrée>
.endblock['(' <fin> ')']

<en-tête> Template simple Généré avant le résultat, s'il y en un
(facultatif)
(facultatif)
<bloc-entrée> Template Un paramètre est utilisé pour spécifier du texte
complexe
Résultat Le résultat est la concaténation de <en-tête>, l'évaluation de <bloc-entrée> et

<fin>.
Exemple :
.block (<b>)
The current text is in bold
.endblock (</b>)
392 PowerAMC
Macro convert_name
La macro .convert_name utilise la table de conversion d'un nom en code.

Lorsqu'aucune occurrence n'est trouvée dans la table, c'est le nom qui est
renvoyé.
.convert_name (<Expression> [,<caractère-séparateur>
[,<séparateur-motif>]])
L'expression <Expression> est le nom à convertir dans la table de conversion

correspondante.
<séparateur-motif> Texte Déclaration des différents séparateurs qui
(facultatif) peuvent exister dans un nom. Ces séparateurs
seront remplacés par le <caractère-séparateur>.
Vous pouvez déclarer plusieurs séparateurs, par
exemple "space" et "tab"
<caractère- Texte Caractère généré chaque fois qu'un séparateur
séparateur> déclaré dans <séparateur-motif> est trouvé dans
(facultatif) le nom. Par exemple, ce caractère peut être "_"
Vous pouvez utiliser la macro .convert_name avec une table de conversion

personnalisée que vous sélectionnez dans la liste déroulante Table de
conversion. Pour ce faire, affichez la boîte de dialogue Options du modèle,
sélectionnez l'objet approprié dans la catégorie Conventions de
dénomination, puis cliquez sur l'onglet Nom en code.
Les tables de conversion ne tiennent pas compte de la casse des caractères.
Vous pouvez utiliser indifféremment des majuscules et des minuscules dans
ces tables. Cette macro est particulièrement utile lorsque vous travaillez sur
les conventions de dénomination.

Remarque Vous pouvez également utiliser cette macro hors des conventions de
dénomination à condition que la table de conversion soit la table de l'objet
courant du script. Voici un exemple d'une macro qui peut être ajoutée à partir
de la catégorie Profile\Column dans une nouvelle entrée Generated Files :
.foreach_item(Columns)
%Name%,
.foreach_part(%Name%)
.convert_name(%CurrentPart%)
.next("_")
.next(\n)
Pour plus d'informations sur la macro .convert_name, reportez-vous à la
section .convert_name & .convert_code macros, dans le chapitre Définition
des conversions de nom et de code du manuel Guide des fonctionnalités
générales.
Macro convert_code
La macro .convert_code utilise la table de conversion d'un code en nom.

Lorsque la table ne contient aucune occurrence, c'est le code qui est renvoyé.
.convert_code (<Expression> [<caractère-séparateur>
[,<séparateur-motif>]])
L'expression <Expression> est le code à convertir dans la table de conversion

correspondante.
<séparateur-motif> Texte Déclaration des différents séparateurs qui
(facultatif) peuvent exister dans un code. Ces séparateurs
seront remplacés par le <caractère-séparateur>.
Vous pouvez déclarer plusieurs séparateurs, par
exemple "space " et "tab"
<caractère- Texte Caractère généré chaque fois qu'un séparateur
séparateur> déclaré dans <séparateur-motif> est trouvé dans
(facultatif) le code. Par exemple, ce caractère peut être "_"
Vous pouvez utiliser cette macro avec une table de conversion personnalisée
que vous sélectionnez dans la liste déroulante Table de conversion. Pour ce
faire, affichez la boîte de dialogue Options du modèle, sélectionnez l'objet
approprié dans la catégorie Conventions de dénomination, puis cliquez sur
l'onglet Nom en code.
394 PowerAMC
Les tables de conversion ne tiennent pas compte de la casse des caractères.

Vous pouvez utiliser indifféremment des majuscules et des minuscules dans
ces tables. Cette macro est particulièrement utile lorsque vous travaillez sur
les conventions de dénomination.
Remarque Vous pouvez également utiliser cette macro hors des conventions de
dénomination à condition que la table de conversion soit la table de l'objet
courant du script.
Pour plus d'informations sur la macro .convert_code, reportez-vous à la
section Macros .convert_name & .convert_code, (Définition des conversions
de nom et de code) dans le chapitre Gestion des modèles du manuel Guide
des fonctionnalités générales.
Macro foreach_item
La macro foreach_item est utilisée pour l'itération des collections d'objets. Le

template spécifié au sein du bloc est converti sur tous les objets contenus
dans la collection spécifiée. Le bloc définit une nouvelle portée au sein de
laquelle l'objet actif à l'itération i est le membre de collection i-ème membre
de la collection.
Si une comparaison est spécifiée, les éléments de la collection sont pré-triés
en fonction de la règle correspondante avant leur itération :
.foreach_item '(' <portée-collection> [',' <en-tête>
[',' <fin> [',' <condition-simple> [',' <comparaison>
]]]]')'
<template-complexe>
.next ['(' <séparateur> ')']
Définition de Toutes les collections sont accessibles pour un objet donné. Chaque objet
collections PowerAMC peut avoir une ou plusieurs collections correspondant aux objets
avec lesquels il interagit. Les collections expriment le lien entre les objets,
par exemple une table a des collections de colonnes, d'index, de règles de
gestion, etc.
Les collections sont représentées dans le métamodèle public PowerAMC par
des associations entre objets. Les rôles des associations correspondent aux
collections d'un objet.

Pour plus d'informations sur les collections d'objets, reportez-vous à la

section Associations et collections, dans le chapitre Métamodèle public
PowerAMC.
<portée-collection> Template Collection sur laquelle l'itération est
simple effectuée
<en-tête> (facultatif) Texte Généré avant le résultat, s'il y en a un
<fin> (facultatif) Texte Ajouté au résultat, s'il y en a un
<condition-simple> Condition Si spécifié, seuls les objets qui satisfont la
(facultatif) simple condition sont considérés lors de l'itération
<comparaison> Condition <comparaison> est évalué au sein d'une
simple portée dans laquelle deux objets locaux
respectivement nommés 'Item1' et 'Item2'
sont définis. Ils correspondent aux éléments
dans la collection. <comparaison> doit être
évalué comme true si Item1 doit être placé
après Item2 dans l'itération
<séparateur> Texte Générer entre deux évaluations de <template-
(facultatif) complexe> non vides
Délimiteurs de paramètres de macro

Les paramètres de macro peuvent être délimités par des guillemets. Les
délimiteurs sont requis lorsque la valeur du paramètre inclut des virgules,
des accolades et des espaces de début ou de fin. La séquence
d'échappement pour les guillemets au sein d'un paramètre est \".
Résultat Le résultat est formé par les évaluations concaténées de <template-

complexe> sur tous les objets dans la collection.
Exemple :
Attribut Type de données Valeur initiale

cust_name String __
cust_foreign Boolean false
.foreach_item(Attributes,,,,%Item1.Code% >=
%Item2.Code%))
Attribute %Code%[ = %InitialValue%];
.next(\n)
396 PowerAMC
Le résultat est le suivant :

Attribute cust_foreign = false
Attribute cust_name;
Remarque Les quatre virgules après (Attributes,,,, signifient que tous les
paramètres (en-tête, fin, condition et comparison) sont sautés.
Macro foreach_line
La macro foreach_line est une macro simple qui procède à l'itération sur les
lignes du template de saisie spécifié comme premier argument pour la macro.
Le template spécifié dans le bloc est converti pour chaque ligne de l'entrée.
Cette macro crée une nouvelle portée avec la variable locale CurrentLine.
Cette dernière est définie dans le bloc comme étant la i-ème ligne du template
en entrée dans l'itération i.
.foreach_line '(' <entrée> [',' <en-tête> [',' <fin>]]
')' <template-complexe>
.next ['(( <séparateur> ')']

<entrée> Template simple Texte en entrée, sur lequel l'itération est
effectuée
<en-tête> Texte Généré avant le résultat, s'il y en a un
(facultatif)
(facultatif)
<séparateur> Texte Généré entre évaluations non vides de
(facultatif) <template-complexe>
Résultat Le résultat est composé des évaluations concaténées de <template-complexe>

pour chaque ligne du template <entrée> converti.
Exemple :
.foreach_line(%Comment%)
// %CurrentLine%
.next(\n)

Macro foreach_part
La macro .foreach_part procède à l'itération sur la partie du template en

entrée spécifiée comme premier argument de la macro. Le template spécifié
dans le bloc est converti pour chaque partie de l'entrée.
Une partie est délimitée avec un motif de séparation. Il existe deux types de
séparateurs :
♦ Séparateur de caractères : pour chaque séparateur de caractères, le
séparateur spécifié dans la prochaine instruction de la macro est renvoyé
(même pour des séparateurs consécutifs)
♦ Séparateur de mots : ils sont spécifiés en tant qu'intervalles, par exemple
[A-Z] spécifie que toutes les lettres majuscules sont des séparateurs.
Pour un séparateur de mots, aucun séparateur (spécifié dans la prochaine
instruction) n'est renvoyé
.foreach_part '(' <entrée> [',' <séparateur-motif> [','
<en-tête> [, <fin>]]] ')'
<template-simple>
.next['(' <séparateur> ')']
Cette macro crée une nouvelle portée dans laquelle la variable locale
CurrentPart est définie comme la i-ème partie du template en entrée à
l'itération i. La variable locale Separator contient le séparateur suivant.
Séparateur-motif Le <séparateur-motif> est défini dans une chaîne entre guillemets et se
comporte comme suit :
♦ Tout caractère spécifié dans le motif peut être utilisé comme séparateur
♦ [<c1> - <c2>] spécifie un caractère au sein de la plage définie entre
les caractères <c1> et <c2>
Par exemple, le motif suivant “ -_,[A-Z]” spécifie que chaque partie peut
être séparée par un espace, un tiret, un trait de soulignement, une virgule ou
un caractère compris entre A et Z (majuscule).
Par défaut, le <séparateur-motif> est initialisé avec le motif (“ -_,\t”). Si
le motif spécifié est vide, le motif est initialisé à l'aide de la valeur par défaut.
398 PowerAMC
Un séparateur <séparateur> peut être concaténé entre chaque partie. Les

expressions <en-tête> et <fin> peuvent être ajoutées respectivement au début
ou à la fin de l'expression générée.
<entrée> Template Texte en entrée sur lequel l'itération est
simple effectuée
<séparateur-motif> Texte Liste de séparateurs
<en-tête> (facultatif) Texte Généré avant le résultat, s'il y en a un
<fin> (facultatif) Texte Ajouté au résultat, s'il y en a un
<séparateur> Texte Généré entre évaluations non vides de
(facultatif) <template-complexe>
Résultat Le résultat est composé des évaluations concaténées de <template-complexe>

pour chaque partie du template <entrée> converti.
Exemples :
Convertit un nom en code de classe (conventions de dénomination Java).
Dans l'exemple suivant, la variable %Name% équivaut à 'Employee
shareholder', et est convertie en 'EmployeeShareholder' :
.foreach_part (%Name%, " _-'")
%.FU:CurrentPart%
.next
Convertit un nom en code d'attribut de classe (conventions de dénomination
Java). Dans l'exemple suivant, la variable %Name% équivaut à 'Employee
shareholder', et est convertie en 'employeeShareholder':
.set_value(_First, true, new)
.foreach_part(%Name%,"' _-'")
.if (%_First%)
%.L:CurrentPart%
.set_value(_First, false, update)
.else
%.FU:CurrentPart%
.endif
.next

Macro bool
Cette macro renvoie 'true' or 'false' en fonction de la valeur de la condition

spécifiée.
.bool '(' <condition> ')'

<condition> Condition Condition à évaluer
Exemple :
.bool(%.3:Code%= =ejb)
Macro set_object
Cette macro est utilisée pour définir une variable locale de type objet (objet
local).
.set_object '(' <nom-var-locale> [',' <object-ref>[',' <new> ]] ')'

<nom-var- Template simple Nom de la variable
locale>
<object-ref> [<portée>.]<portée Décrit une référence d'objet. S'il n'est pas
(facultatif) -objet>] spécifié ou s'il s'agit d'une chaîne vide, la
variable est une référence à l'objet actif dans
la portée de conversion courante
<new> new ou update (la Si le paramètre est 'new', crée une nouvelle
(facultatif) valeur par défaut variable et ce, même s'il en existe déjà une
est update) dans la portée courante, tandis que le
paramètre 'update' modifie la valeur de la
variable dans la portée courante, ou crée une
nouvelle variable s'il n'en existe aucune
La variable est une référence à l'objet spécifié à l'aide du second argument.

Exemple :
.set_object(Attribute1, Attributes.First)
400 PowerAMC
Remarque
Lorsque vous spécifiez une nouvelle variable, il est recommandé de
spécifier 'new' comme troisième argument pour vous assurer qu'une
nouvelle variable soit créée dans la portée courante.
Macro set_value
Cette macro est utilisée pour définir une variable locale ou un type de valeur.
.set_value '(' <nom-var-locale> ')' <value>[',' <new> ')'

<nom-var- Template simple Nom de variable
locale>
<value> Template simple Valeur
(séquences
d'échappement
ignorées)
<new> New ou update (la Si la valeur est new, (re)définit la variable
(facultatif) valeur par défaut dans la portée courante.
est update) Si la valeur est update, met à jour la variable
existante. Dans le cas contraire, définit une
nouvelle variable
La valeur de la variable est définie pour être la valeur du template converti

spécifiée comme second argument.
Exemple :
.set_value(FirstAttributeCode, %Attributes.First.Code%)
Remarque
Lorsque vous spécifiez une nouvelle variable, il est recommandé de
spécifier 'new' comme troisième argument pour vous assurer qu'une
nouvelle variable soit créée dans la portée courante.

Macro execute_vbscript
Cette macro est utilisée pour exécuter un script VB spécifié dans un fichier
séparé.
.execute_vbscript '(' <fichier-vbs> [',' <script-
parameter>] ')'

<fichier-vbs> Template simple Chemin d'accès du fichier VB script
(séquences
d'échappement
ignorées)
<paramètre- Template simple Paramètre passé au script via la propriété
script> globale ScriptInputParameters
(facultatif)
Résultat Le résultat est la propriété globale ScriptResult.

Exemple :
.execute_vbscript(C:\samples\vbs\login.vbs, %username%)
Remarque : l'objet actif de la portée de conversion courante est accessible via
la collection ActiveSelection en tant que ActiveSelection.Item(0).
Pour plus d'informations sur ActiveSelection, reportez-vous à la section
Propriétés globales, dans le chapitre Manipulation des objets via VBScript du
manuel Guide des fonctionnalités générales.
Macro execute_command
Cette macro est utilisée pour lancer des exécutables sous forme de processus
séparés. Elle est disponible pour exécuter des commandes de génération
uniquement, et peut être combinée aux macros standard du langage de
génération par template lorsque vous définissez des commandes.
.execute_command '(' <cmd> [',' <args> [',' <mode>]] ')'

<cmd> Template simple Chemin d'accès d'exécutables
(séquences
d'échappement
ignorées)
402 PowerAMC
Paramètre Type Description

<args> Template simple Arguments pour l'exécutable
(facultatif) (séquences
d'échappement
ignorées)
<mode> cmd_ShellExecute cmd_ShellExecute est exécuté comme
(facultatif) or processus indépendant
cmd_PipeOutput cmd_PipeOutput bloque jusqu'à la fin de
l'exécution, puis montre le résultat de
l'exécutable dans la fenêtre Résultats
Remarquez que si une commande .execute_command échoue pour une raison

quelconque (exécutables non trouvés, ou bien résultat envoyé vers stderr),
l'exécution de la commande est interrompue.
Exemple :
.execute_command(notepad, file1.txt, cmd_ShellExecute)
Macro abort_command
Cette macro stoppe l'exécution de la commande. Elle est disponible pour

exécuter des commandes de génération uniquement, et peut être combinée
aux macros standard du langage de génération par template lorsque vous
définissez des commandes.
Exemple :
.if %_JAVAC%
.execute (%_JAVAC%,%FileName%)
.else
.abort_command
.endif
Macro change_dir
Cette macro change le répertoire courant. Elle est disponible pour exécuter
des commandes de génération uniquement, et peut être combinée aux macros
standard du langage de génération par template lorsque vous définissez des
commandes.
.change_dir '(' <chemin> ')'

Paramètre Paramètre Type Description

<chemin> Template simple Nouveau répertoire courant
(séquences
d'échappement
ignorées)
Exemple :
.change_dir(C:\temp)
Macro create_path
Cette macro créé un chemin spécifié si ce dernier n'existe pas.

.create_path '(' <chemin> ')'

<chemin> Template simple Chemin à créer
(séquences
d'échappement
ignorées)
Exemple :
.create_path(C:\temp)
Macro log
Cette macro consigne un message dans la page Génération de la fenêtre

Résultats, située dans la partie inférieure de la fenêtre principale. Elle est
disponible pour exécuter des commandes de génération uniquement, et peut
être combinée aux macros standard du langage de génération par template
lorsque vous définissez des commandes.
.log <message>

<message> Template simple Message à consigner
Exemple :
.log undefined environment variable: JAVAC
404 PowerAMC
Macro warning
La macro warning est utilisée pour produire un avertissement lors de la

conversion. Elle peut être utile pour afficher un message lorsqu'une
incohérence est détectée pendant que vous appliquez le template à un objet
particulier. Les avertissements n'interrompent pas la génération, et
n'apparaissent pas non plus dans le fichier généré. Le contenu du message
d'avertissement est le template simple évalué, passé par paramètre.
Il apparaît dans la fenêtre Résultats (située dans la partie inférieure de la
fenêtre principale) lors de la génération, est affichée dans le code dans la
page Aperçu de la feuille de propriétés de l'objet, si au moins une erreur a été
rencontrée.
.warning <message>

<message> Template simple Message d'avertissement
Exemple :
.warning Les associations bidirectionnelles entre
classes internes ne sont pas prises en charge
Macro error
La macro error est similaire à la macro warning en ceci qu'elle n'apparaît pas
dans le fichier généré. En revanche error stoppe la génération. Le message
d'erreur est le template spécifié converti pour l'objet actif. Il est affiché à la
fois dans la page Aperçu de la feuille de propriétés de l'objet et dans la
fenêtre Résultats.
.error <message>

<message> Template simple Message d'erreur
Exemple :
.error aucune valeur initiale fournie pour l'attribut
%Code% de la classe %Parent.Code%

Commentaire et macro //
Le commentaire et la macro // sont utiles pour insérer des commentaires dans

un template. Les lignes qui commencent par .// ou par .comment sont
ignorées lors de la génération.
Exemple :
.// Ceci est un commentaire utilisateur
Définition de blocs conditionnels
Les blocs conditionnels peuvent être utilisés pour spécifier différents

templates en fonction de la valeur d'une variable.
{syntax 1}: '[' <variable> '?' <template-simple> [':'
<template-simple>] ']'
{syntax 2}: '[' <texte> <variable> <texte> ']'
Syntaxe 1 est similaire à C et aux expressions ternaires Java. Si la valeur de
la variable est false, null, ou la chaîne null, le second template, s'il est
spécifié, est évalué. Dans le cas contraire, c'est le premier template qui est
évalué.
Syntax 2 a une signification légèrement différente. Le template simple
<texte><variable><texte> est converti si et uniquement si la valeur de la
variable n'est pas la chaîne null.
Exemple : déclaration d'attribut dans Java :
%Visibility% %DataType% %Code% [= %InitialValue%]
Définition de messages d'erreur
Les messages d'erreur interrompent la génération du fichier dans lequel des

erreurs ont été trouvées. Ces erreurs sont affichées dans la page Aperçu de la
feuille de propriétés de l'objet correspondant.
Les messages d'erreur ont le format suivant :
406 PowerAMC
Vous pouvez rencontrer les types d'erreur suivants :

♦ Erreurs de syntaxe
♦ Erreurs de conversion
Erreurs de syntaxe
Vous pouvez rencontrer les erreurs de syntaxe suivantes :
Message d'erreur Description et correction

Erreur de syntaxe dans la condition Erreur de syntaxe dans une expression
booléenne
.endif attendu Ajoutez un .endif
.else sans .if correspondant Ajoutez un .if au .else
.endif sans .if correspondant Ajoutez un .if au .endif
.next attendu Ajoutez un .next
.end%s attendu Ajoutez un .end%s (par exemple, .endunique,
.endreplace, …)
.end%s sans .%s correspondant Ajoutez un .<macro> au .end<macro>
.next sans .foreach correspondant Ajoutez un .foreach au .next
Parenthèses manquantes ou non Corrigez les éventuelles accolades non
appariées appariées
Paramètre inattendus : <params- Supprimez les paramètres nécessaires
supplémentaires>
Macro inconnue La macro n'est pas valide
.execute_command [syntaxe La syntaxe appropriée s'affiche dans la page
incorrecte] Aperçu, ou bien dans la fenêtre Résultats :
.execute_command(<exécutable>[,<arguments
>[,{cmd_ShellExec|cmd_PipeOutput}]])
Change_dir [syntaxe incorrecte] La syntaxe doit être : .change_dir(<chemin>)
convert_name [syntaxe incorrecte] La syntaxe doit être : .convert_name(<nom>)
convert_code [syntaxe incorrecte] La syntaxe doit être : .convert_code(<code>)
set_object [syntaxe incorrecte] La syntaxe doit être :
.set_object(<nom-var-locale>[,[<portée>.]
<portée-objet>[,{new|update}]])
set_value [syntaxe incorrecte] La syntaxe doit être : .set_value(<nom-var-
locale>,<template-simple>[,{new|update}])

Message d'erreur Description et correction

execute_vbscript [syntaxe La syntaxe doit être :
incorrecte] .execute_vbscript(<fichier-script>[,<script-
input_params>])
Erreurs de conversion
Les erreurs de conversion sont des erreurs d'évaluation sur une variable
lorsque vous évaluez un template.
Vous pouvez rencontrer les erreurs de conversion suivantes :
Message d'erreur de conversion Description et correction

collection non résolue : <collection> Collection inconnue
membre non résolu : <membre> Membre inconnu
aucune portée externe Utilisation incorrecte du mot clé
objet null Se produit lors d'une tentative d'accès à
un membre d'un objet null
variable objet attendue : <object> Se produit lorsqu'une chaîne est utilisée
à la place d'un objet
Erreur d'exécution VBScript Erreur de script VB
Blocage détecté Blocage dû à une boucle infinie
408 PowerAMC
Conseils et techniques de génération
Cette section fournit des informations supplémentaires relatives au

mécanisme du langage de génération par template.
Partage de templates
Dans le mécanisme du langage de génération par template, vous pouvez

partager des conditions, des templates et des sous-templates afin de faciliter
la maintenance du langage et le rendre plus lisible.
Partage de conditions
Un template peut contenir une expression de condition. Vous avez également

la possibilité de créer des templates pour partager des expressions de
condition longues et fastidieuses :
Nom de template Valeur de template

%ConditionVariable% .bool (condition)
Au lieu de répéter la condition dans d'autres templates, vous utilisez

simplement %ConditionVariable% dans la macro conditionnelle :
.if (%ConditionVariable%)
Exemple Le template %isInner% contient une condition qui renvoie true si le

classificateur est interne à un autre classificateur.
.bool (%ContainerClassifier%!=null)
Ce template est utilisé dans le template %QualifiedCode% utilisé pour définir

le code qualifié du classificateur :
.if (%isInner%)
%ContainerClassifier.QualifiedCode%::%Code%
.else
%Code%
.endif

Utilisation des templates récursifs
Un template récursif est template qui est défini par rapport à lui-même.
Exemple Considérons trois X, Y et Z. X est interne à Y, et Y est interne à Z.
La variable %topContainerCode% est définie pour extraire la valeur du
conteneur parent d'une classe.
La valeur du template est la suivante :
.if (%isInner%)
%ContainerClassifier.topContainerCode%
.else
%Code%
.endif
Si la classe est interne pour une autre classe, %topContainerCode% est

appliqué à la classe conteneur de la classe courante
(%ContainerClassifier.topContainerCode%).
Si la classe n'est pas une classe interne, le code de la classe est généré.
Utilisation des variables d'environnement
Dans le langage de génération par template, vous pouvez accéder aux

variables situées dans la boîte de dialogue Options générales (Sélectionnez
Outils→Options générales). Si la variable n'a pas été définie, une chaîne null
est renvoyée.
Utilisation de nouvelles lignes dans la chaîne d'en-tête et de fin
Les chaînes d'en-tête et de fin sont utiles car elles ne sont générées que
lorsque nécessaire, cela est particulièrement utile lorsque vous utilisez de
nouvelles lignes '\n'. Elles sont ajoutées respectivement au début et à la fin du
code généré, la chaîne d'en-tête et la chaîne de fin n'apparaissant pas dans le
code généré.
410 PowerAMC
Exemple Vous souhaitez générer le nom d'une classe et ses attributs sous le format
suivant (une ligne vide entre les attributs et la classe) :
Attribute 1 attr1
Attribute 2 attr2
Class
Vous pouvez insérer le séparateur "\n" après l'instruction .foreach pour vous
assurer que chaque attribut s'affiche dans une ligne séparée. Vous pouvez
également ajouter "\n\n " après l'instruction .endfor pour insérer une ligne
vide après la liste d'attributs et avant le mot "Class".
.foreach (Attribute) ("\n")
Attribute %Code%
.endfor ("\n\n")
Class
Exemple Considérons une classe nommée Nurse, ayant pour code de classe Nurse, et
supplémentaire dotée de deux attributs :
Attribut Type de données Valeur initiale

NurseName String __
NurseGender Char 'F'
Les templates suivants sont fournis à titre d'exemple, avec le texte généré
pour chacune d'entre eux, ainsi qu'une description de chaque résultat :
Template 1 class "%Code%" {
// Attributes
.foreach_item(Attributes)
%DataType% %Code%
.if (%InitialValue%)
= %InitialValue%
.endif
.next
// Operations
.foreach_item(Operations)
%ReturnType% %Code%(...)
.next
}
Texte généré 1 class "Nurse" {

// Attributes String nurseName char nurseGender = 'F' // Operations}
Description 1 Au-dessous du code de classe, le code est généré sur une ligne. Il s'agit d'un
exemple d'une macro de bloc (.if, .endif macro).

Template 2 class "%Code%" {

(nouvelle ligne) // Attributes
%DataType% %Code%
= %InitialValue%
.endif
.next(\n)
// Operations
.foreach_item(Operations)
.next(\n)
}

// Attributes String nurseName
char nurseGender = 'F' // Operations}
Description 2 String nurseName et char nurseGender se trouvent sur deux lignes distinctes
Dans Template 1, String nurseName et char nurseGender se trouvaient sur la
même ligne, alors que dans Template 2, l'ajout de \n à la fin de .next(\n) place
String nurseName et char nurseGender sur deux lignes distinctes.
En outre, // Operations est affichée dans le résultat et ce, même en l'absence
d'opération (voir Description 3).
Template 3 (blanc) class "%Code%" {
.foreach_item(Attributes, // Attributes\n,\n)
%DataType% %Code%
= %InitialValue%
.endif
.next(\n)
.foreach_item(Operations, // Operations\n,\n)
.next(\n)
}
Texte généré 3 class "Nurse" {// Attributes

String nurseName
char nurseGender = 'F'
}
Description 3 L'espace entre .foreach_item(Attributes, et // Attributes\n,\n)

n'est pas généré, comme indiqué dans le résultat suivant : class "Nurse" {//
Attributes au lieu de …. { // Attributes
// Operations n'est pas affiché dans le résultat car il est placé dans la macro
.foreach_item. Il est placé dans l'en-tête de la macro à cet effet.
412 PowerAMC
Template 4 (blanc) class "%Code%" {\n

.foreach_item(Attributes," // Attributes\n",\n)
%DataType% %Code%[ = %InitialValue%]
.next(\n)
.foreach_item(Operations," // Operations\n",\n)
.next(\n)
}

// Attributes
String nurseName
char nurseGender = 'F'
}
Description 4 Le caractères guillemet ("") dans " // Attributes\n" permet d'insérer un espace
comme indiqué dans le résultat : // Attributes
Nouvelle ligne précédant la macro

La nouvelle ligne qui précède immédiatement une macro est ignorée, de
même que celle qui la suit, comme dans l'exemple suivant :
Jack
.set_value(v, John)
Paul
yields: JackPaul
instead of:
Jack
Paul

Utilisation du passage de paramètres
Vous pouvez passer des paramètres dans, hors ou dans/hors un template via
des variables locales en tirant parti des portées de traduction. Vous pouvez
accéder à des paramètres avec la variable %@<number>%.
Exemple Templates de classe :
Template 1 <show> template
<<<
Class "%Code%" attributes :
// Public
%publicAttributes%
// Protected
%protectedAttributes%
// Private
%privateAttributes%
>>>
Template 2 <publicAttributes> template

<<<
.if (%Visibility% == +)
%DataType %Code%
.endif
.next(\n)
>>>
Template 3 <protectedAttributes> template

<<<
.if (%Visibility% == #)
%DataType %Code%
.endif
.next(\n)
>>>
Template 4 <privateAttributes> template

<<<
.if (%Visibility% == -)
%DataType %Code%
.endif
.next(\n)
>>>
414 PowerAMC
Pour améliorer la lisibilité et rendre le code encore plus réutilisable, ces

quatre templates peuvent être écrits dans deux templates à l'aide de
paramètres:
Premier template <show> template
<<<
Class "%Code%" attributes :
// Public
%attributes(+)%
// Protected
%attributes(#)%
// Private
%attributes(-)%
>>>
Second template <attributs> template

<<<
.if (%Visibility% == %@1%)
%DataType %Code%
.endif
.next(\n)
>>>
Description Le premier paramètre dans cet exemple %attributes(+, ou #, ou -)% peut être
accessible via la variable %@1%, le second, s'il existe, est accessible via la
variable %@2% variable, etc.

416 PowerAMC
C H A P I T R E 8
Métamodèle public PowerAMC
Sujet
Ce chapitre décrit le contenu et l'utilisation du métamodèle public
PowerAMC.
Sommaire
Section Page
Qu'est-ce que le métamodèle public PowerAMC ? 418

Concepts relatifs au métamodèle 419
Notions de base relatives à la structure du métamodèle 422
Utilisation du métamodèle avec VBS 426
Utilisation du métamodèle à l'aide du langage de génération par
template (GTL) 428
Utilisation du métamodèle pour comprendre le format de fichier
XML de PowerAMC 432

Qu'est-ce que le métamodèle public PowerAMC ?
Qu'est-ce que le métamodèle public

PowerAMC ?
Définition du
métamodèle L'emploi d'un métamodèle est une extension logique du processus
d'abstraction utilisé pour créer des objets de modèle. Un modèle objet est une
abstraction des données, et peut être décrit à l'aide de métadonnées. Un
métamodèle est une abstraction des métadonnées.
Les métamodèles décrivent de façon formelle les éléments du modèle, ainsi
que la syntaxe et la sémantique de la notation qui permet leur manipulation.
Leur utilisation permet de rendre plus puissant, plus souple et plus versatile
un logiciel car ils isolent l'application des changements intervenant dans le
modèle d'application. Par exemple, vous pouvez utiliser le métamodèle pour
représenter le modèle objet d'un modèle objet, le modèle objet d'un modèle
dynamique, ou la grammaire d'une grammaire.
Métamodèle
PowerAMC Le métamodèle public de PowerAMC est une abstraction des métadonnées de
PowerAMC représentées dans un Modèle Orienté Objet (MOO).
Le métamodèle public de PowerAMC est divisé en packages contenant des
classes liées entre elles via des associations et des généralisations. Chaque
classe est dotée d'un nom (nom public) et peut être décrite par des attributs ;
elle peut assumer plusieurs rôles dans les associations avec d'autres classes.
Pourquoi publier un Le métamodèle public de PowerAMC a pour but de :
métamodèle ?
♦ Faire en sorte que tout changement dans le codage et la conception soit
représenté pleinement dans l'architecture du métamodèle et éviter des
incohérences de codage
♦ Permettre aux utilisateurs d'avoir à la fois une vue d'ensemble et une
connaissance approfondie des métadonnées PowerAMC
♦ Compléter le fichier d'aide Visual Basic afin de permettre aux
utilisateurs de créer leurs propres scripts VB
♦ Aider les utilisateurs à utiliser le langage de génération par template
(GTL)
♦ Permettre une meilleure compréhension et simplifier la modification des
fichiers PowerAMC enregistrés au format XML
418 PowerAMC
Chapitre 8 Métamodèle public PowerAMC
Concepts relatifs au métamodèle
Le métamodèle public de PowerAMC prend en charge pleinement la

méthode et le formalisme d'UML. Les sections suivantes récapitulent
brièvement les termes et concepts employés dans le cadre du métamodèle.
Noms publics
Chaque objet du métamodèle PowerAMC a un nom et un code qui

correspondent au nom public de l'objet. Le nom public d'un objet est
identificateur unique de cet objet dans la bibliothèque du modèle. Une
bibliothèque de modèle correspond à un package visible dans le diagramme
Modules du métamodèle, par exemple PdCommon. Le nom public ne
correspond pas toujours au nom de l'objet dans l'interface de PowerAMC.
Les noms publics sont également utilisés dans les fichiers XML ainsi que
dans le langage de génération par template (GTL) de PowerAMC.
Pour plus d'informations sur les fichiers XML, reportez-vous au
chapitre Spécification du format de fichier PowerAMC.
Pour plus d'informations sur la génération de texte, reportez-vous au
Classes
Les classes sont utilisées pour représenter les métadonnées de la façon

suivante :
♦ Classes abstraites : elles sont utilisées pour partager des attributs et
comportements. Elles ne sont pas visibles dans l'interface PowerAMC.
Les classes pouvant être instanciées héritent des classes abstraites via des
liens de généralisation. Par exemple, NamedObject est une classe
abstraite, elle stocke les attributs standard tels que name, code, comment,
annotation et description hérités par la plupart des objets de conception
PowerAMC
♦ Classes instanciables/concrètes : elles correspondent aux objets
affichés dans l'interface, elles sont dotées de leurs propres attributs tels
que type ou persistance, et héritent des attributs et comportements des
classes abstraites via les liens de généralisation

Concepts relatifs au métamodèle
Le métamodèle PowerAMC met en exergue les liens d'héritage entre

métadonnées.
Attributs de classe Les attributs sont des propriétés de classe qui peuvent être dérivés ou non.
Les classes liées à d'autres classes via des liens de généralisation contiennent
le plus souvent des attributs dérivés qui sont calculés à partir des attributs ou
des collections de la classe parent. Les attributs non dérivés sont les attributs
propres de la classe. Ces attributs sont stockés dans le modèle et enregistrés
dans le fichier du modèle.
Ni les attributs dérivés, ni les attributs par le biais des associations navigables
ne sont stockés dans le fichier du modèle.
Associations et collections
Les associations sont utilisées pour exprimer les connexions sémantiques
entre des classes appelées collections. Dans la feuille de propriétés d'une
association, les rôles transportent l'information relative à l'objet d'extrémité
de l'association. Dans le métamodèle PowerAMC, ce rôle a le même nom
qu'une collection pour l'objet courant. Les objets PowerAMC sont liés à
d'autres objets via des collections.
En règle générale, les associations n'ont qu'un seul rôle, ce rôle se trouve à
l'opposé de la classe qui représente une collection. Dans l'exemple suivant,
Identifier a une collection appelée Attributes :
Lorsque les associations ont deux rôles, les deux collections ne peuvent pas
être enregistrées dans le fichier XML, seule la collection ayant un rôle
navigable sera enregistrée.
Pour plus d'informations sur les rôles navigables, reportez-vous à la
section XML et le métamodèle PowerAMC dans le chapitre Spécification du
format de fichier PowerAMC.
Composition Parmi les associations, les compositions expriment une forte propriété des
classes enfant par les classes parent ; les enfant vivent et meurent avec les
parents. Si le parent est copié, l'enfant l'est également.
420 PowerAMC
Par exemple, dans le package PdCommon, diagramme Option Lists, la classe

NamingConvention est associée avec la classe BaseModelOptions via trois
associations de composition : NameNamingConventions,
CodeNamingConventions et NamingConventionsTemplate. Ces associations
de composition expriment le fait que la classe NamingConvention n'existerait
pas sans la classe BaseModelOptions.
Généralisations
Le métamodèle PowerAMC utilise des généralisations pour montrer les liens
d'héritage entre une classe plus générale (le plus souvent une classe
abstraite) et une classe plus spécifique (le plus souvent une classe
instanciable). La classe la plus spécifique hérite des attributs de la classe plus
générique, ces attributs étant appelés attributs dérivés.
En partageant les attributs et comportements, les héritages améliorent la
lisibilité du métamodèle.
Commentaires et notes sur les objets

La plupart des classes, des diagrammes et des packages sont dotés d'un
commentaire qui explique leur rôle dans le métamodèle.
Certains détails de mise en oeuvre interne sont également disponibles dans la
page Notes→Annotation de la feuille de propriétés des classes.

Notions de base relatives à la structure du métamodèle
Notions de base relatives à la structure du

métamodèle
Le métamodèle PowerAMC est publié dans un Modèle Orienté Objet. Il
utilise le formalisme du diagramme de classes UML pour représenter les
métadonnées PowerAMC.
Organisation générale
Lorsque vous ouvrez le métamodèle PowerAMC, le diagramme Modules
s'affiche, et vous pouvez voir une série de packages liés à PdCommon. Ces
packages représentent les différentes bibliothèques de PowerAMC, chaque
bibliothèque (en dehors de PdCommon) équivaut à un type de modèle :
Nom du package Modèle correspondant

PdCDM Modèle Conceptuel de Données (MCD)
PdPDM Modèle Physique de Données (MPD)
PdOOM Modèle Orienté Objet( MOO)
PdBPM Modèle de Processus Métiers (MPM)
PdXSM Modèle XML
PdMTM Modèle de Traitements Merise (MTM)
PdFRM Modèle libre (MLB)
PdRMG Référentiel
PdWSP Espace de travail
Le package PdCommon ne correspond pas à un modèle particulier, il

rassemble tous les objets partagés entre modèles. Les règles de gestion, par
exemple, sont définies dans ce package.
Il définit également les classes abstraites du modèle, par exemple BaseObject
est défini dans le diagramme Common Abstract Objects dans le package
Objects de PdCommon.
Pour plus d'informations sur les classes abstraites, reportez-vous à la
section Classes.
Les packages de bibliothèques sont liées à PdCommon par des liens de
généralisation indiquant que chaque modèle hérite des objets communs de la
bibliothèque PdCommon.
422 PowerAMC
Contenu de PdCommon
La bibliothèque PdCommon est organisée en sous-packages contenant
différents diagrammes qui illustrent un certain aspect de la bibliothèque.
Sous-package Description
Features Toutes les fonctionnalités mises en oeuvre par les classes
dans PdCommon. Par exemple, Report appartient à
PdCommon car cette fonctionnalité est partagée par tous les
modèles
Objects Les objets de conception partagés par plusieurs modèles
Symbols Représentation graphique d'objets de conception partagés
Contenu des autres packages de bibliothèque

Tous les autres packages de bibliothèque affichent des diagrammes
correspondant aux différents aspects du modèle.
Diagramme Description
Features Toutes les fonctionnalités mises en oeuvre par des classes dans la
bibliothèque courante. Par exemple, AbstractDataType est une
fonctionnalité de PdPDM
Objects Objets de conception de la bibliothèque courante
Symbols Représentation graphique des objets de conception
Dans les packages PdOOM et PdPDM, les différents types de diagramme

pris en charge dans PowerAMC s'affichent sous la forme de diagrammes
différents dans le package.
Navigation dans le métamodèle

Vous pouvez utiliser l'interface graphique du MOO pour naviguer dans la
structure du métamodèle.
Code de couleurs Les classes en vert sont des classes dont le comportement est expliqué dans
le diagramme courant.
Les classes en mauve sont visibles pour vous aider à comprendre le contexte,
mais ne sont pas expliquées dans le diagramme courant.

Notions de base relatives à la structure du métamodèle
Dans l'exemple courant issu de Common Instantiable Objects dans le package

Objects de PdCommon, BusinessRule (couleur verte) est développé tandis
que NamedObject et BaseModel sont utilisés pour exprimer les liens
d'héritage et de composition à l'aide de classes abstraites.
Navigation à l'aide de l'interface

Vous pouvez utiliser l'Explorateur d'objets pour développer ou réduire les
catégories afin de comprendre la structure globale du métamodèle à partir
d'une arborescence. Vous pouvez également afficher des diagrammes et
observer la représentation graphique des métadonnées.
Les classes en mauve sont le plus souvent des raccourcis d'une classe existant
dans un autre package. Le raccourci facilite la lecture du diagramme et la
compréhension des liens de généralisation entre les classes. Si vous souhaitez
obtenir une explication relative à une classe mauve dans un diagramme,
pointez sur cette classe, cliquez le bouton droit de la souris et sélectionnez
Ouvrir un diagramme associé pour afficher le diagramme dans lequel la
classe est définie.
Rôles d'association Le diagramme affiche également la plupart des associations avec leurs rôles
ce qui permet d'identifier des collections d'objets.
Pour plus d'informations sur les rôles d'association, reportez-vous à la
section Associations et collections.
424 PowerAMC
Navigation à l'aide de feuilles de propriétés d'objets

Vous pouvez utiliser l'onglet Dépendances dans la feuille de propriétés des
classes du métamodèle pour consulter les pages suivantes :
♦ Associations : vous pouvez personnaliser le filtre afin d'afficher le rôle
des associations, vous obtenez ainsi la liste des collections de l'objet
courant
♦ Généralise : affiche une liste des liens de généralisation dans lesquelles
l'objet courant est le parent. Cette liste permet d'afficher les enfants de la
classe courante. Les classes enfant héritent des attributs de la classe
parent et n'affichent pas d'attribut dérivé
♦ Spécialise : affiche le parent de l'objet courant. La classe courante hérite
des attributs de ce parent
♦ Raccourcis : affiche la liste des raccourcis créés pour l'objet courant
Vous pouvez utiliser l'onglet Associations dans les feuilles de propriétés des
classes de métamodèle pour obtenir la liste des associations migrées pour la
classe courante.

Utilisation du métamodèle avec VBS
Utilisation du métamodèle avec VBS

Vous pouvez accéder aux objets internes de PowerAMC et les manipuler à
l'aide de Visual Basic Scripting. Les scripts permettent d'accéder aux
propriétés, collections et méthodes d'objet et de les modifier en utilisant le
nom public de ces objets.
Le métamodèle PowerAMC fournit des informations utiles relatives à ces
objets :
Information Description Exemple

Nom public Le nom et le code des AssociationLinkSymbol
objets du métamodèle ClassMapping
sont les noms publics CubeDimensionAssociation
des objets internes de
PowerAMC
Collections d'objets Vous pouvez identifier Dans PdBPM, il existe une
les collections d'une association entre les classes
classe en observant les MessageFormat et
associations liées à cette MessageFlow. Le nom public
classe dans le de cette association est Format.
diagramme. Le rôle de Le rôle de cette association est
chaque association est Usedby, qui correspond à la
le nom de la collection collection de messages de la
classe MessageFormat
Attributs d'objet Vous pouvez afficher Dans PdCommon, dans le
les attributs d'une classe diagramme Common
avec les attributs que Instantiable Objects, vous
cette classe hérite d'une pouvez afficher les objets
autre classe via des BusinessRule,
liens de généralisation ExtendedDependency et
FileObject avec leurs propres
attributs, ainsi que les classes
abstraites dont ils héritent les
attributs via des liens de
généralisation
Opérations d'objet Les opérations dans des BaseModel contient l'opération
classes d'un Compare qui peut être utilisée
métamodèle dans VBS
correspondent aux
méthodes objet utilisées
dans VBS
426 PowerAMC
Information Description Exemple

<<notScriptable>> Objets qui ne prennent RepositoryGroup
stereotype pas en charge les scripts
VB qui ont le
stéréotype
<<notScriptable>>
Pour plus d'informations sur les noms publics, reportez-vous à la

section Noms publics.
Pour plus d'informations sur les généralisations, reportez-vous à la
section Généralisations.
Fichier d'aide sur Si vous avez besoin d'un supplément d'informations relatives à VBS, vous
VBS pouvez utiliser le fichier d'aide accessible via la boîte de dialogue
Edition/Exécution d'un script. Ce fichier d'aide HTML est une autre
représentation du métamodèle, conçue pour aider les utilisateurs VBS à
identifier les collections et attributs d'objets.
Pour plus d'informations sur VB Scripting, reportez-vous à la section
Accès aux objets à l'aide de VBScript dans le manuel Guide des

Utilisation du métamodèle à l'aide du langage de génération par template (GTL)
Utilisation du métamodèle à l'aide du langage de

génération par template (GTL)
Le GTL utilise des templates pour générer des fichiers. Un template est un
élément de code défini sur une métaclasse PowerAMC définie qui hérite de
cette classe. Il peut être utilisé dans différents contextes pour la génération de
texte et, éventuellement, de code.
Ces templates peuvent être considérés comme des extensions du métamodèle
car ils définissent les classes de métamodèle, ils constituent des types
d'attributs de métamodèle particuliers. L'utilisateur peut définir autant de
templates qu'il le souhaite pour une métaclasse donnée en utilisant la syntaxe
suivante :
<metamodel-classname> / <template-name>
Héritage Les templates sont hérités par tous les descendants de la métaclasse pour
laquelle ils sont définis. Ce mécanisme est utile pour partager le code de
template entre les métaclasses ayant un ancêtre commun. Par exemple, si
vous définissez un template pour une classe abstraite telle que BaseObjects,
toutes les classes liées via des liens de généralisation à cette classe héritent de
ce template.
Collections Le GTL utilise des macros telles que foreach_item, pour permettre l'itération
des collections d'objets. Ce template spécifié dans le bloc est converti sur
tous les objets contenus dans la collection spécifiée. Le métamodèle fournit
des informations très utiles concernant les collections de métaclasses sur
lesquelles vous définissez un template contenant une macro d'itération.
428 PowerAMC
Attributs calculés
Les attributs calculés suivants sont des extensions de métamodèle spécifiques
au GTL :
Nom de
métaclasse Nom d'attribut Type Description
PdCommon. isSelected boolean True si l'objet
BaseObject correspondant fait partie
de la sélection dans la
boîte de dialogue de
génération, false dans le
cas contraire
isShortcut boolean True si l'objet était
accessible via un
raccourci, false dans le cas
contraire
PdCommon. GenOptions struct Permet d'accéder aux
BaseModel options de génération
définies par l'utilisateur
PdOOM. MinCardinality string
Class
MaxCardinality string
SimpleTypeAttribute
(XML-specific)
@<tag> (Java-specific) string Attribut étendu
Javadoc@<tag> avec
formatage supplémentaire
PdOOM. @<tag> (Java-specific) string Attribut étendu
Interface Javadoc@<tag> avec
PdOOM. MinMultiplicity string
Attribute
MaxMultiplicity string
Overridden boolean
DataTypeModifier string
Prefix
Suffix

Utilisation du métamodèle à l'aide du langage de génération par template (GTL)
Nom de
métaclasse Nom d'attribut Type Description
Javadoc@<tag> avec
PdOOM. DeclaringInterface object
Operation
GetSetAttribute object
Overridden boolean
ReturnTypeModifier string
Prefix
ReturnTypeModifier string
Suffix
Javadoc@<tag> formatage
supplémentaire
(particulièrement pour
@throws, @exception,
@params)
PdOOM. DataTypeModifier string
Parameter Prefix
Suffix
PdOOM. RoleAMinMultiplicity string
Association
RoleAMaxMultiplicity string
RoleBMinMultiplicity string
RoleBMaxMultiplicity string
PdOOM.* ActualComment string Commentaire supprimé
(avec /**, /*, */ et //
retirés)
430 PowerAMC
Collections calculées
Les collections calculées sont des extensions de métamodèle spécifiques au
GTL :
Nom de métaclasse Nom de collection Description

PdCommon.BaseModel Generated Collection de tous les
<metaclass-name>List objets du type
<metaclass-name> qui
font partie de la
sélection dans la boîte
de dialogue de
génération
PdCommon. SourceLinks
BaseClassifierMapping
PdCommon. SourceLinks
BaseAssociationMapping

Utilisation du métamodèle pour comprendre le format de fichier XML de PowerAMC
Utilisation du métamodèle pour comprendre le

format de fichier XML de PowerAMC
Les modèles PowerAMC sont composés d'objets dont les propriétés et
interactions sont expliquées dans le métamodèle public. Vous pouvez utiliser
le métamodèle public pour mieux comprendre :
♦ Les noms d'objet dans les fichiers XML, ces noms correspondent aux
noms publics disponibles dans le métamodèle
♦ Les collections d'objets qui s'affichent sous la forme de rôles
d'association dans le métamodèle
Vous pouvez utiliser le métamodèle pour visualiser les éléments qui ne
s'affichent pas dans les fichiers XML :
♦ Les attributs dérivés peuvent être déduits du métamodèle lorsqu'il existe
un lien de généralisation entre une classe parent et une classe enfant. Ces
attributs ne s'affichent pas dans le code XML
♦ Les objets ayant le stéréotype <<internal>> correspondent aux
fonctionnalités temporaires telles que CheckModelControler, qui ne
s'affiche pas dans le fichier XML
Pour plus d'informations sur l'utilisation du métamodèle public afin de

comprendre le format de fichier XML, reportez-vous à la section XML et le
métamodèle PowerAMC dans le chapitre Spécification du format de fichier
PowerAMC.
432 PowerAMC
C H A P I T R E 9
Spécification du format de fichier

PowerAMC
Sujet Ce chapitre décrit le format de fichier utilisé pour enregistrer les modèles
PowerAMC.
Sommaire
Section
Format de fichier XML 434

Modification d'un fichier XML 442

Format de fichier XML

Tous les fichiers de modèle dans PowerAMC sont dotés d'un suffixe qui
correspond au module dans lequel ils sont enregistrées. Par exemple, un
modèle enregistré dans le module orienté objet a comme suffixe MOO. Outre
le suffixe de nom de fichier, vous pouvez décider du format de sauvegarde de
vos modèles :
Format de fichier Permet de…

BIN (Binary) Disposer de fichiers moins volumineux et donc moins
gourmands en espace-disque, permettant également une
ouverture et un enregistrement plus rapides dans
PowerAMC
XML (Extensible Visualiser et modifier la structure et le contenu des objets
Markup Language) de modèle dans un éditeur de texte ou un éditeur XML
XML signifie Extensible Markup Language. Il s'agit d'un langage permettant

de simplifier l'utilisation de documents au format SGML, ainsi que la
transmission et le partage de ces documents sur le Web.
Editeurs de DTD et En outre, les fichiers XML de PowerAMC prennent en charge un DTD
XML (Document Type Definition) pour chaque type de modèle. Le DTD permet
d'utiliser un éditeur XML pour parcourir la structure hiérarchique des objets
dans le modèle. Les différents DTD sont disponibles dans le dossier \DTD du
répertoire d'installation de PowerAMC.
Vous pouvez trouver plus d'informations concernant XML sur le site
suivant :
http://www.xml.com
Structure et contenu des fichiers XML

Les sections suivantes décrivent la syntaxe et la structure XML dans le
fichiers PowerAMC.
Balises XML
Les fichiers XML contiennent des objets, attributs et collections, le plus
souvent déclarés à l'aide de balises begin et end ; les objets référencés n'ont
qu'une seule balise pour le début et la fin, comme indiqué dans le tableau ci-
après.
434 PowerAMC
Chapitre 9 Spécification du format de fichier PowerAMC
La différence entre une balise de début (begin) et une balise de fin (end)
réside dans le fait que la balise de fin comporte une barre oblique (/) après le
caractère <.
Les balises suivantes sont utilisées dans les fichiers XML de PowerAMC :
Balise de
début Balise de fin Objet Description
<c:collection> </c:collection> Collection Collection d'objets liés à un
autre objet. Vous pouvez
utiliser le métamodèle
PowerAMC pour visualiser
les collections d'un objet.
Par exemple, <c:Children>
<o:object> </o:object> Object Un objet que vous pouvez
créer dans PowerAMC. Par
exemple, <o:Model>
<o:object/> — Referenced Lorsqu'un objet est déjà
object défini dans le fichier, une
référence est créée la
prochaine fois que ce fichier
est lu dans le fichier XML.
Par exemple, <o:Class Ref=
"xyz"/>
<a:attribute> </a:attribute> Attribute Un objet est constitué d'un
nombre d'attributs dont
chacun peut être modifié
indépendamment. Par
exemple, <a:ObjectID>
XML et le métamodèle PowerAMC

Les modèles PowerAMC sont composés d'objets dont les propriétés et
interactions sont expliquées dans le métamodèle public. Le métamodèle
utilise le formalisme du MOO pour documenter les métadonnées PowerAMC
(sous la forme de classes) et leurs liens (sous la forme d'associations et de
généralisations).
Vous pouvez utiliser le métamodèle public PowerAMC pour mieux
comprendre le format des fichiers XML de PowerAMC.
En premier lieu, les noms d'objet, qui sont déclarés dans les balises <o:nom
de l'objet> correspondent aux noms publics dans le métamodèle. Vous
pouvez chercher un objet dans le métamodèle à l'aide du nom d'objet trouvé
dans le fichier XML.

Une fois vous que vous avez trouvé et localisé l'objet dans le métamodèle,
vous pouvez lire les informations suivantes :
♦ Chaque objet PowerAMC peut comporter plusieurs collections
correspondant aux autres objets avec lesquels il doit interagir. Ces
collections sont représentées par les associations existant entre objets.
Les rôles des associations (agrégations et compositions incluses)
correspondent aux collections d'un objet. Par exemple, chaque modèle
PowerAMC contient une collection de domaines appelée Domains.
En règle générale, les associations n'ont qu'un seul rôle, le rôle s'affiche à
l'opposé de la classe pour lequel il représente une collection. Toutefois,
le métamodèle contient également des associations ayant deux rôles,
auquel cas, les deux collections ne peuvent pas être enregistrées dans le
fichier XML. Vous pouvez identifier la collection qui sera enregistrée à
partir de la feuille de propriétés de l'association : il s'agit du rôle pour
lequel la case Navigable est cochée.
Dans l'exemple suivant, les association ont deux rôles qui signifient que
Classifier a une collection Actors, et que Actor2 a une collection
ImplementationClasses :
436 PowerAMC
Si vous affichez la feuille de propriétés de l'association, vous pouvez

voir que la case Navigable est cochée pour le rôle ImplementationClass,
ce qui signifie que seule la collection ImplementationClass sera
enregistrée dans le fichier.
♦ Les attributs ayant le type de données IOBJECT sont des attributs dans
le métamodèle alors qu'ils apparaissent sous forme de collections
contenant un seul objet dans le fichier XML. Ce n'est pas le cas pour
Parent et Folder qui ne contiennent pas de collection.
Le métamodèle public PowerAMC est disponible dans le répertoire
\Exemples.
Vous pouvez également utiliser le fichier d'aide doté du suffixe .chm fourni
avec PowerAMC. Ce fichier est destiné à aider les utilisateurs qui souhaitent
créer des scripts Visual Basic car il fournit des informations utiles sur les
propriétés, collections et méthodes d'objets.

Pour plus d'informations sur la création de scripts Visual Basic pour les
objets PowerAMC, reportez-vous au chapitre Manipulation des objets via
VBScript du manuel Guide des fonctionnalités générales.
Notions de base relatives aux format XML

Le format des fichiers XML reflète la façon dont les informations du modèle
sont enregistrées : PowerAMC parcourt chaque objet pour enregistrer sa
définition.
Chevauchement La définition d'un objet implique la définition de ses attributs et de ses
des collections collections. Ceci justifie le fait que PowerAMC vérifie chaque objet et
analyse les collections de cet objet pour définir chaque nouvel objet et
collection dans ces collections, et ainsi de suite, jusqu'à ce que le processus
trouve les objets terminaux qui ne nécessitent pas d'être analysés plus avant.
Compte tenu du chevauchement des collections, le format des fichiers de
modèle PowerAMC peut être comparé à une arborescence : il part d'un noeud
racine (l'objet racine contenant toutes les collections de modèle) et cascade
au travers des collections. Cette analogie est utilisée par la plupart des
éditeurs XML pour afficher la structure des fichiers XML.
Définition d'objet Lorsqu'un objet est mentionné dans une collection, PowerAMC définit cet
ou référence objet à l'aide de la syntaxe <o:object Id="XYZ"> ou fait référence à
cet objet à l'aide de la syntaxe <o:object Ref="XYZ"/>. Les
définitions d'objet ne sont utilisées que dans les collections de composition
(l'objet parent possède l'enfant dans l'association).
Dans ces deux cas, XYZ est un identificateur unique affecté automatiquement
à un objet lorsqu'il est rencontré pour la première fois.
Etude de cas
Le modèle suivant contient deux classes et une association. Nous allons
explorer le fichier XML correspondant à ce modèle.
438 PowerAMC
Le fichier commence par plusieurs lignes qui spécifient des détails relatifs à
XML et au modèle.
Le premier objet qui apparaît est la racine du modèle <o:RootObject
Id="01">. RootObject est un conteneur de modèle qui est défini par défaut
lorsque vous créez et enregistrez un modèle. RootObject contient une
collection appelée Children qui est composée de modèles.
Dans notre exemple, Children ne contient qu'un objet de modèle qui est
défini comme suit :
<o:Model Id="o2">
<a:ObjectID>3CEC45F3-A77D-11D5-BB88-
0008C7EA916D</a:ObjectID>
<a:Name>ObjectOrientedModel_1</a:Name>
<a:Code>OBJECTORIENTEDMODEL_1</a:Code>
<a:CreationDate>1000309357</a:CreationDate>
<a:Creator>arthur</a:Creator>
<a:ModificationDate>1000312265</a:ModificationDate>
<a:Modifier>arthur</a:Modifier>
<a:ModelOptionsText>
[ModelOptions]
…
Sous la définition de l'objet modèle, vous pouvez voir la série d'attributs
ModelOptions. Remarquez que ModelOptions n'est pas limité aux options
définies dans la boîte de dialogue Options du modèle d'un modèle, mais
rassemble toutes les propriétés enregistrées dans un modèle, notamment les
options relatives à la génération intermodèle.
Après ModelOptions, vous pouvez identifier la collection
<c:ObjectLanguage>. Il s'agit du langage objet lié au modèle. La seconde
collection du modèle est <c:ClassDiagrams>. Il s'agit de la collection des
diagrammes liés au modèle. Dans notre exemple, un seul diagramme est
défini dans le paragraphe suivant :
<o:ClassDiagram Id="o4">
<a:ObjectID>3CEC45F6-A77D-11D5-BB88-
0008C7EA916D</a:ObjectID>
<a:Name>ClassDiagram_1</a:Name>
<a:Code>CLASSDIAGRAM_1</a:Code>
<a:DisplayPreferences>
…
Tout comme dans le cas des options de modèle, la définition ClassDiagram
est suivie d'une série d'attributs de préférences d'affichage.

Dans la collection ClassDiagram se trouve une nouvelle collection appelée

<c:Symbols>. Cette collection rassemble tous les symboles contenus dans le
diagramme du modèle. Le premier objet à être défini dans la collection
Symbols est AssociationSymbol :
<o:AssociationSymbol Id="o5">
<a:CenterTextOffset>(1, 1)</a:CenterTextOffset>
<a:SourceTextOffset>(-1615, 244)</a:SourceTextOffset>
<a:DestinationTextOffset>(974, -2)</a:DestinationTextOffset>
<a:Rect>((-6637,-4350), (7988,1950))</a:Rect>
<a:ListOfPoints>((-6637,1950),(7988,-4350))</a:ListOfPoints>
<a:ArrowStyle>8</a:ArrowStyle>
<a:ShadowColor>13158600</a:ShadowColor>
<a:FontList>DISPNAME 0 Arial,8,N
AssociationSymbol contient les collections <c:SourceSymbol> et
<c:DestinationSymbol>. Dans ces deux collections, les symboles font l'objet
de références mais ne sont pas définis, car ClassSymbol n'appartient pas aux
collections SourceSymbol et DestinationSymbol.
<c:SourceSymbol>
<o:ClassSymbol Ref="o6"/>
</c:SourceSymbol>
<c:DestinationSymbol>
<o:ClassSymbol Ref="o7"/>
</c:DestinationSymbol>
La collection des symboles d'association est suivie par la collection
<c:Symbols>. Cette collection contient la définition des deux symboles de
classe.
<o:ClassSymbol Id="o6">
<a:Rect>((-18621,6601), (-11229,12675))</a:Rect>
<a:FillColor>16777215</a:FillColor>
<a:ShadowColor>12632256</a:ShadowColor>
<a:FontList>ClassStereotype 0 arial,8,N
La collection <c:Classes> suit la collection <c:Symbols>. Dans cette
collection, les deux classes sont définies avec leurs collections d'attributs.
<o:Class Id="o10">
<a:ObjectID>10929C96-8204-4CEE-911#-
E6F7190D823C</a:ObjectID>
<a:Name>Order</a:Name>
<a:Code>Order</a:Code>
<c:Attributes>
<o:Attribute Id="o14">
440 PowerAMC
L'attribut est un objet terminal : aucune ramification supplémentaire n'est

nécessaire pour en détailler la définition.
Chaque collection appartenant à un objet analysé est développée et analysée,
y compris les collections contenues dans d'autres collections.
Une fois tous les objets et toutes les collections parcourus, les balises
suivantes s'affichent :
</o:RootObject>
</Model>

Modification d'un fichier XML

Lorsque vous devez modifier un modèle à l'aide de son fichier XML, vous
devez y ajouter ou supprimer des objets qu'avec précautions. En raison de la
structure du fichier qui comporte des chevauchements, une seule erreur de
syntaxe mineure peut rendre le fichier inutilisable.
OID Si vous créez un objet dans un fichier XML en copiant un objet existant du
même type, assurez-vous de supprimer l'OID dupliqué. Il est préférable de
supprimer un OID que d'essayer d'en créer un nouveau car ce nouvel ID
risque de ne pas être unique dans le modèle. PowerAMC va automatiquement
affecter un OID au nouvel objet dès que vous ouvrirez le modèle.
Vous pouvez modifier un fichier XML à l'aide de :
♦ Un éditeur de texte standard
♦ Un éditeur XML
Vous pouvez visualiser un fichier XML à l'aide d'une visionneuse XML.
Modification d'un fichier XML à l'aide d'un éditeur standard

Si vous utilisez un éditeur standard, vous pouvez personnaliser la mise en
forme XML comme défini dans la section Modification d'un fichier XML.
Pour modifier le contenu d'un fichier XML :

1 Ouvrez le fichier dans un éditeur de texte.
442 PowerAMC
Le contenu du fichier XML s'affiche. Les objets sont triés en fonction

des collections auxquelles ils appartiennent.
2 Parcourez le fichier ou utilisez l'outil de recherche pour trouver un nom

d'objet dans le modèle.
3 Vous pouvez modifier directement les propriétés d'un objet en prenant
soin de ne pas modifier les balises de début et de fin de la définition de
l'objet (informations contenues entre les symboles < >).

4 Enregistrez et fermez le fichier.

Si vous ouvrez le fichier dans PowerAMC, l'objet s'affiche avec le
nouveau nom.
Modification d'un fichier XML à l'aide d'un éditeur XML

Vous pouvez modifier le fichier dans un éditeur XML. Dans cette section,
l'éditeur XML utilisé est Microsoft Bloc-notes XML.
Pour visualiser le contenu d'un fichier XML dans un éditeur XML :

1 Ouvrez le fichier dans un éditeur XML.
Le fichier XML s'affiche. Les objets sont affichés en fonction de la
hiérarchie qui reflète la façon dont ils sont organisés dans le modèle.
2 Développez ou réduisez les noeuds situés à gauche des objets.
3 Vous pouvez modifier une valeur en saisissant directement dans le

champ correspondant du volet Valeurs.
444 PowerAMC
Dans l'exemple suivant, les propriétés de modèle ont été modifiées en

ajoutant NEW au nom du modèle :
4 Une fois les modifications terminées, enregistrez puis fermez le fichier.
Visualisation d'un fichier XML à l'aide d'une visionneuse XML

Vous pouvez visualiser un fichier XML avec une visionneuse XML, par
exemple à l'aide d'un explorateur Internet compatible XML.
Vous ne pouvez pas modifier le fichier dans une visionneuse XML, mais
seulement consulter son contenu.
Pour visualiser le contenu d'un fichier XML à l'aide d'une

visionneuse XML :
1 Ouvrez le fichier dans l'explorateur.

Le contenu du fichier XML s'affiche. Les objets sont affichés en fonction

de la hiérarchie qui reflète la façon dont ils sont organisés dans le
modèle.
2 Développez ou réduisez les noeuds situés à gauche des objets pour

parcourir la hiérarchie des objets.
3 Refermez l'explorateur une fois que vous avez terminé.
446 PowerAMC
Index
B
BasicDataTypes 288
. BeforeCreate 76
.EXA fichier 349 BeforeCreateDatabase 131
.syntaxe de format Z 38 BeforeDrop 76
BeforeModify 76
Bind 95, 134, 154, 156
BindDefault 135
A bitmap join index 163
abort_command (macro) 403 bloc 372
Abstract Data Type 136 bloc (macro) 385
Abstract Data Type Attribute 138 bloc conditionnel 406
activer la sélection pour la génération block (macro) 392
de fichiers 203 BlockComment 63
activer le suivi 286, 315, 332 bool (macro) 400
Add 76 boucle (macro) 384, 385
AddColIndex 105
AddColnChck 95, 98
AdditionalDataTypes 288
AddJoin 163 C
AddQuote 65 CanCreate gestionnaire d'événement 248
AddTableCheck 83 caractère de fin 61
ADTComment 138 caractère de fin de bloc 61
AfterCreate 76, 170 caractères illégaux (langage objet) 289
AfterDrop 76 CaseSensitivityUsingQuote 64
AfterModify 76 catégorie 3
AKeyComment 116 ODBC 6
AllowedADT 86, 138, 139, 181 Script 6
AllowNullableColn 114 catégorie de script 5, 60
AltEnableAddColnChk 90 catégorie Generation
AlterFooter 72 (définition étendue de modèle) 359
AlterHeader 72 change_dir (macro) 403
AlterTableFooter 83 CharFunc 73
AlterTableHeader 83 CheckNull 90
AmcdDataType 177 CheckOnCommit 120
apostrophe variable par défaut 81 Choreography
association 420 catégorie (langage de processus) 327
attribut dérivé 419 cible de génération 355
attribut étendu 13, 201, 218 classe
créer 219 abstraite 419
importer depuis des versions antérieures 348 attribute 419
type 218, 219 concrète 419
métamodèle 419

CloseDatabase 131
Cluster 105
D
Data type (catégorie) 11, 177
codage 303
AllowedADT 181
collection 420
AmcdDataType 177
chevauchement 438
HostDataType 181
composition 420
LogPhysADTType 180
membre 372, 375
OdbcPhysDataType 179
navigable 420
PhysDataType 178
portée 377
PhysDttpSize 178
collection étendue 234
PhysLogADTType 180
créer 235
PhysOdbcDataType 180
nom inverse 234
Data types catégorie (langage objet) 288
propriétés 234
Database 130
stéréotype cible 234
Datahandling catégorie
type de cible 234
(langage de processus) 327
ColnDefaultName 143
DateFunc 73
ColnRuleName 143
DB Package 168
colonne variable par défaut 81
DB Package Cursor 172
Column 87
DB Package Exception 173
ColumnComment 96
DB Package Parameter 173
commande 361
DB Package Pragma 174
Commands
DB Package Procedure 170
catégorie (langage de processus) 317
DB Package Type 172
catégorie (langage objet) 291
DB Package Variable 171
catégorie (langage XML) 333
DBProcedureBody 171
commentaire & // (macro) 406
DclDelIntegrity 121
Commit 74
DclUpdIntegrity 120
composition 420
Default 159
ConceptualDataTypes 288
DefaultDataType 288
conseils et techniques 409
DefaultTriggerName 151
Constants catégorie (langage objet) 289
DefIndexColumn 106
ConstName 82, 95, 111, 115, 120
DefIndexType 106
convention de dénomination de code 202
DefineColnCheck 96
convert_code (macro) 394
DefineJoin 121
convert_name (macro) 393
DefineTableCheck 83
ConvertFunc 74
définition étendue de modèle 341, 342
CopyObject 245
catégorie 343, 354
correction automatique 222, 225
catégorie Generation 359
Count 375
cibles de génération 355
Create 75
commande 360
create_path (macro) 404
compléter la génération de langage 356
CreateBeforeKey 108
compléter la génération principale 366
CreateBody 170
créer 343
CreateDefault 135
créer une commande 361
CreateFunc 147
créer une tâche 362
critère 201, 213
éditeur 353
ajouter un attribut étendu 219
entrée 343
Criteria catégorie (langage objet) 301
exporter 351
CustomFunc 148
famille 354
CustomProc 147
448 PowerAMC
définition étendue de modèle (suite) EnableMultiCheck 58
génération de langage 354 EnableMultiFile 68
générer 366 EnableMultiTrigger 150
générer pour une cible séparée 366 EnableNotNullWithDflt 95
générique 343, 344 EnableNull 94
importer 346, 350 EnableOption 175
mode de suivi 354 EnableOwner 104, 134, 147, 151, 166
modifier 342 EnableOwnerPrefix 65
options 363 en-tête chaîne 410
paramètres de génération 342 entrée 3
profil 342 erreur de script (VB) 228
propriétés 354 error (macro) 405
rattachement automatique 354 étiquette 245
sous-famille 354 Event 153
spécifique 343, 346 EventDelimiter 153
tâche 360 Events catégorie (langage objet) 290
DefOptions 77 exclure une métaclasse 205
delete (macro) 391 execute_command (macro) 402
délimiteur 62 execute_vbscript (macro) 402
dépendance 425 exporter définition étendue de modèle 351
Domain 132 Extended attributes
Drop 76 (catégorie de langage objet) 302
DropColnChck 96 extension 21, 29
DropColnComp 97
DropFunc 148
DropTableCheck 84
F
famille 5, 286, 315, 332, 354
fichier généré 201, 229, 370
E créer 231
élément de template de trigger 4 File (catégorie)
Enable 75 AlterFooter 72
EnableAdtOnColn 137 AlterHeader 72
EnableAdtOnDomn 137 EnableMultiFile 68
EnableAlias 167 Footer 67
EnableAscDesc 103 Header 67
EnableBindRule 91, 133 ScriptExt 68
EnableChangeJoinOrder 118 StartCommand 69
EnableCheck 57, 134 TableExt 69
EnableCluster 103 TrgFooter 72
EnableComputedColn 91 TrgHeader 71
EnableConstname 58 TrgUsage1 70
EnableDefault 91, 133 TrgUsage2 70
EnableDtbsPrefix 65 TriggerExt 70
EnablefKeyName 118 Usage1 69
EnableFunc 146 Usage2 69
EnableFunction 104 fin chaîne 410
EnableIdentity 92 First 375
EnableIntegrity 57 FKAutoIndex 119
EnableManyDatabases 132 FKeyComment 122

Footer 67 gestionnaire d'événement 247
foreach_item (macro) 395 ajouter à un stéréotype 250
foreach_line (macro) 397 ajouter à une métaclasse 250
foreach_part (macro) 398 CanCreate 248
Format (catégorie de SGBD) 63 Initialize 249
format de date 66 propriétés 247
format de fichier 432, 433 script 247
balises XML 434 variable globale 247
bin 434 GetSource 245
collections superposée 438 GetTarget 245
définition d'objet 438 global script 222, 227
DTD 434 GrantOption 158, 159
éditeur XML 434 Group 153
étude de cas 438 GroupFunc 73
métamodèle 435 GTL 21, 291, 316, 333, 367, 428
modification à l'aide de la attributs calculés 429
visionneuse XML 445 bloc conditionnel 406
modifier 442 chaîne de fin 410
modifier dans un éditeur standard 442 chaîne d'en-tête 410
modifier dans un éditeur XML 444 collections calculées 431
OID 442 conseils et techniques 409
référence d'objet 438 conversion des raccourcis 380
structure 434 définition 368
XML 434 héritage 369, 381
format d'heure 66 message d'erreur 406
FunctionComment 149 partager des templates 409
passage de paramètre 414
polymorphisme 369, 382
portée de la conversion 379
G redéfinir un template 381
General 6 séquences d'échappement 383
General (catégorie) 5, 57 surcharge de template 383
EnableCheck 57 template 370
EnableConstname 58 templates récursifs 410
EnableIntegrity 57 variables 372
EnableMultiCheck 58 variables d'environnement 410
SqlSupport 58 GTL (macro)s 384
UniqConstName 59
généralisation 421
Generated Files (catégorie de langage objet) 303
Generation H
catégorie (langage de processus) 316 Header 67
catégorie (langage XML) 333 héritage 369, 381, 421
Generation (catégorie de langage objet) 291 HostDataType 181
générer 18
post-génération 358
pré-génération 358
générer pour une définition étendue I
de modèle 366 icône
attacher à un stéréotype 209
450 PowerAMC
if (macro) 386 langage de processus (suite)
IllegalChar 63 catégorie Implementation 325
Implementation catégorie catégorie Options 322
(langage de processus) 325 catégorie Profile 328, 339
importer Catégorie Settings 325
attributs étendus 348 catégorie Tasks 318
définition étendue de modèle 350 éditeur 314
fichier .EXA 349 entrée 312
Index (catégorie) 101 famille 315
Footer 106 modifier 312
Header 106 propriétés 315
index basé sur une fonction 33 sous-famille 315
IndexComment 107 langage objet 283, 284
IndexType 106 activer le suivi 286
Initialize gestionnaire d'événement 249 catégorie 284
Install 137 catégorie Commands 291
instruction SQL 36 catégorie Constants 289
format de variable 41 catégorie Criteria 301
mots réservés 36 catégorie Data types 288
template de nom de contrainte 43 catégorie Events 290
variables 38 catégorie Extended attributes 302
IsEmpty 375 catégorie Generated Files 303
catégorie Namings 289
catégorie Options 297
J catégorie Profile 300
join index Catégorie Settings 288
EnableJidxColn 163 catégorie Stereotype 301
EnableOwner 163 catégorie Tasks 293
Join Index (catégorie) 161 catégorie Templates 308
Footer 163 éditeur 285
Header 163 entrée 284
JoinIndexComment 163 famille 286
modifier 284
propriétés 286
rôle d'association 310
K sous-famille 286
Key 112 langage XML 329, 330
tasks category 335
activer le suivi 332
catégorie 330
L catégorie Commands 333
langage de génération par template (GTL) 367
langage de processus 311, 312
catégorie Options 336
activer le suivi 315
Catégorie Settings 339
catégorie 312
éditeur 331
catégorie Choreography 327
entrée 330
catégorie Commands 317
famille 332
catégorie Datahandling 327
modifier 330
propriétés 332

langage XML (suite) menu 252
sous-famille 332 contextuel 252
types de données 339 créer un menu contextuel 254
LineComment 63 créer un menu principal 254
ListOperators 74 emplacement 253
log (macro) 404 menu page 253
LogPhysADTType 180 outil Ajouter un séparateur 253
lowercase (macro) 389 outil Ajouter un sous-menu 253
LowerCaseOnly 64 outil Ajouter une commande 253
outil Créer une commande 253
principal 252
propriétés 253
M xml page 253
macro 384 message d'erreur 406
abort_command 403 erreur de conversion 408
bloc 384, 385 syntaxe 407
block 392 métaclasse 202
bool 400 activer la sélection pour la génération de
boucle 384, 385 fichiers 203
change_dir 403 ajouter un attribut étendu 219
commentaire & // 406 convention de dénomination de code 202
convert_code 394 exclure d'un modèle 205
convert_name 393 utiliser un stéréotype comme métaclasse 208
create_path 404 métamodèle 417
delete 391 association 420
error 405 attributs calculés 429
execute_command 402 classes 419
execute_vbscript 402 code de couleur 423
foreach_item 395 collection 420
foreach_line 397 collections calculées 431
foreach_part 398 concepts 419
if 386 définition 418
log 404 fonctionnalités 423
lowercase 389 format de fichier XML 432
replace 390 naviguer 423
set_object 400 noms publics 419
set_value 401 objets 423
simple 384, 385 packages 422
unique 388 PdCommon 422, 423
uppercase 389 PowerAMC 418
vbscript 387 structure 422
warning 405 symboles 423
MandIndexType 105 utilisation avec VBS 426
MaxColIndex 105 utiliser avec GTL 428
MaxConstLen 86, 99, 115, 119, 175 méthode 237
MaxDefaultLen 143 créer 238
MaxFuncLen 147 propriétés 237
Maxlen 75, 161, 167 script 237
MaxScriptLen 65 type 237
variables globale 237
452 PowerAMC
méthode (suite) Objects (catégorie) (suite)
VBS 238 Maxlen 75
ModifiableAttributes 79 ModifiableAttributes 79
modifier permission 158
définition étendue de modèle 342 Pkey 109
langage XML 330 Privilege 157
SGBD 2 Procedure 145
Modify instruction 20 Qualifier 164
ModifyColnComp 99 Reference 117
ModifyColnDflt 97 ReversedStatements 79
ModifyColnNull 99 Role 155
ModifyColumn 97 Rule 142
mot clé 72 Sequence 164
mot réservé 36 SqlAttrQuery 78
SqlFragQuery 78
SqlListQuery 77
SqlOptsQuery 78
N Storage 128
Namings catégorie (langage objet) 289 Synonym 166
nom par défaut 211 Table 79
nom public 419 Tablespace 126
NumberFunc 73 trigger 149
User 140
View 123
objet
O définition 438
Objects (catégorie de SGBD) Default 159 membre 372, 374
Objects (catégorie) 9, 75 portée 372, 377
Abstract Data Type 136 référence 438
Abstract Data Type Attribute 138 objet transformation interne 243
Add 76 ODBC
Column 87 génération 25
Create 75 requête 20
Database 130 requête de reverse engineering étendue 29
DB Package 168 reverse engineering 25
DB Package Cursor 172 reverse engineering à l'aide des qualifiants 35
DB Package Exception 173 reverse engineering d'index basés sur une
DB Package Parameter 173 fonction 33
DB Package Pragma 174 reverse engineering d'options physiques 31
DB Package Procedure 170 SqlAttrQuery 25
DB Package Type 172 SqlChckQuery 25
DB Package Variable 171 SqlListChildrenQuery 25
DefOptions 77 SqlListQuery 25
Domain 132 SqlOptsQuery 25
Drop 76 SqlPermQuery 25
Enable 75 SqlSysIndexQuery 25
Group 153 ODBC (catégorie) 5, 60
index 101 OdbcPhysDataType 179
Join Index 161 OID 442
Key 112 OpenDatabase 131

opérateur 374, 375, 376 profil (suite)
option physique 47 créer 358
attributs étendus 48 créer un fichier généré 231
composite 53 créer un template 229
liste de valeurs 52 critères 201, 213
répéter 55 étude de cas 256
sans nom 51 extension de métaclasse 201
spécifiée par une valeur 49 fichier généré 229
storage 52 fichiers générés & templates 201
tablespace 52 gestionnaire d'événement 247
valeur par défaut 51 héritage 199
variable 48 menu 252
Options méthode 237
catégorie (langage de processus) 322 niveau d'extension 199
catégorie (langage objet) 297 stéréotype 201, 206
catégorie (langage XML) 336 symbole et outil personnalisés 201
OtherFunc 74 symbole personnalisé 215
outil personnalisé par stéréotype 210 template 229
ouvrir d'un diagramme associé 424 transformation 11, 241, 300, 357
vérification personnalisée 201, 221
profile transformation 328, 339
Profile
P catégorie (langage objet) 300
ParameterTypes 171, 172 catégorie (SGBD) 5, 12
paramètre passer 414
partager un template 409
PdCommon 423
Permission 82, 89, 124, 146 Q
permission (object) 158 qualifiant 35
PhysDataType 178 Qualifier 164
PhysDttpSize 178 Quote 62
PhysLogADTType 180
PhysOdbcDataType 180
PkAutoIndex 110
Pkey 109 R
PKeyComment 111 raccourci conversion dans le GTL 380
polymorphisme 369, 382 rattachement automatique 354
portée 376 redéfinir 381
portée de la conversion 379 Reference 117
portée externe 376 Remove 138
post-génération 358 Rename 83, 99
pré-génération 358 replace (macro) 390
Privilege 157 requête étendue 29
Procedure 145 ReservedDefault 72
ProcedureComment 149 ReservedWord 72
profil 198 reverse engineering 18
ajouter une métaclasse 202 index basés sur une fonction 33
attribut étendu 201, 218 options physiques 31
Category (langage de processus) 328, 339 qualifiants 35
collection étendue 234 ReversedStatements 24, 79
454 PowerAMC
RevokeOption 158, 159 SQL (catégorie) (suite)
Role 155 caractère de fin 61
rôle d'association 310 caractère de fin de bloc 61
Rule 142 délimiteur 62
RuleComment 145 Format 63
LineComment 63
Quote 62
SqlContinue 63
S SqlAkeyIndex 116
script variables globales 227 SqlAttrQuery 25, 78
Script (catégorie) 6 SqlChckQuery 25, 84, 100
script (reverse engineering) 24 SqlContinue 63
script de vérification 222 SqlFragQuery 78
script helper methods 245 SqlListChildrenQuery 25, 122, 155, 157
ScriptExt 68 SqlListDefaultQuery 135
Sequence 164 SqlListQuery 25, 77
séquence d'échappement 383 SqlListRefrTables 85
SequenceComment 166 SqlOptsQuery 25, 78
set_object (macro) 400 SqlPermQuery 25, 84, 100, 125, 141, 148, 155,
set_value (macro) 401 157
SetSource 245 SqlSupport 58
Settings SqlSysIndexQuery 25, 107
catégorie (langage de processus) 325 StartCommand 69
catégorie (langage XML) 339 Stereotype catégorie (langage objet) 301
Settings (catégorie de langage objet) 288 stéréotype 206
SGBD 1 affecter un outil 210
attributs étendus 13 ajouter un attribut étendu 219
catégorie 3, 5 attacher une icône 209
catégorie Data type 11 créer 207
catégorie General 6, 57 nom par défaut 211
catégorie Objects 9, 75 propriétés 206
catégorie ODBC 6, 60 utiliser comme métaclasse 208
catégorie Profile 12 storage 128
catégorie Script 6, 60 option physique 52
catégorie SQL 8, 61 StorageComment 129
éditeur 4 suppression d'une commande 291, 317, 333
entrée 3 surcharge 383
famille 5 symbole personnalisé 201, 215
génération 18 créer 216
instruction 18, 19 format 215
modifier 2 Synonym 166
nom de fichier 5 syntaxe 36
présentation 2 System 158
propriétés 5
requête 18, 19
reverse engineering 18
simple (macro) 384, 385 T
sous-famille 286, 315, 332, 354 table
SQL (catégorie) 8, 61 Footer 86
BlockComment 63 Header 86

Table 79
TableComment 82
U
UddtComment 135
TableExt 69
UddtDefaultName 144
tablespace option physique 52
UddtRuleName 144
Tablespace 126
UML profil 198
TablespaceComment 128
Unbind 101, 135, 154, 156, 161
tâche 362
UniqConstaintName 85
Tasks
UniqConstAutoIndex 114
catégorie (langage de processus) 318
UniqConstName 59
catégorie (langage objet) 293
UniqInTable 115
tasks category (langage XML) 335
UniqName 108
template 201, 229, 370
unique (macro) 388
attribut étendu 219
uppercase (macro) 389
convertir les raccourcis 380
UpperCaseOnly 64
créer 229
Usage1 69
nom de contrainte 43
Usage2 69
partager 409
UseBlockTerm 62
partager des conditions 409
UseErrorMsgTable 151
portée de la conversion 379
UseErrorMsgText 152
récursif 410
User 140
redéfinir 381
UserTypeName 134
surcharger 383
UseSpFornKey 122
trigger 4
UseSpPrimKey 110
Templates (catégorie de langage objet) 308
utiliser comme métaclasse 208
Time 153
transformation 241
contrôles de script 243
créer 243 V
créer un profil 358 variable 3, 38, 182
étiquette permettant d'identifier l'origine 245 globale 227
objet transformation interne 243 variable (GTL) 372
post-génération 358 bloc 372
pré-génération 358 environnement 410
profil 357 format 377
profile 11, 300, 328, 339 globale 376
propriétés 241 locale 375
propriétés d'un profil 357 membre de collection 375
script 241 membre d'objet 374
script helper methods 245 membre-collection 372
variable 241 membre-objet 372
VBS 243 portée de la collection 377
TrgFooter 72 portée de l'objet 377
TrgHeader 71 portée externe 376
TrgUsage1 70 portée-objet 372
TrgUsage2 70 variable-globale 372
Trigger 149 variable-locale 372
TriggerComment 153 variable (SGBD)
TriggerExt 70 ASE & SQL Server 190
types de données 339 attribut de type de données abstrait 189
clé 193
456 PowerAMC
variable (SGBD) (suite)
colonne 188
X
XML
colonne de référence 193
balises 434
colonne d'index 191
format de fichier 432, 433
domaine 189
format 41
génération 182
Index 190
Join Index 191
métadonnées 185
options physiques 48
procédure 182, 195
référence 191
règles 189
reverse engineering 183
sécurité de base de données 184
Sequence 190
synchronisation de base de données 184
table 186
trigger 182
triggers 194
type de données abstraits 188
vérifications sur les domaines et sur les
colonnes 187
vues 194
variable locale 375
variable par défaut apostrophes 81
variables de format 377
VBS 426
vbscript (macro) 387
vérification personnalisée 201, 221
définir le script global 227
définir un script 223
définir une correction automatique 225
dépannage 228
exécuter 228
propriétés 222
variables globales 227
View 123
View (catégorie)
Footer 124
Header 124
ViewCheck 126
ViewComment 125
ViewStyle 126
W
warning (macro) 405

458 PowerAMC

Advanfr

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Advanfr

Transféré par

Droits d'auteur :

Formats disponibles

Sybase®

Unicode et le logo Unicode sont des marques déposées de Unicode, Inc.

1 Guide de référence du SGBD ............................................1

Documentation utilisateur avancée iii

Documentation utilisateur avancée v

3 Guide de référence du langage objet............................283

4 Guide de référence du langage de processus .............311

5 Guide de référence du langage XML.............................329

Documentation utilisateur avancée vii

7 Guide de référence de la génération ............................ 367

8 Métamodèle public PowerAMC ..................................... 417

9 Spécification du format de fichier PowerAMC .............433

Documentation utilisateur avancée ix

Guide de référence du SGBD

Sujet Ce document décrit la structure et le contenu d'un fichier de définition de

Présentation du fichier de définition de SGBD 2

Avant de Les modifications apportées à un fichier de définition de SGBD peuvent

Documentation utilisateur avancée 1

Présentation du fichier de définition de SGBD

PowerAMC peut être utilisé avec de nombreux SGBD différents. Pour

 Pour plus d'informations sur la création d'une nouvelle définition de

Que contient une

Documentation utilisateur avancée 3

 Pour afficher l'éditeur de SGBD :

Notions de base relatives aux catégories de

Feuille de propriétés de SGBD

Documentation utilisateur avancée 5

Catégorie Script et ODBC

Lorsque la valeur d'une commande ou sa catégorie manque lors de la

Documentation utilisateur avancée 7

Exemple Dans le fichier de définition de Sybase Adaptive Server Anywhere 6, la

Exemple Dans le fichier de définition de Sybase Adaptive Server Anywhere 6, la

L'entrée Terminator est sélectionnée et la zone Valeur associée à cette

Documentation utilisateur avancée 9

Exemple Dans le fichier de définition de Sybase Adaptive Server Anywhere 8, la

Catégorie Data type

Catégorie Transformation profile

Documentation utilisateur avancée 11

 Pour plus d'informations sur les profils, reportez-vous au chapitre

La catégorie Extended Attribute est divisée en deux catégories :

Définition d'un attribut étendu dans un SGBD

 Pour ajouter un attribut étendu :

Exemple Dans DB2 UDB 7 OS/390, l'attribut étendu WhereNotNull permet

Documentation utilisateur avancée 13

Dans la commande Create index, WhereNotNull est évalué comme

Utilisation des attributs étendus dans le MPD

Le nom et le type de données des attributs étendus ne peuvent pas être

 Pour définir la valeur d'un attribut étendu :

Documentation utilisateur avancée 15

4 Cliquez sur OK.

Utilisation d'attributs étendus lors de la génération

PowerAMC prend en compte la casse des caractères

Documentation utilisateur avancée 17

Gestion de la génération et du reverse

Notions de base relatives aux instructions et requêtes

Exploration de la catégorie Script

Instructions de La catégorie Script contient des instructions DDL (Database Description

Documentation utilisateur avancée 19

♦ ConstName pour définir le template de nom de contrainte pour les

Exploration de la catégorie ODBC

Par exemple, l'échange de données entre PowerAMC et MSACCESS

Documentation utilisateur avancée 21

 Pour plus d'informations sur le langage de génération par template

Pour plus d'informations sur la création d'une nouvelle définition de

Pour afficher l'éditeur de SGBD :

Pour plus d'informations sur les profils, reportez-vous au chapitre

Pour ajouter un attribut étendu :

Pour définir la valeur d'un attribut étendu :

Pour plus d'informations sur le langage de génération par template

Pour plus d'informations sur le langage de génération par template

Pour plus d'informations sur les filtres de qualifiants, reportez-vous à la

Pour obtenir la liste des variables utilisées dans PowerAMC, reportez-

Pour obtenir la liste de toutes les variables utilisées dans PowerAMC,