L'utilitaire ManageRepository permet de créer un référentiel dans une
base de données et de le gérer. Le référentiel contient des données pureQuery utilisées par des applications activée avec pureQuery,
notamment des informations de configuration et des données pureQueryXML.
Le référentiel peut stocker des données SQL capturées à partir d'applications activées
avec l'optimisation client pureQuery.
Opérations de niveau référentiel
Les opérations de niveau référentiel
ManageRepository incluent la création, la mise à niveau et la suppression d'un référentiel dans une base de données, le contrôle de validité et l'affichage de la version du référentiel.
Pour
afficher les instructions SQL requises pour créer, supprimer
ou lier un référentiel, utilisez l'option -generateScriptOnly.
Les instructions sont générées sans pour autant exécuter les opérations correspondantes. Si vous modifiez les instructions SQL et les émettez, vous pouvez utiliser l'option -verify repository pour contrôler le référentiel.
Pour
créer un référentiel qui contient uniquement les informations des fichiers pureQuery utilisés pour l'optimisation client pureQuery,
utilisez l'option -repositoryType avec la valeur pureQueryRuntimeOnly.
Syntaxe de la commande ManageRepository
pour les opérations de niveau référentiel

(1)
>>-------java--com.ibm.pdq.tools.ManageRepository--------------->
>--+- -create repository-- -repositoryType--+-pureQueryOnly--------+------------------+-->
| '-pureQueryRuntimeOnly-' |
| (2) |
+------- -bind packages------------------------------------------------------------+
+- -verify repository--------------------------------------------------------------+
+- -report--+-repositoryData--+---------------------------+-- -file--nom-fichier-+-+
| | | .-long--. | | |
| | '- -reportlength--+-short-+-' | |
| '-repositoryVersion--------------------------------------------------' |
+- -delete repository--+--------------------+--------------------------------------+
| | .-FALSE-. | |
| '- -force--+-TRUE--+-' |
'- -upgrade repository-------------------------------------------------------------'
>--| connection information |----------------------------------->
>--+---------------------------------------------------+-------->
| (3) |
'------- -generateScriptOnly--chemin-fichier-script-'
>--+--------+--------------------------------------------------><
'- -help-'
informations de connexion
|-- -repositoryURL--URL-base de données-référentiel------------->
>-- -repositoryUsername--ID-utilisateur-- -repositoryPassword--mot de passe-->
>-- -repositoryDriverClass--classe de pilote-------------------->
>--+------------------------------------------+-----------------|
| (4) .-IBMPDQ-----. |
'------- -repositorySchema--+-nom_schéma-+-'
Remarques:
- Vous pouvez spécifier les options dans n'importe quel ordre.
- L'option -bind packages ne peut être utilisées
qu'avec une base de données prenant en charge les instructions SQL statiques.
- L'option -generateScriptOnly ne peut pas être utilisée
avec l'option -report.
- Si l'option -repositorySchema est spécifiée
lors de la création d'un référentiel, l'option doit être spécifiée pour les commandes
ManageRepostitory suivantes.
Description des options relatives aux opérations de niveau référentiel
La liste suivante décrit les options et variables ManageRepository prises en charge.
- -create repository
- L'utilitaire ManageRepository utilise les informations de connexion pour
déterminer le type de plateforme de base de données et émettre les instructions DDL
appropriées afin de créer les tables dans le schéma spécifié.
Si un référentiel
existe, une erreur s'affiche.
- -repositoryType
- Permet de spécifier le type de référentiel à créer. Les types de
référentiel suivants sont pris en charge :
- pureQueryOnly
- Il s'agit de la valeur par défaut. Le référentiel peut contenir des informations
des fichiers pureQuery utilisés
par les applications activées avec l'optimisation client
pureQuery, les propriétés pureQuery Runtime
et les données pureQueryXML. Le référentiel peut également contenir des options de liaison et des options de configuration de fichiers pureQueryXML.
Lorsque vous téléchargez les contenus d'un fichier pureQueryXML sur un référentiel, l'utilitaire
ManageRepository extrait les instructions SQL des données
pureQueryXML et les stocke séparément dans le référentiel.
Le référentiel peut contenir les données SQL qui ont été exportées depuis
IBM® Data
Studio vers le référentiel.
- pureQueryRuntimeOnly
- Le référentiel peut contenir des informations des fichierspureQuery utilisés par les applications activées
avec l'optimisation client pureQuery, les propriétés pureQuery Runtime
et les données pureQueryXML. Le référentiel peut également contenir des options de liaison et des options de configuration de fichiers pureQueryXML.
Utilisez l'option -generateScriptOnly pour
générer un script SQL avec les instructions SQL permettant de créer un référentiel, sans créer
de référentiel. Après avoir passé le script en revue, vous
pour l'exécuter pour créer le référentiel. Si vous modifiez les instructions SQL et exécutez le script, vous pouvez utiliser l'option
-verify repository pour vérifier le référentiel.
- -bind packages
- Sur les plateformes de base de données prenant en charge les instructions SQL statiques, indique que
des packages de base de données sont créés pour gérer l'accès au référentiel.
Le nom de collection et les noms de package sont choisis par l'utilitaire et
ne peuvent pas être modifiés par l'utilisateur.
Une fois le référentiel créé, les options
-grant et -revoke de l'utilitaire ManageRepository
sont utilisées pour accorder des privilèges à ces packages et en révoquer. Pour plus d'informations
sur l'accès aux packages, voir Opérations de gestion des privilèges des groupes d'exécution
Utilisez
l'option -generateScriptOnly uniquement pour générer un script,
sans exécuter d'opération de définition des accès.
- -report repositoryData | repositoryVersion
- Affiche des informations sur le référentiel.
- repositoryData [-reportLength short|long]
-file nom-fichier
- Génère un rapport HTML décrivant les informations de groupe d'exécution dans le
référentiel. La valeur nom-fichier correspond au nom et à l'emplacement du fichier qui contiendra le rapport.
Utilisez l'option
facultative
-reportLength pour spécifier les informations
dans le rapport.
- long
- Il s'agit de la valeur par défaut. Le rapport de référentiel répertorie les informations
de package et les instructions SQL contenues dans les packages.
- short
- Le rapport de référentiel répertorie les informations de package. Les instructions SQL
dans les packages ne sont pas répertoriées.
- repositoryVersion
- Affiche la version du référentiel.
- -verify repository
- Vérifie les tables dans le référentiel pour s'assurer que les tables
ont été correctement créées, avec les colonnes et types de colonne prévus.
Des tests sont également réalisées pour vérifier que les droits d'accès en lecture et en écriture au
référentiel sont corrects et donc s'assurer que l'ID utilisateur en charge de l'exécution dispose des autorisations appropriées.
La sortie renvoyée inclut les informations des différents composants du référentiel. La sortie inclut également des messages indiquant
des problèmes avec le référentiel tel que des autorisations incorrectes ou des tables avec des colonnes manquantes.
Utilisez
l'option -generateScriptOnly pour générer un script SQL,
sans vérifier le référentiel.
- -delete repository
- Supprime toutes les tables utilisées par le référentiel. Toutes les données dans le référentiel
sont supprimées.
Un message demandant à l'utilisateur de confirmer la
suppression des tables de base de données s'affiche.
- -force TRUE|FALSE
- Valeur booléenne permettant de confirmer la suppression du référentiel.
Utilisez -force TRUE pour
confirmer la suppression, sans qu'aucun message ne s'affiche.
Utilisez l'option -generateScriptOnly pour
générer un script SQL, sans supprimer le référentiel.
Pour pureQuery Runtime version 3.2
et ultérieure, la suppression d'un référentiel n'implique pas la suppression de l'espace table
ou du pool de mémoire tampon de ce référentiel. Pour plus d'informations sur la suppression de l'espace
table ou du pool de mémoire tampon, voir Remarques sur l'utilisation.
- -generateScriptOnly chemin-fichier-script
- Génère un script SQL avec les instructions SQL permettant d'exécuter l'opération
ManageRepository, sans exécuter l'opération. Vous devez
spécifier les informations de connexion à la base de données du référentiel.
Vous pouvez modifier le script de création d'un référentiel pour changer certains noms d'objet. Cependant, vous ne
pouvez pas modifier le nom du schéma, le nom des tables ou des colonnes. Pour obtenir des informations sur l'utilisation des scripts
ManageRepository, voir Remarques sur l'utilisation.
Après avoir passé en revue et
modifié le script, un administrateur de base de données peut créer le
référentiel en exécutant le script. Par exemple, l'administrateur de base de données
peut ajouter un espace de table aux instructions SQL dans le script.
Une fois le
référentiel créé, l'option -verify repository peut
être utilisée pour vérifier le référentiel.
Pour l'option -bind packages,
le nom de collection et les noms de package sont choisis par l'utilitaire et
ne peuvent pas être modifiés par l'utilisateur.
- -upgrade repository
- Mettez à niveau un référentiel pour qu'il prenne en charge le stockaged'événements de journaux pureQuery dans le référentiel.
Si le référentiel se trouve déjà au niveau correct, aucune action n'est entreprise.
Pour
un référentiel qui prend en charge le stockage d'événements de journaux, vous pouvez spécifier la propriété de journalisation pureQuery
com.ibm.pdq.database pour écrire des événements pureQuery
sur le référentiel.
Utilisez l'option -generateScriptOnly pour générer un script SQL sans mettre à niveau le référentiel.
- -help
- Affiche des informations sur l'utilisation.
Description des options relatives aux informations de
connexion
La liste suivante décrit les informations requises
pour se connecter à la base de données d'un référentiel :
- -repositoryDriverClass classe de pilote
- Nom de classe qualifié complet du pilote JDBC à utiliser pour se connecter
à la base de données du référentiel.
- -repositorySchema nom_schéma
- Le nom de schéma du référentiel. Le nom du schéma par défaut est
IBMPDQ.
Pour plus d'informations sur la spécification d'un nom de schéma pour un référentiel,
voir Remarques sur l'utilisation.
- -repositoryURL URL-basededonnées-référentiel
- URL de la base de données du référentiel
- -repositoryUsername ID-utilisateur -repositoryPassword mot de passe
- ID et mot de passe utilisés pour se connecter à la base de données
Opérations de gestion des groupes d'exécution
Les opérations
ManageRepository de niveau groupe d'exécution incluent la création, la gestion et
la suppression de groupes d'exécution et des versions de groupes dans un référentiel.
Les données pureQuery stockées dans une
version de groupe d'exécution incluent les informations de configurationpureQuery, les
données pureQueryXML et le cas échéant, les données SQL capturées à
partir des applications activées avec l'optimisation client
pureQuery.
Les versions de groupe d'exécution contiennent également d'autres informations
utilisées par pureQuery Runtime
afin d'identifier la version d'exécution et la version active du groupe.
Syntaxe des opérations de gestion de groupes
d'exécution

(1)
>>-------java--com.ibm.pdq.tools.ManageRepository--------------->
>--+- -create runtimeGroup--+-----------------------+-------------------------------------------------+-->
| '-| Données pureQuery |-' |
+- -update runtimeGroup--+-----------------------+-------------------------------------------------+
| '-| Données pureQuery |-' |
+- -delete runtimeGroup--+--------------------+----------------------------------------------------+
| | .-FALSE-. | |
| '- -force--+-TRUE--+-' |
+- -delete incremental-- -inputDirectory--chemin-répertoire-- -incrementalCapture--préfixe-fichier-+
+- -list runtimeGroupVersions----------------------------------------------------------------------+
+- -activate runtimeGroup--------------------------------------------------------------------------+
+- -deactivate runtimeGroup------------------------------------------------------------------------+
'- -copy runtimeGroup--+---------------------------------+-- -targetVersion--version-cible---------'
'- -sourceVersion--version-source-'
>-- -runtimeGroupId--ID groupe---------------------------------->
(2)
>-------- -runtimeGroupVersion--version------------------------->
>--+---------------------------------+--+--------+-------------->
'- -contact--informations-contact-' '- -help-'
>--| connection information |----------------------------------><
Données pureQuery
(3)
|-------- -inputDirectory--chemin-répertoire-------------------->
>--+------------------------------------------+----------------->
'- -pureQueryXml--nom-fichier-pureQueryXML-'
>--+-----------------------------------------------+------------>
'- -pureQueryProperties--fichier-prop-exécution-'
>--+---------------------------------------------+-------------->
'- -optionsFileForConfigure -fichier-genProps-'
>--+-----------------------------------------+------------------|
'- -optionsFileForBind -fichier-bindProps-'
Informations de connexion
|-- -repositoryURL--URL-base de données-référentiel------------->
>-- -repositoryUsername--ID-utilisateur-- -repositoryPassword--mot de passe-->
>-- -repositoryDriverClass--classe de pilote-------------------->
>--+------------------------------------------+-----------------|
| (4) .-IBMPDQ-----. |
'------- -repositorySchema--+-nom_schéma-+-'
Remarques:
- Vous pouvez spécifier les options dans n'importe quel ordre.
- L'option -runtimeGroupVersion ne peut pas être
définie avec l'option -copy runtimeGroup.
- Lors de la mise à jour des données pureQuery,
spécifiez au moins un fichier.
- Si l'option -repositorySchema est spécifiée
lors de la création d'un référentiel, l'option doit être spécifiée pour gérer
le référentiel.
Description des options relatives aux opérations de gestion de groupes d'exécution
La liste suivante décrit les options et variables ManageRepository prises en charge.
- -create runtimeGroup
- Permet de créer un groupe d'exécution avec l'ID de groupe et la version indiqués.
Si l'ID de groupe d'exécution existe dans le référentiel, une erreur s'affiche.
Lors
de la création d'une version du groupe d'exécution, les paramètrespureQuery suivants sont les paramètres par défaut :
- La propriété executionMode correspond à DYNAMIC (pour exécuter
des instructions SQL dynamiques).
- La propriété captureMode est définie sur ON (mode de capture
de type incrémentiel).
Pour redéfinir les paramètres par défaut et spécifier d'autres propriétés,
indiquez les fichiers contenant les propriétés et leurs valeurs.
- -update runtimeGroup
- Mettez à jour les données contenues dans la version du groupe d'exécution avec les données pureQuery des fichiers spécifiés.
- -delete runtimeGroup
- Permet de supprimer le l'ID de groupe du groupe d'exécution du
référentiel.
Un message demandant à l'utilisateur de confirmer la
suppression du groupe d'exécution s'affiche. L'utilisateur peut annuler l'action.
- -force TRUE|FALSE
- Indiquez TRUE ou FALSE pour confirmer la suppression du groupe d'exécution.
Si vous indiquez TRUE, le groupe d'exécution est supprimé sans confirmation. La valeur par défaut
est FALSE.
Utilisez l'option -force TRUE
pour confirmer la suppression, sans qu'aucun message ne s'affiche.
- -delete incremental
- Permet de supprimer les données SQL capturées à partir de la version d'un groupe d'exécution. Les données
dans les fichiers SQL capturés spécifiés sont comparées aux données du référentiel
et les données SQL capturées du référentiel sont supprimées en cas de correspondance.
Une fois
les données SQL capturées fusionnées avec les données pureQueryXML de la version d'un
groupe d'exécution, les données SQL capturées pour la version peuvent être supprimées.
- -inputDirectory chemin-répertoire
- Chemin d'accès complet au répertoire contenant les fichiers SQL capturés.
- -incrementalCapture préfixe-fichier
- Préfixe utilisé par les fichiers SQL capturés.
- -list runtimeGroupVersions
- Affiche des informations sur les versions de groupe d'exécution.
- -activate runtimeGroup
- Permet d'activer une version de groupe d'exécution.
Lorque pureQuery Runtime accède à un groupe d'exécution
dans le référentiel, il utilise les informations pureQuery
contenues dans la version du groupe d'exécution active.
Par
défaut, pureQuery Runtime vérifie les mises à jour des informations pureQuery
pour une version de groupe d'exécution après l'activation de la version du groupe d'exécution.
Si la version du groupe d'exécution est activée et que les données pureQuery pour
la version du groupe d'exécution sont à jour, pureQuery Runtime actualise
les données. Les propriétés pureQuery Runtime
runtimeGroupActivationCheckInterval et propertiesRefreshInterval contrôlent
le moment où pureQuery Runtime
vérifie les mises à jour des informations pureQuery
pour une version de groupe d'exécution. Pour plus d'informations sur la vérification des
mises à jour, voir Remarques sur l'utilisation.
- -deactivate runtimeGroup
- Permet de désactiver un groupe d'exécution.
Lorsque pureQuery Runtime accède à un groupe d'exécution
dans le référentiel, il ignore les informationspureQuery
contenues dans les groupes d'exécution qui ne sont pas actifs.
- -copy runtimeGroup
- Permet de copier les données du groupe d'exécution de la version spécifiée dans l'option -sourceVersion
dans le même groupe dont le nom de version est indiqué par l'option -targetVersion.
- -sourceVersion version-source
- Indique la version existante du groupe d'exécution utilisé pour créer une version de groupe d'exécution.
Si aucune valeur source-version n'est spécifiée, la version de groupe d'exécution active est utilisée. Si aucune valeur version-source n'est
indiquée et qu'il n'y a pas de version de groupe d'exécution active, un message d'erreur
s'affiche.
- -targetVersion version-cible
- Indique la version de groupe d'exécution créée lors de la copie de la version de groupe d'exécution version-source.
- -runtimeGroup ID groupe
- Indique l'identifiant du groupe d'exécution du référentiel.
- -runtimeGroupVersion version
- Indique un nom de version de groupe d'exécution. L'option -runtimeGroupVersion ne peut pas être
définie avec l'option -copy runtimeGroup.
- -contact informations-contact
- Chaîne spécifiant des informations de contact facultatives stockées avec la
version de groupe d'exécution.
- -help
- Affiche des informations sur l'utilisation.
Description des options relatives aux données pureQuery
La
liste suivante décrit les options de données
pureQuery :
- -inputDirectory chemin-répertoire
- Le chemin d'accès complet vers le répertoire des fichiers pureQuery.
- -pureQueryXml nom-fichier-pureQueryXML
- Nom du fichier pureQueryXML.
- -pureQueryProperties nom-fichier-prop-exécution
- Le nom du fichier de propriétés
pureQuery Runtime.
- -optionsFileForConfigure fichier-genProps
- Le fichier contenant les options utilisées par l'utilitaire Configure.
- -optionsFileForBind fichier-bindProps
- Fichier contenant les options utilisées par l'utilitaire StaticBinder pour
lier des instructions SQL dans le fichier pureQueryXML.
Description des options relatives aux informations de
connexion
La liste suivante décrit les informations requises
pour se connecter à la base de données d'un référentiel :
- -repositoryDriverClass classe de pilote
- Nom de classe qualifié complet du pilote JDBC à utiliser pour se connecter
à la base de données du référentiel.
- -repositorySchema nom_schéma
- Le nom de schéma du référentiel. Le nom du schéma par défaut est
IBMPDQ.
Pour plus d'informations sur la spécification d'un nom de schéma pour un référentiel,
voir Remarques sur l'utilisation.
- -repositoryURL URL-basededonnées-référentiel
- URL de la base de données du référentiel
- -repositoryUsername ID-utilisateur -repositoryPassword mot de passe
- ID et mot de passe utilisés pour se connecter à la base de données
Opérations de gestion des privilèges des
groupes d'exécution
Les opérations de gestion des privilèges sont effectuées
une fois les données SQL capturées stockées dans la base de données du référentiel.
Un administrateur doit accorder des droits pour les applications pour pouvoir lire et
écrire des données dans les tables de la base de données du référentiel.
Syntaxe des opérations de gestion des privilèges

(1)
>>-------java--com.ibm.pdq.tools.ManageRepository--------------->
>--+- -revoke-+------------------------------------------------->
'- -grant--'
.-,---------------.
V |
>----"--grantees--(----ID_autorisation-+--) -"------------------>
>-- -privilege--+-tableAccess----------+------------------------>
| (2) |
'-------executePackage-'
>-- -accessLevel -+-APPLICATION-+--| connection information |--->
'-MANAGER-----'
>--+--------+--------------------------------------------------->
'- -help-'
>--+---------------------------------------------+-------------><
'- -generateScriptOnly--chemin-fichier-sortie-'
Informations de connexion
|-- -repositoryURL--URL-base de données-référentiel------------->
>-- -repositoryUsername--ID-utilisateur-- -repositoryPassword--mot de passe-->
>-- -repositoryDriverClass--classe de pilote-------------------->
>--+------------------------------------------+-----------------|
| (3) .-IBMPDQ-----. |
'------- -repositorySchema--+-nom_schéma-+-'
Remarques:
- Vous pouvez spécifier les options dans n'importe quel ordre.
- Sur les plateformes prenant en charge les instructions SQL statiques, executePackage est la
seule option prise en charge après l'émission de l'option -bind packages.
- Si l'option -repositorySchema est spécifiée
lors de la création d'un référentiel, l'option doit être spécifiée pour gérer
le référentiel.
Description des options relatives à la gestion des privilèges
du référentiel
La liste suivante décrit les options et variables ManageRepository prises en charge :
- -grant
- Accorde l'accès spécifié par l'option -privilege aux
utilisateurs indiqués dans la liste grantees.
- -revoke
- Révoque tous les privilèges des tables de dbase de données de référentiel
pour les utilisateurs spécifiés dans la liste grantees.
Il est inutile de
spécifier un rôle pour l'option -revoke.
- "grantees(premier_ID, deuxième_ID,
...)"
- Mot clé indiquant la liste des utilisateurs de base de données concernés. La
clause grantees, le mot-clé et la liste des utilisateurs doivent commencer et se
terminer par des guillemets ("). Les noms d'utilisateur doivent être séparés par des virgules.
Dans l'exemple suivant, trois ID d'autorisation sont spécifiés en tant que titulaires.
"grantees(test1, test2, user1)"
- ID-autorisation
- ID utilisateur de base de données auquel des privilèges sont accordés ou pour lequel il sont révoqués.
L'ID PUBLIC
peut être indiqué.
L'ID-autorisation doit
présenter la même casse que l'ID utilisateur de base de données. Par exemple, si l'ID utilisateur DB2 est en lettres majuscules, l'ID-autorisation doit être saisi en lettres
majuscules.
- -privilege tableAccess|executePackage
- Indique le type de privilège accordé. Les valeurs de
privilège suivantes sont prises en charge :
- tableAccess
- Privilège pour les plateformes prenant uniquement en charge les instructions SQL dynamiques. Vérifie
que les applications dynamiques ont accès aux tables de base de données des
référentiels sous-jacents. tableAccess est pour les environnements SQL
dynamiques où les privilèges sur les tables de base de données de référentiel
eux-mêmes sont obligatoires.
- executePackage
- Privilège pour les plateformes prenant en charge les instructions SQL statiques
où l'option -bind packages de ManageRepository a été émise. Vérifie que les applications peuvent
accéder au référentiel avec des instructions SQL liées en mode statique créées
par l'utilitaire ManageRepository.
- -accessLevel MANAGER|APPLICATION
Les valeurs suivantes sont prises en charge pour l'option
-accessLevel :
- APPLICATION
- Un ID utilisateur auquel les droits d'accès APPLICATION ont été accordés peut
lire les données pureQueryXML et écrire dans les tables utilisées pour stocker les données
SQL capturées.
- MANAGER
- Les droit d'accès MANAGER permettent d'accéder à toutes
les tables de base de données du référentiel. Les privilèges sont accordés aux
titulaires figurant dans la liste des ID utilisateur.
Si un référentiel InfoSphere Optim Performance Manager est ciblé, seul le niveau d'accès
MANAGER est disponible.
- -generateScriptOnly chemin-fichier-script
- Génère un script SQL avec les instructions SQL permettant d'exécuter l'opération
ManageRepository, sans exécuter l'opération.
Après avoir passé en revue et
modifié le script, un administrateur de base de données peut créer le
référentiel en exécutant le script. Une fois le
référentiel créé, l'option -verify repository peut
être utilisée pour vérifier le référentiel.
Pour l'option -bind packages,
le nom de collection et les noms de package sont choisis par l'utilitaire et
ne peuvent pas être modifiés par l'utilisateur.
- -help
- Affiche des informations sur l'utilisation.
Description des options relatives aux informations de
connexion
La liste suivante décrit les informations requises
pour se connecter à la base de données d'un référentiel :
- -repositoryDriverClass classe de pilote
- Nom de classe qualifié complet du pilote JDBC à utiliser pour se connecter
à la base de données du référentiel.
- -repositorySchema nom_schéma
- Le nom de schéma du référentiel. Le nom du schéma par défaut est
IBMPDQ.
Pour plus d'informations sur la spécification d'un nom de schéma pour un référentiel,
voir Remarques sur l'utilisation.
- -repositoryURL URL-basededonnées-référentiel
- URL de la base de données du référentiel
- -repositoryUsername ID-utilisateur -repositoryPassword mot de passe
- ID et mot de passe utilisés pour se connecter à la base de données
Opérations d'extraction, d'exportation et
d'importation
Avec un ensemble de capture incrémentiel, l'optimiseur client pureQuery continue de
capturer de nouvelles instructions SQL et d'enregistrer des activités SQL afin que les
instructions SQL obsolètes puissent être supprimées. Selon les paramètres du fichier de propriétés pureQuery Runtime,
les données SQL capturées peuvent être stockées dans le même référentiel que
les données pureQueryXML, ou dans un autre référentiel. Une fois capturées,
les données SQL peuvent être fusionnées avec les données pureQueryXML de sorte qu'un nouveau fichier pureQueryXML
puisse être téléchargé. La procédure est composée des étapes suivantes :
- Procédez à l'extraction des données incrémentielles.
- Utilisez l'utilitaire Merge pour combiner les fichiers SQL capturés avec le
fichier pureQueryXML.
- Utilisez l'utilitaire Configure pour configurer le fichier pureQueryXML
mis à jour.
- Vous pouvez éventuellement utiliser l'utilitaire StaticBind pour créer des packages d'instructions SQL
dans une base de données à partir des ensembles d'instructions du fichier pureQueryXML et lier les packages dans la base de données.
- Mettez le groupe d'exécution à jour avec les nouvelles données.
Syntaxe des opérations d'exportation, d'extraction
et d'importation de données

(1)
>>-------java--com.ibm.pdq.tools.ManageRepository--------------->
>--+- -export data-- -file--chemin-nom-fichier-zip-+------------>
+- -extract runtimeGroup--| Données pureQuery |-+
'- -import data-- -file--chemin-nom-fichier-zip-'
>-- -runtimeGroupId--ID-groupe---------------------------------->
>-- -runtimeGroupVersion--ID-version---------------------------->
>--| connection information |----------------------------------->
>--+---------------------------------------------------+-------->
| (2) |
'-------| informations de connexion SQL capturées |-'
>--+--------+--------------------------------------------------><
'- -help-'
Données pureQuery
(3)
|-------- -outputDirectory--chemin-répertoire------------------->
>--+------------------------------------------+----------------->
'- -pureQueryXml--nom-fichier-pureQueryXML-'
>--+-----------------------------------------------+------------>
'- -pureQueryProperties--fichier-prop-exécution-'
>--+---------------------------------------------+-------------->
'- -optionsFileForConfigure -fichier-genProps-'
>--+-----------------------------------------+------------------>
'- -optionsFileForBind -fichier-bindProps-'
>--+-------------------------------+----------------------------|
'- -incrementalCapture--préfixe-'
Informations de connexion
|-- -repositoryURL--URL-base de données-référentiel------------->
>-- -repositoryUsername--ID-utilisateur-- -repositoryPassword--mot de passe-->
>-- -repositoryDriverClass--classe de pilote--------------------|
informations de connexion SQL capturées
|-- -incrementalRepositoryURL--URL-base de données-référentiel-->
>-- -incrementalRepositoryUsername--ID-utilisateur-- -incrementalRepositoryPassword--mot de passe-->
>-- -incrementalRepositoryDriverClass--classe de pilote--------->
>--+------------------------------------------+-----------------|
| (4) .-IBMPDQ-----. |
'------- -repositorySchema--+-nom_schéma-+-'
Remarques:
- Vous pouvez spécifier les options dans n'importe quel ordre.
- A utiliser uniquement avec l'option -extract runtimeGroup.
Indiquez les informations requises pour extraire les données SQL capturées si elles
résident dans un référentiel distinct de celui contenant les autres données pureQuery.
- Lors de la mise à jour des données pureQuery,
spécifiez au moins un fichier.
- Si l'option -repositorySchema est spécifiée
lors de la création d'un référentiel, l'option doit être spécifiée pour gérer
le référentiel.
Description des options relatives à l'exportation
et à l'extraction de données
La liste suivante décrit les options et variables ManageRepository prises en charge :
- -export data
- Exporte les données pureQuery
de toutes les versions d'un groupe d'exécution vers un fichier zip. Ce dernier peut être utilisé comme fichier source lors de l'importation de
de données.
- -file chemin-nom-fichier-zip
- Le chemin d'accès complet et le nom de fichier du fichier zip qui contiendra
les données extraites du groupe d'exécution pureQuery.
- -extract runtimeGroup
- Permet d'extraire les données pureQuery
de la version du groupe d'exécution spécifié dans un ou plusieurs fichiers. Les options de données pureQuery déterminent
les données pureQuery extraites
de la version du groupe d'exécution. Par exemple, vous spécifiez
les options -pureQueryXml myPqXML.pdqxml et -optionsFileForBind myBindOpts.opts.
Le fichier myPqXML.pdqxml contient les données de fichier pureQueryXML
et le fichier myBindOpts.opts contient
les données des options de liaison.
- -import data
- Permet d'importer des données pureQuery
à partir d'un fichier zip créé lors de l'exportation de donnéespureQuery à partir d'un référentiel.
Si
les données ont été exportées avec la fonction d'export de Data Studio et que plusieurs
projets pureQuery
ont été sélectionnés pour exportation, seuls les données pureQuery des derniers projets sont importées dans le groupe
d'exécution spécifié par l'option -runtimeGroupId.
- -file chemin-nom-fichier-zip
- Indique le chemin et le nom du fichier zip contenant les données
exportées. Le fichier est utilisé pour l'exportation de donnéespureQuery à partir d'une version de groupe d'exécution du référentiel, ou pour l'importation de donnéespureQuery dans une version de groupe d'exécution
de référentiel.
- -runtimeGroupId ID groupe
- Indique l'identifiant du groupe d'exécution du référentiel.
- -runtimeGroupVersion version
- Indique l'identifiant de la version du groupe d'exécution.
- -help
- Affiche des informations sur l'utilisation.
Description des options relatives aux données pureQuery
La
liste suivante décrit les options de données
pureQuery :
- -outputDirectory chemin-répertoire
- Indique le chemin d'accès complet vers le répertoires des fichierpureQuery.
- -pureQueryXml nom-fichier-pureQueryXML
- Indique le nom du fichier pureQueryXML.
- -pureQueryProperties nom-fichier-prop-exécution
- Indique le nom du fichier de propriétéspureQuery Runtime.
- -optionsFileForConfigure fichier-genProps
- Spécifie le fichier contenant les propriétéspureQuery
pour la génération des fichiers de capture SQL.
- -optionsFileForBind fichier-bindProps
- Spécifie le fichier contenant les propriétéspureQuery
utilisées pour lier les instructions SQL dans le fichier pureQueryXML.
- -incrementalCapture préfixe
- Indique le préfixe de fichier utilisé lors de l'exportation de jeux de données SQL
capturées dans des fichiers. Les noms de fichiers contenant les données SQL capturées extraites ont le format suivant :
préfixe_N.pdqxml,
où la valeur N est un nombre entier commençant par 1 et utilisé pour chaque fichier créé lors de l'exportation.
Par exemple, pour l'option
-incrementalCapture
"testApp", les fichiers suivants peuvent être générés :
testApp_1.pdqxml
testApp_2.pdqxml
Les données SQL capturées peuvent être extraites d'un
référentiel différent du référentiel contenant les
données pureQueryXML. Indiquez les informations de connexion de la ligne de commande pour le référentiel contenant la base de données SQL capturée.
Description des options relatives aux informations de
connexion
La liste suivante décrit les informations requises
pour se connecter à la base de données d'un référentiel :
- -repositoryDriverClass classe de pilote
- Indique le nom de classe qualifié complet du pilote JDBC à utiliser pour se connecter
à la base de données du référentiel.
- -repositorySchema nom_schéma
- Le nom de schéma du référentiel. Le nom du schéma par défaut est
IBMPDQ.
Pour plus d'informations sur la spécification d'un nom de schéma pour un référentiel,
voir Remarques sur l'utilisation.
- -repositoryURL URL-base de données-référentiel
- Indique l'URL de la base de données du référentiel.
- -repositoryUsername ID-utilisateur -repositoryPassword mot de passe
- Indique l'ID et le mot de passe pour se connecter à la base de données.
Description des options relatives aux informations de
connexion pour les instructions SQL capturées
A utiliser uniquement avec l'option extract runtimeGroup.
Lors de l'extraction de données pureQuery,
le référentiel contenant les instructions SQL capturées peut se trouver dans une base de données
de référentiel distincte de celle contenant les autres données pureQuery.
La liste suivante décrit les informations de connexion requises
pour se connecter à la base de données d'un référentiel contenant les instructions SQL capturées.
- -incrementalRepositoryURL URL-base de données-référentiel
- Indique l'URL de la base de données du référentiel.
- -incrementalRepositoryUsername ID-utilisateur -incrementalRepositoryPassword mot de passe
- Indique l'ID et le mot de passe pour se connecter à la base de données
du référentiel.
- -incrementalRepositoryDriverClass classe de pilote
- Indique le nom de classe qualifié complet du pilote JDBC à utiliser pour se connecter
à la base de données du référentiel.
Rapport comparant deux fichiers pureQueryXML
L'option
-report pureQueryXMLChanges de ManageRepostiory crée un rapport
HTML des différences entre deux fichiers pureQueryXML.
Vous pouvez créer un rapport qui compare deux versions d'un fichier pureQueryXML. Le rapport contient des informations récapitulatives et détaillées des modifications
entre les deux fichiers. Ce rapport comprend :
- Des informations sur les packages ajoutés, supprimés et modifiés notamment l'ID
version et l'ID collection, l'état de liaison et le nombre d'instructions SQL
ajoutées, supprimées et modifiées.
- Des informations sur les instructions SQL ajoutées, supprimés et modifiés dans
les packages notamment le numéro de section, l'heure de dernière exécution de
l'instruction et le nombre de fois que l'instruction a été exécutée.
Les
fichiers pureQueryXML que l'utilitaire ManageRepository compare doivent se
trouver sur votre système de fichiers. Une connexion à une base de données est
obligatoire.
Syntaxe dé génération d'un rapport de comparaison de
fichiers pureQueryXML

(1)
>>-------java--com.ibm.pdq.tools.ManageRepository--------------->
>-- -report pureQueryXMLChanges--------------------------------->
>-- -oldPureQueryXml--pureQueryXML-file------------------------->
>-- -newPureQueryXml--pureQueryXML-file-- -file--report-file---->
>--| connection information |----------------------------------><
Informations de connexion
|-- -repositoryURL--URL-base de données-référentiel------------->
>-- -repositoryUsername--ID-utilisateur-- -repositoryPassword--mot de passe-->
>-- -repositoryDriverClass--classe de pilote-------------------->
>--+------------------------------------------+-----------------|
| (2) .-IBMPDQ-----. |
'------- -repositorySchema--+-nom_schéma-+-'
Remarques:
- Vous pouvez spécifier les options dans n'importe quel ordre.
- Si l'option -repositorySchema est spécifiée
lors de la création d'un référentiel, l'option doit être spécifiée pour gérer
le référentiel.
Description des options permettant de générer un rapport de
comparaison entre deux fichiers pureQueryXML
La liste suivante décrit les
options et variables ManageRepository qui sont utilisées pour générer le rapport :
- -report pureQueryXMLChanges
- Génère un rapport HTML de comparaison entre deux fichiers pureQueryXML.
- -oldPureQueryXml original-pureQueryXML-file
- Spécifie le nom du fichier pureQueryXML d'origine.
- -newPureQueryXml updated-pureQueryXML-file
- Spécifie le nom du fichier pureQueryXML mis à jour.
- -file file-name
- Spécifie le nom du fichier qui contiendra le rapport.
- -help
- Affiche des informations sur l'utilisation.
Description des options relatives aux informations de
connexion
La liste suivante décrit les informations requises
pour se connecter à la base de données d'un référentiel :
- -repositoryDriverClass classe de pilote
- Indique le nom de classe qualifié complet du pilote JDBC à utiliser pour se connecter
à la base de données du référentiel.
- -repositorySchema nom_schéma
- Le nom de schéma du référentiel. Le nom du schéma par défaut est
IBMPDQ.
Pour plus d'informations sur la spécification d'un nom de schéma pour un référentiel,
voir Remarques sur l'utilisation.
- -repositoryURL URL-base de données-référentiel
- Indique l'URL de la base de données du référentiel.
- -repositoryUsername ID-utilisateur -repositoryPassword mot de passe
- Indique l'ID et le mot de passe pour se connecter à la base de données.
Remarques sur l'utilisation
- Récupération d'informations pureQuery
à partir d'une version de groupe d'exécution de référentiel
- Par défaut, pureQuery Runtime vérifie les mises à jour des informations pureQuery
pour une version de groupe d'exécution après l'activation de la version du groupe
d'exécution lors du démarrage de l'application. Si pureQuery Runtime détecte des mises à jour, pureQuery Runtime récupère les propriétés d'exécution mises à jour et les données pureQueryXML, puis utilise
les informations mises à jour.
Les propriétés pureQuery Runtime
runtimeGroupActivationCheckInterval et
propertiesRefreshInterval contrôlent
le moment où pureQuery Runtime
vérifie les mises à jour des informations pureQuery
pour une version de groupe d'exécution.
- La propriété runtimeGroupActivationCheckInterval contrôle le moment où pureQuery Runtime
vérifie les versions de groupe d'exécution activées. La propriété doit être
définie pour qu'elle s'applique à toutes les instances pureQuery Runtime
qui exécutent une machine virtuelle Java.
- La propriété propertiesRefreshInterval peut
être utilisée pour indiquer un intervalle spécifique pour vérifier les mises les mises à jour apportées aux informations pureQuery pour une
version de groupe d'exécution. La propriété peut également être définie de façon à
désactiver toutes les vérifications d'informations pureQuery
mises à jour pour la version du groupe d'exécution, y compris la vérification qui se produit
lorsqu'une version de groupe d'exécution est activée.
Pour plus d'informations sur les propriétés, voir lapropriété runtimeGroupActivationCheckInterval
et la propriété propertiesRefreshInterval.
- Spécification d'un schéma de référentiel
- Si vous créez un référentiel et que vous spécifiez un nom de schéma, vous devez
spécifier le nom de schéma pour gérer le référentiel.
Vous devez également
spécifier le nom de schéma avec la propriété pureQuery Runtime
repositorySchema lorsque vous utilisez pureQuery Runtime pour récupérer et stocker des données pureQuery. Par exemple,
vous créez un référentiel et vous spécifiez un nom de schéma. Lorsque vous utilisez la propriété pureQuery Runtime finalRepositoryProperties pour
spécifier le référentiel, vous devez également spécifier le schéma avec la propriété pureQuery Runtime repositorySchema.
Un
référentiel créé avec l'option -repositorySchema est
accessible uniquement par les applications Java pureQuery.
- Pool de mémoire tampon et espace table du référentiel
- Les référentiels créés dans une base de données partagent un même pool de mémoire
tampon et un même espace table. Les tables de base de données qui ne contiennent pas
de référentiel ne doivent pas utiliser l'espace table du référentiel.
La suppression d'un référentiel à l'aide de l'option –delete repository
de l'utilitaire ManageRepository ne supprime
pas le pool de mémoire tampon, ni l'espace table du référentiel. L'utilitaire
ManageRepository peut générer les instructions SQL pour supprimer le pool de mémoire
tampon et l'espace table du référentiel. Exécutez l'utilitaire ManageRepository avec les options –delete
repository, -generateScriptOnly et -repositorySchema.
Le fichier de script SQL inclut des commentaires contenant les instructions SQL
pour la suppression du pool de mémoire tampon et de l'espace table.
Pour pureQuery Runtime version 3.1.1 et antérieure,
la suppression du référentiel avec l'utilitaire ManageRepository supprime
le pool de mémoire tampon et l'espace table du référentiel.
- Prise en charge par le référentiel des instructions SQL dynamiques
et statiques
- Les instructions SQL sont utilisées pour accéder à un référentiel et
le manipuler.
Ces instructions peuvent liées de façon statique à la base de données
pour les plateformes prenant en charge les instructions SQL statiques. Les instructions sont émises
de façon dynamique pour les autres plateformes.
Pour les plateformes qui prennent en charge les instructions SQL statiques, la spécification
de l'option -grant privilege et des options -privilege
EXECUTEPACKAGE permet aux applications d'accéder
au référentiel avec des instructions liées de façon statique. Pour les plateformes qui
prennent en charge les instructions SQL statiques, l'utilitaire ManageRepository peut utiliser les
packages liés ou émettre des instructions SQL dynamiques après l'émission
de l'option -bind packages. S'il n'existe pas de packages liés ou que
l'utilisateur ne dispose pas de privilèges d'exécution sur les packages liés, ManageRepository
utilise des instructions SQL dynamiques pour accéder aux tables de base de données du référentiel.
Pour
les plateformes dynamiques, la spécification des options -grant privilege
et -privilege TABLEACCESS permet aux applications
dynamiques d'accéder aux tables de base de données des référentiels sous-jacents.
C'est la seule option disponible pour ces plateformes qui ne prennent pas
en charge les instructions SQL statiques.
- Prise en charge de ManageRepository pour le référentiel InfoSphere Optim Performance Manager
InfoSphere Optim Performance Manager et InfoSphere Optim Performance Manager Extended
Insight peuvent utiliser les données pureQueryXML. L'utilitaire ManageRepository peut télécharger des données pureQueryXML dans un référentiel InfoSphere Optim Performance Manager.
Vous pouvez lancer l'utilitaire ManageRepository pour télécharger
uniquement des données pureQueryXML dans un référentiel InfoSphere Optim Performance Manager.
D'autres données, telles que les propriétés pureQuery Runtime
peuvent ne pas être téléchargées.
Vous pouvez lancer l'utilitaire ManageRepository pour
créer, mettre à jour, supprimer et répertorier des groupes d'exécution dans un référentiel InfoSphere Optim Performance Manager. Les autres commande de
ManageRepository ne sont pas prises en charge.
- Gestion d'un référentiel avec un mécanisme de sécurité DB2 externe
- Lors de la création d'un référentiel, l'utilitaire ManageRepository crée des packages pour gérer ce référentiel. L'utilitaire crée des packages différents en fonction du type de référentiel créé. Si vous utilisez un mécanisme de sécurité DB2 externe pour gérer un référentiel, vous devez accorder les privilèges aux packages dans leur outil de sécurité. La table suivante répertorie le nom du package et les privilèges requis pour le type de référentiel :
Tableau 1. Privilèges requis pour les packages de référentiel lors de la gestion d'un référentiel avec mécanisme de sécurité
DB2 externe| Type de référentiel |
Nom de package de référentiel |
Privilèges de niveau gestionnaire (complets) |
Privilèges de niveau application (restreints) |
| pureQueryRuntimeOnly |
AMDL |
X |
|
| pureQueryRuntimeOnly ou pureQueryOnly |
AMDA |
X |
X |
| pureQueryOnly |
AMD |
X |
|
- Bases de données Oracle
- Sur les bases de données Oracle, vous devez créer un schéma de référentiel avant
de créer le référentiel avec l'option ManageRepository -create repository. Le
schéma par défaut est IBMPDQ. Par exemple, l'exécution de la commande suivante
Oracle SQL*Plus crée un utilisateur et un schéma nommé IBMPDQ sur une base de
données Oracle :
create user IBMPDQ identified by password
Lors
de la création d'un référentiel, tout utilisateur dotés des droits
d'administration de la base de données peut créer un référentiel.
La
commande ManageRepository de l'exemple suivant suppose que l'utilisateur tiger
possède des droits d'administration sur la base de données Oracle TEST et que le
schéma IBMPDQ est créé sur la base de données :
java com.ibm.pdq.tools.ManageRepository
-create repository -repositoryType pureQueryOnly
-repositoryURL jdbc:db2://test.ora.com:17593/test
-repositoryUsername tiger
-repositoryPassword testpwd
-repositoryDriverClass oracle.jdbc.driver.OracleDriver
- Script ManageRepository pour créer un référentiel
- Vous pouvez générer un script de création d'un référentiel en indiquant l'option -generateScriptOnly dans la commande de création d'un référentiel. Vous pouvez personnaliser certains noms d'objet mais d'autres noms d'objet ne peuvent pas être modifiés.
Si vous modifiez les instructions SQL et exécutez le script, vous pouvez utiliser l'option
-verify repository pour vérifier le référentiel.
Si vous utilisez un script personnalisé pour créer un référentiel, vous devez supprimer le référentiel avec un script personnalisé. Vous pouvez créer un script de suppression d'un référentiel en indiquant l'option -generateScriptOnly avec la commande de suppression d'un référentiel. Avant d'exécuter le script, modifiez les noms d'objet qui ont été changés dans le script utilisé pour créer un référentiel.
Vous pouvez modifier les noms des éléments suivants dans le script pour créer un référentiel :
- Le nom de la base de données. Le nom de la base de données est spécifié dans la clause IN
des instructions CREATE TABLESPACE.
- Les noms des espaces table. Les noms d'espace table sont indiqués dans la clause IN des instructions CREATE TABLE.
- L'ID du groupe de stockage. L'ID du groupe de stockage est spécifié dans la
clause USING STOGROUP des instructions CREATE.
- L'ID du pool de mémoire tampon. L'ID du pool de mémoire tampon est indiqué dans les clauses BUFFERPOOL et INDEXBP.
Vous ne pouvez pas modifier les éléments suivants dans le script pour créer un référentiel :
- Les noms de table, les noms de vue et leurs définitions de schéma.
- Le nom de collection et les noms de package ne peuvent pas être modifiés si vous indiquez l'option -bind packages.
La section ci-dessous présente deux méthodes pour exécuter le script :
- Exécutez le script à partir d'un fichier script SQL avec l'éditeur SQL et XQuery
disponible dans IBM Data Studio.
Pour plus d'informations sur l'éditeur SQL et XQuery, voir Utilisation d'instructions SQL.
- Exécutez le script à partir d'un fichier sur la ligne de commande DB2. A partir de la ligne de commande DB2, connectez-vous à la base de données de référentiel et exécutez le script. L'exemple suivant permet de se connecter à la base de données SAMPLE et d'exécuter le script dans le fichier testcreate.sql.
db2 connect to sample
db2 -tvf nomfichier
Pour obtenir des informations sur la ligne de commande DB2, voir
Command line processor (CLP) dans le centre de documentation DB2.
- Exemples de scripts ManageRepository
- Exemple de scripts de ligne de commande qui illustre l'utilisation des commandes ManageRepository incluent dans le répertoire d'installation
de pureQuery Runtime for Linux, UNIX, and Windows.
Exemples
La commande suivante
permet d'établir une connexion avec la base de données à l'aide des informations de connexion
et de créer un référentiel.
java com.ibm.pdq.tools.ManageRepository
-create repository -repositoryType pureQueryOnly
-repositoryURL jdbc:db2://test.user.com:17593/SAMPLE
-repositoryUsername mytestid
-repositoryPassword testpwd
-repositoryDriverClass com.ibm.db2.jcc.DB2Driver
La commande suivante crée une connexion à la base de données et génère un script SQL qui peut créer un référentiel dans la base de données :
java com.ibm.pdq.tools.ManageRepository
-create repository -repositoryType pureQueryOnly
-repositoryURL jdbc:db2://test.user.com:17593/SAMPLE
-repositoryUsername mytestid
-repositoryPassword testpwd
-repositoryDriverClass com.ibm.db2.jcc.DB2Driver
-generateScriptOnly D:\test\scripts\createtest.sql
La
commande suivante permet de supprimer un référentiel :
java com.ibm.pdq.tools.ManageRepository –delete repository
-repositoryURL jdbc:db2://test.user.com:17593/SAMPLE
-repositoryUsername mytestid
-repositoryPassword testpwd
-repositoryDriverClass com.ibm.db2.jcc.DB2Driver
La commande suivante crée
un référentiel dans la base de données. Le référentiel est créé avec le nom de
schéma PDQTEST :
java com.ibm.pdq.tools.ManageRepository
-create repository -repositoryType pureQueryOnly
-repositoryURL jdbc:db2://test.user.com:17593/SAMPLE
-repositoryUsername mytestid
-repositoryPassword testpwd
-repositorySchema PDQTEST
-repositoryDriverClass com.ibm.db2.jcc.DB2Driver
La
commande suivante supprime le référentiel dont le nom de schéma est PDQTEST :
java com.ibm.pdq.tools.ManageRepository –delete repository
-repositoryURL jdbc:db2://test.user.com:17593/SAMPLE
-repositoryUsername mytestid
-repositoryPassword testpwd
-repositorySchema PDQTEST
-repositoryDriverClass com.ibm.db2.jcc.DB2Driver
Remarque : La suppression du référentiel n'entraîne pas la suppression
des espaces table ou des pools de mémoire tampon du référentiel. Vous devez supprimer les espaces table
ou les pools de mémoire tampon du référentiel avec des instructions SQL distinctes.
La
commande suivante crée un script dans le fichier createtest.sql. Les commentaires
du script contiennent des instructions SQL permettant de supprimer le référentiel
et l'espace table.
java com.ibm.pdq.tools.ManageRepository –delete repository
-repositoryURL jdbc:db2://test.user.com:17593/SAMPLE
-repositoryUsername mytestid
-repositoryPassword testpwd
-repositorySchema PDQTEST
-repositoryDriverClass com.ibm.db2.jcc.DB2Driver
-generateScriptOnly createtest.sql