Utilitaire Configure

Avec l'utilitaire Configure de pureQuery, vous pouvez définir plusieurs caractéristiques des packages DB2 que vous avez éventuellement créés pour les instructions SQL dans vos fichiers pureQueryXML. Les caractéristiques que vous pouvez définir incluent la collection, la version et le nom racine des packages DB2. Vous pouvez définir le nombre maximal d'instructions SQL regroupées dans un package. La validation de schéma XML peut également être effectuée au niveau des fichiers pureQueryXML d'entrée.

Les caractéristiques que vous définissez sont ajoutées dans votre fichier pureQueryXML. Lorsque vous exécutez l'utilitaire StaticBinder pour lier les instructions SQL d'un fichier pureQueryXML dans des packages DB2, l'utilitaire StaticBinder lit ces caractéristiques. pureQuery Runtime utilise également des informations du fichier, telles que l'ID collection, l'ID package, l'ID version et le numéro de section lors de l'exécution d'instructions SQL en mode statique.

Remarque : Le fichier pureQueryXML indiqué par l'option -pureQueryXml ne doit pas être un fichier pureQueryXML créé de l'une des manières suivantes :
  • Le fichier a été créé pour capturer des instructions SQL supplémentaires lorsque les deux propriétés outputPureQueryXml et pureQueryXml de pureQuery Runtime ont été indiquées. Lorsque les deux propriétés sont spécifiées, le fichier pureQueryXML indiqué par la propriété outputPureQueryXml contient des instructions SQL capturées qui ne figurent pas dans le fichier pureQueryXML indiqué par la propriété pureQueryXml. Avant d'effectuer la configuration, vous devez fusionner les différents fichiers. Utilisez le fichier spécifié par la propriété pureQueryXml comme fichier de base.
  • Le fichier contient des données SQL capturées qui ont été extraites d'un référentiel et les données pureQueryXML contenues dans la version active du groupe d'exécution. Avant d'effectuer la configuration, vous devez extraire les données pureQueryXML de la version du groupe d'exécution et fusionner les différents fichiers. Utilisez le fichier contenant les données npureQueryXML comme fichier de base.

Cette rubrique contient les sections suivantes :

Pour comprendre les conventions utilisées dans les diagrammes, voir Lecture des diagrammes de syntaxe.

Remarque : Les options de l'utilitaire Configure n'affectent généralement pas toutes les instructions SQL ou tous les ensembles d'instructions dans un fichier pureQueryXML. Lorsque l'utilitaire Configure change un ensemble d'instructions, les instructions SQL dans l'ensemble d'instructions nécessitent généralement une redéfinition des accès avant que les instructions ne puissent être exécutées de manière statique. Pour plus d'informations sur les options qui affectent les ensembles d'instructions, les ensembles d'instructions affectés et la nécessité d'une redéfinition des accès, voir Configurer des options qui nécessitent de redéfinir les accès d'instructions SQL.

Fichiers d'options de l'utilitaire Configure

Le fichier d'options de l'utilitaire Configure répertorie le(s) fichier(s) pureQueryXML que l'utilitaire pureQuery Configure doit traiter, ainsi que les options indiquant aux utilitaires comment traiter les fichiers pureQueryXML. Vous pouvez définir certaines options de l'utilitaire Configure comme options par défaut appliquées à tous les fichiers pureQueryXML répertoriés dans un fichier d'options. Vous pouvez également définir des options d'interfaces afin de remplacer les options par défaut et d'en définir d'autres spécifiques aux fichiers pureQueryXML individuels.

Dans la commande d'exécution de l'utilitaire Configure, vous pouvez indiquer le fichier à utiliser avec l'option -optionsFile.

Par exemple, un fichier d'options simple pour l'utilitaire pureQuery Configure peut se présenter comme suit :
defaultOptions = -collection COLL01
C:\capture_files\capture_sales.pdqxml = -collection NULLID -rootPkgName SALES
C:\capture_files\capture_employee.pdqxml = -collection COLL02 -rootPkgName EMP
C:\capture_files\capture_orders.pdqxml = -rootPkgName ORDERS
Dans cet exemple, la ligne commençant par defaultOptions indique l'ID collection des packages DB2 qui seront créés et dont les accès seront définis. Les deux lignes suivantes suppriment l'ID collection par défaut. Pour les trois fichiers pureQueryXML, l'option obligatoire -rootPkgName indique le nom de package racine des packages DB2.
Vous pouvez également insérer des commentaires dans les fichiers d'options en insérant le symbole # au début de chaque ligne de commentaire. Si ce symbole doit également apparaître dans la valeur de l'une des options, placez la valeur entre guillemets, comme suit :
-pkgVersion "ver#1"
Lorsque vous exécutez l'utilitaire Configure à partir d'une ligne de commande et utilisez un fichier d'options, pureQuery reconnaît les options selon l'ordre de priorité suivant :
  1. Options dans la ligne de commande
  2. Options pour les fichiers pureQueryXML spécifiques dans le fichier d'options indiqué
  3. Options par défaut dans le fichier d'options spécifié

Syntaxe de la commande d'exécution de l'utilitaire Configure sans utiliser un fichier d'options

Si vous disposez d'un seul fichier pureQueryXML, vous pouvez utiliser cette commande afin de spécifier son nom et les options du package DB2.

Lire le diagrammeSauter le diagramme
                                     (1)   
>>-java--com.ibm.pdq.tools.Configure---------------------------->

>--+----------------------------------+------------------------->
   |               .-NULLID---------. |   
   '- -collection--+-nom_collection-+-'   

>--+-----------------------------+------------------------------>
   '- -markDDLForBind--+-TRUE--+-'   
                       '-FALSE-'     

>--+--------------------------------+--------------------------->
   '- -pkgVersion-- -+-AUTO-------+-'   
                     '-ID_version-'     

>-- -rootPkgName--racine_nom_package---------------------------->

>--+--------------------------------------------------------+--->
   '- -allowStaticRowsetCursors--+-READ_ONLY--------------+-'   
                                 +-READ_ONLY_SCROLLABLE---+     
                                 +-READ_ONLY_FORWARD_ONLY-+     
                                 '-NEVER------------------'     

>--+-----------------------------+------------------------------>
   |                   .-FALSE-. |   
   '- -cleanConfigure--+-TRUE--+-'   

>--+---------------------------------------+-------------------->
   |                             .-FALSE-. |   
   '- -forceSingleBindIsolation--+-TRUE--+-'   

>--+-----------------------------------------+------------------>
   |                               .-FALSE-. |   
   '- -groupSQLBySpecialRegisters--+-TRUE--+-'   

>--+-------------------------------------------+---------------->
   |                      .------------------. |   
   |                      |    .-|------.    | |   
   |                      V    V        |    | |   
   '- -groupSQLByStrings----(----chaîne-+--)-+-'   

>--+----------------------------------+------------------------->
   |                       .- -1----. |   
   '- -maxMissingSections--+-nombre-+-'   

>--+---------------------------------------+-------------------->
   '- -removeSQLInactiveForDays----jours---'   

>--+-------------------------------+---------------------------->
   |                     .-FALSE-. |   
   '- -removeInvalidSQL--+-TRUE--+-'   

                                           (2)   
>--+-------------------------------------+---------------------->
   |                           .-FALSE-. |       
   '- -restoreInvalidSQLForce--+-TRUE--+-'       

>--+-----------------------------------------------------------------+-->
   |                        .-----------------------------------.    |   
   |                        V                                   |    |   
   '- -replaceLocations--"----(--nom_origine-->--nouveau_nom--)-+--"-'   

>--+---------------------------------------------------------------+-->
   |                      .-----------------------------------.    |   
   |                      V                                   |    |   
   '- -replaceSchemas--"----(--nom_origine-->--nouveau_nom--)-+--"-'   

>--+--------------------------+--+------------------------+----->
   |                .-FALSE-. |  |             .-100----. |   
   '- -showDetails--+-TRUE--+-'  '- -sqlLimit--+-nombre-+-'   

>--+---------------------------------------+-------------------->
   '- -setPreStatusOfAllPkgs--+-AUTO-----+-'   
                              +-FINAL----+     
                              '-REQUIRED-'     

>--+---------------------------------+-------------------------->
   '- -setPostStatusOfAllPkgs--FINAL-'   

>--+-------------------------------------------------------------+-->
   '- -optionsFileForBind--+-fichier-options-liaison-----------+-'   
                           '-DEFAULT_IN_PUREQUERYXML_DIRECTORY-'     

>--+--------------------------+--+--------------------------+--->
   |                .-FALSE-. |  |                      (3) |   
   '- -validateXml--+-TRUE--+-'  '-| Options de trace |-----'   

>-- -pureQueryXml--fichier_pureQueryXML--+--------+------------><
                                         '- -help-'   

Remarques:
  1. Vous pouvez spécifier les options dans n'importe quel ordre.
  2. Les options -replaceLocations et -replaceSchemas exigent que le fichier JAR pdqsqlparser.jar figure dans le chemin d'accès aux classes. Ces options sont prises en charge avec DB2 for z/OS Version 10 et DB2 for Linux, UNIX, mais aussi avec Windows Version 9.8. Un avertissement est émis si une base de données non prise en charge est détectée.
  3. Pour la syntaxe, voir la description de ces options.

Syntaxe de la commande d'exécution de l'utilitaire Configure avec un fichier d'options

Si vous disposez de plusieurs fichiers pureQueryXML, utilisez la commande et un fichier d'options pour spécifier leurs noms et les options des packages DB2. Vous pouvez utiliser la commande et un fichier d'options même si vous ne disposez que d'un seul fichier pureQueryXML.

Lire le diagrammeSauter le diagramme
>>-java--com.ibm.pdq.tools.Configure---------------------------->

>-- -optionsFile--nom_fichier--+--------------------------+----><
                               |                      (1) |   
                               '-| Options de trace |-----'   

Remarques:
  1. Pour la syntaxe, voir la description de ces options.

Syntaxe permettant de spécifier les options par défaut dans un fichier d'options pour l'utilitaire Configure

Ce diagramme de syntaxe affiche les options par défaut que vous pouvez définir pour tous les fichiers pureQueryXML figurant dans un fichier d'options.

Lire le diagrammeSauter le diagramme
                     (1)   
>>-defaultOptions--=-------------------------------------------->

>--+----------------------------------+------------------------->
   |               .-NULLID---------. |   
   '- -collection--+-nom_collection-+-'   

>--+-----------------------------+------------------------------>
   '- -markDDLForBind--+-TRUE--+-'   
                       '-FALSE-'     

>--+--------------------------------+--------------------------->
   '- -pkgVersion-- -+-AUTO-------+-'   
                     '-ID_version-'     

>--+--------------------------------------------------------+--->
   '- -allowStaticRowsetCursors--+-READ_ONLY--------------+-'   
                                 +-READ_ONLY_SCROLLABLE---+     
                                 +-READ_ONLY_FORWARD_ONLY-+     
                                 '-NEVER------------------'     

>--+---------------------------------------+-------------------->
   |                             .-FALSE-. |   
   '- -forceSingleBindIsolation--+-TRUE--+-'   

>--+-----------------------------------------+------------------>
   |                               .-FALSE-. |   
   '- -groupSQLBySpecialRegisters--+-TRUE--+-'   

>--+-------------------------------------------+---------------->
   |                      .------------------. |   
   |                      |    .-|------.    | |   
   |                      V    V        |    | |   
   '- -groupSQLByStrings----(----chaîne-+--)-+-'   

                                        (2)   
>--+----------------------------------+------------------------->
   |                       .- -1----. |       
   '- -maxMissingSections--+-nombre-+-'       

>--+-----------------------------------------------------------------+-->
   |                        .-----------------------------------.    |   
   |                        V                                   |    |   
   '- -replaceLocations--"----(--nom_origine-->--nouveau_nom--)-+--"-'   

>--+---------------------------------------------------------------+-->
   |                      .-----------------------------------.    |   
   |                      V                                   |    |   
   '- -replaceSchemas--"----(--nom_origine-->--nouveau_nom--)-+--"-'   

>--+---------------------------------------+-------------------->
   '- -removeSQLInactiveForDays----jours---'   

>--+-------------------------------+---------------------------->
   |                     .-FALSE-. |   
   '- -removeInvalidSQL--+-TRUE--+-'   

>--+-------------------------------------+---------------------->
   |                           .-FALSE-. |   
   '- -restoreInvalidSQLForce--+-TRUE--+-'   

>--+--------------------------+--+------------------------+----->
   |                .-FALSE-. |  |             .-100----. |   
   '- -showDetails--+-TRUE--+-'  '- -sqlLimit--+-nombre-+-'   

>--+---------------------------------------+-------------------->
   '- -setPreStatusOfAllPkgs--+-AUTO-----+-'   
                              +-FINAL----+     
                              '-REQUIRED-'     

>--+---------------------------------+-------------------------->
   '- -setPostStatusOfAllPkgs--FINAL-'   

>--+-------------------------------------------------------------+-->
   '- -optionsFileForBind--+-fichier-options-liaison-----------+-'   
                           '-DEFAULT_IN_PUREQUERYXML_DIRECTORY-'     

>--+--------------------------+--+--------------------------+--><
   |                .-FALSE-. |  |                      (3) |   
   '- -validateXml--+-TRUE--+-'  '-| Options de trace |-----'   

Remarques:
  1. Vous pouvez spécifier les options dans n'importe quel ordre.
  2. Les options -replaceLocations et -replaceSchemas exigent que le fichier JAR pdqsqlparser.jar figure dans le chemin d'accès aux classes. Ces options sont prises en charge avec DB2 for z/OS Version 10 et DB2 for Linux, UNIX, mais aussi avec Windows Version 9.8. Un avertissement est émis si une base de données non prise en charge est détectée.
  3. Pour la syntaxe, voir la description de ces options.

Syntaxe permettant de spécifier des options de fichiers pureQueryXML spécifiques dans un fichier d'options pour l'utilitaire Configure

Ce diagramme de syntaxe affiche les options que vous pouvez définir pour chaque fichier pureQueryXML figurant dans un fichier d'options.

Lire le diagrammeSauter le diagramme
                           (1)   
>>-fichier_pureQueryXML--=-------------------------------------->

>--+----------------------------------+------------------------->
   |               .-NULLID---------. |   
   '- -collection--+-nom_collection-+-'   

>--+-----------------------------+------------------------------>
   '- -markDDLForBind--+-TRUE--+-'   
                       '-FALSE-'     

>--+--------------------------------+--------------------------->
   '- -pkgVersion-- -+-AUTO-------+-'   
                     '-ID_version-'     

>-- -rootPkgName--racine_nom_package---------------------------->

>--+--------------------------------------------------------+--->
   '- -allowStaticRowsetCursors--+-READ_ONLY--------------+-'   
                                 +-READ_ONLY_SCROLLABLE---+     
                                 +-READ_ONLY_FORWARD_ONLY-+     
                                 '-NEVER------------------'     

>--+-----------------------------+------------------------------>
   |                   .-FALSE-. |   
   '- -cleanConfigure--+-TRUE--+-'   

>--+---------------------------------------+-------------------->
   |                             .-FALSE-. |   
   '- -forceSingleBindIsolation--+-TRUE--+-'   

>--+-----------------------------------------+------------------>
   |                               .-FALSE-. |   
   '- -groupSQLBySpecialRegisters--+-TRUE--+-'   

>--+-------------------------------------------+---------------->
   |                      .------------------. |   
   |                      |    .-|------.    | |   
   |                      V    V        |    | |   
   '- -groupSQLByStrings----(----chaîne-+--)-+-'   

>--+----------------------------------+------------------------->
   |                       .- -1----. |   
   '- -maxMissingSections--+-nombre-+-'   

>--+---------------------------------------+-------------------->
   '- -removeSQLInactiveForDays----jours---'   

>--+-------------------------------+---------------------------->
   |                     .-FALSE-. |   
   '- -removeInvalidSQL--+-TRUE--+-'   

                                           (2)   
>--+-------------------------------------+---------------------->
   |                           .-FALSE-. |       
   '- -restoreInvalidSQLForce--+-TRUE--+-'       

>--+-----------------------------------------------------------------+-->
   |                        .-----------------------------------.    |   
   |                        V                                   |    |   
   '- -replaceLocations--"----(--nom_origine-->--nouveau_nom--)-+--"-'   

>--+---------------------------------------------------------------+-->
   |                      .-----------------------------------.    |   
   |                      V                                   |    |   
   '- -replaceSchemas--"----(--nom_origine-->--nouveau_nom--)-+--"-'   

>--+--------------------------+--+------------------------+----->
   |                .-FALSE-. |  |             .-100----. |   
   '- -showDetails--+-TRUE--+-'  '- -sqlLimit--+-nombre-+-'   

>--+---------------------------------------+-------------------->
   '- -setPreStatusOfAllPkgs--+-AUTO-----+-'   
                              +-FINAL----+     
                              '-REQUIRED-'     

>--+---------------------------------+-------------------------->
   '- -setPostStatusOfAllPkgs--FINAL-'   

>--+--------------------------+--------------------------------><
   |                .-FALSE-. |   
   '- -validateXml--+-TRUE--+-'   

Remarques:
  1. Vous pouvez spécifier les options dans n'importe quel ordre.
  2. Les options -replaceLocations et -replaceSchemas exigent que le fichier JAR pdqsqlparser.jar figure dans le chemin d'accès aux classes. Ces options sont prises en charge avec DB2 for z/OS Version 10 et DB2 for Linux, UNIX, mais aussi avec Windows Version 9.8. Un avertissement est émis si une base de données non prise en charge est détectée.

Descriptions des options

fichier-pureQueryXML = options
Utilisez ce format dans un fichier d'options afin d'indiquer le nom d'un fichier pureQueryXML et ses options. Le nom de fichier doit apparaître au début de la ligne du fichier. Il doit inclure son chemin d'accès absolu ou relatif. Il doit aussi afficher l'extension .pdqxml ou .xml.
Les options que vous indiquez sur cette ligne viennent remplacer les options que vous indiquez sur la ligne defaultOptions.
-allowStaticRowsetCursors
Utilisez cette option lorsque vous souhaitez qu'il y ait une différence entre les instructions utilisant des curseurs d'ensemble de lignes lors de la capture et les instructions utilisant des curseurs d'ensemble de lignes lors de l'exécution statique. Voici des exemples de situations dans lesquelles cela peut se produire :
  • Vous souhaitez utiliser les curseurs d'ensemble de lignes lors de l'exécution statique, mais vous avez effectué une capture avec une base de données autre que DB2 for z/OS. Par exemple, vous avez effectué la capture à l'aide de DB2 for Linux, UNIX et Windows.
  • Votre environnement de capture a utilisé des curseurs d'ensemble de lignes, mais vous ne souhaitez pas utiliser des ensembles de lignes lors de l'exécution statique,
  • Vous souhaitez utiliser des curseurs d'ensemble de lignes lors de l'exécution statique. Vous avez effectué la capture sur DB2 for z/OS, et vous allez procéder à l'exécution statique sur DB2 for z/OS, mais utiliserez un type de pilote de périphérique différent pour les deux opérations. Par exemple, si vous avez effectué une capture à l'aide d'un pilote IBM® Data Server Driver for JDBC and SQLJ T4, mais procéderez à l'exécution statique avec un pilote IBM Data Server Driver for JDBC and SQLJ T2, vous pouvez souhaiter spécifier l'option "-allowStaticRowsetCursors READ_ONLY". De la même façon, si vous avez effectué la capture à l'aide du pilote IBM Data Server Driver for JDBC and SQLJ T2, mais que vous allez procéder à l'exécution statique avec un pilote IBM Data Server Driver for JDBC and SQLJ T4, vous pouvez souhaiter spécifier "-allowStaticRowsetCursors READ_ONLY_SCROLLABLE".
  • Vous souhaitez utiliser des curseurs d'ensemble de lignes lors de l'exécution statique. Votre fichier de capture a été créé avec une version de pureQuery antérieure à 2.2 ; aucune des instructions y figurant sont marquées comme utilisant des curseurs d'ensemble de lignes.

Seul DB2 for z/OS prend en charge les curseurs d'ensemble de lignes. Les curseurs d'ensemble de lignes sont utilisés uniquement quand les propriétés IBM Data Server Driver for JDBC and SQLJ le requièrent. Si vous effectuez la capture depuis un type de données source différent, ou sans activer les curseurs d'ensemble de lignes, aucune des instructions capturées n'utilise de curseur d'ensemble de lignes.

Lorsque les curseurs d'ensemble de lignes ne sont pas utilisés pour les curseurs de défilement vers l'avant, une connexion de Type 4 peut utiliser de façon interne un mécanisme similaire pour atténuer le trafic réseau.

Cette option prend l'une des quatre valeurs suivantes :

READ_ONLY
Indique que les instructions SELECT ne sélectionnant pas de colonne de type de données LOB ou XML sont autorisées à utiliser les curseurs d'ensemble de lignes (qui ouvrent les curseurs en lecture seule de défilement vers l'avant ou flottants). Les autres instructions SELECT ne sont pas autorisées à utiliser des curseurs d'ensemble de lignes.
Cette option ajoute l'attribut allowStaticRowsetCursors à chaque instruction SELECT du fichier pureQueryXML qui remplit les critères et définit la valeur sur TRUE dans chaque cellule.
READ_ONLY_SCROLLABLE
Indique que les instructions SELECT ouvrant les curseurs de lecture uniquement, flottants et ne sélectionnant aucune colonne de type de données LOB ou XML sont autorisées à utiliser les curseurs d'ensemble de lignes. Les autres instructions SELECT ne sont pas autorisées à utiliser des curseurs d'ensemble de lignes.
Cette option ajoute l'attribut allowStaticRowsetCursors à chaque instruction SELECT du fichier pureQueryXML qui remplit les critères et définit la valeur sur TRUE dans chaque cellule.
READ_ONLY_FORWARD_ONLY
Indique que les instructions SELECT ouvrant les curseurs de lecture uniquement, les curseurs de défilement vers l'avant et ceux ne sélectionnant pas les colonnes de types de données LOB ou XML sont autorisées à utiliser les curseurs d'ensemble de lignes. Les autres instructions SELECT ne sont pas autorisées à utiliser des curseurs d'ensemble de lignes.
Cette option ajoute l'attribut allowStaticRowsetCursors à chaque instruction SELECT du fichier pureQueryXML qui remplit les critères et définit la valeur sur TRUE dans chaque cellule.
NEVER
Indique qu'aucune instruction SELECT n'est autorisée à utiliser les curseurs d'ensemble de lignes.
Cette option ajoute l'attribut allowStaticRowsetCursors à chaque instruction SELECT du fichier pureQueryXML et définit la valeur de chaque cellule sur FALSE. Si vous souhaitez activer les curseurs d'ensemble de lignes pour un sous-ensemble d'instructions SELECT, vous pouvez définir cet attribut sur TRUE dans le plan de travail.

Cette option n'est pas nécessaire si l'une de ces conditions est remplie :

  • Le pilote IBM Data Server Driver for JDBC and SQLJ est défini pour utiliser l'extraction de plusieurs lignes pour les curseurs flottants. Vous avez capturé les instructions SELECT en les exécutant sur un serveur de données DB2 for z/OS et en utilisant une connexion T4. Vous prévoyez d'exécuter les instructions de façon statique sur le même serveur ou un serveur compatible en utilisant une connexion T4.
  • Vous définissez le pilote IBM Data Server Driver for JDBC and SQLJ pour qu'il utilise l'extraction de plusieurs lignes pour les curseurs de défilement vers l'avant et les curseurs flottants. Vous avez capturé les instructions SELECT en les exécutant sur un serveur de données DB2 for z/OS et en utilisant une connexion T2. Vous prévoyez d'exécuter les instructions de façon statique sur le même serveur de données ou sur un serveur compatible en utilisant une connexion T2.
Pour autoriser les instructions SQL à utiliser des curseurs d'ensemble de lignes lorsque pureQurey les exécute de façon statique, les conditions suivantes doivent être remplies :
  • Les instructions capturées doivent être des instructions SELECT.
  • Aucune de ces instructions n'est exécutée par une procédure mémorisée.
  • Aucune des colonnes des résultats de requête ne contiennent des données de type LOB ou XML.
  • Les curseurs ouverts par les instructions sont en lecture seule. Si un curseur statique actualisable utilise des ensembles de lignes, le résultat est imprévisible.

    pureQuery considère qu'une instruction est actualisable si l'une de ces conditions est vraie :

    • L'attribut concurrent est défini sur java.sql.ResultSet.CONCUR_UPDATABLE.
    • L'instruction SQL contient la clause FOR UPDATE.
    pureQuery considère qu'une instruction est en lecture seule si elle n'est pas actualisable.

Si vous exécutez des instructions de façon statique sur une source de données qui ne prend pas en charge les curseurs d'ensemble de ligne, le curseur de ligne n'est utilisé par pureQuery pour aucune instruction.

L'utilitaire Configure désactive les curseurs d'ensembles de lignes quelle que soit l'instruction SQL pour laquelle pureQuery Runtime ne prend pas en charge ces curseurs, même si IBM Data Server Driver for JDBC and SQLJ les ont utilisés pour ces instructions.

Si vous n'indiquez pas cette option et que pureQuery Runtime prend en charge les curseurs d'ensembles de lignes pour l'instruction, pureQuery les utilise pour les instructions que IBM Data Server Driver for JDBC and SQLJ ont employé lors de la capture des instructions.

-cleanConfigure TRUE | FALSE
Indique la portée de l'exécution de l'utilitaire Configure sur un fichier pureQueryXML.
TRUE
Au cours de l'exécution, toutes les instructions SQL sont organisées en des ensembles d'instructions selon les options spécifiées, telles que sqlLimit, groupSQLByString et groupSQLBySpecialRegister. L'utilitaire Configure réorganise les instructions SQL en ensembles d'instructions, si nécessaire.

Pour tous les ensembles d'instructions, l'utilitaire Configure associe l'attribut configureStatus à la valeur AUTO pendant la procédure de configuration. Remplace la valeur FINAL pour l'attribut configureStatut de l'ensemble d'instructions.

FALSE
Les noms et ID collection des ensembles d'instructions sont définis par l'utilitaire Configure dans un fichier pureQueryXML. Les ensembles d'instructions concernés sont ceux dont l'indicateur configureStatus est défini sur REQUIRED ou AUTO, et ceux qui n'ont pas de nom. L'utilitaire Configure modifie les ensembles d'instructions dont l'indicateur configureStatus est défini sur AUTO seulement si l'utilitaire détermine que l'ensemble d'instructions doit être modifié.

FALSE est la valeur par défaut.

Pour les ensembles d'instructions sans nom, la configuration applique toutes les options spécifiées.

Pour les ensembles d'instructions nommés dont l'attribut configureStatus correspond à REQUIRED, certaines options sont appliquées. Les options appliquées comprennent les options -collection, -pkgVersion , -forceSingleBindIsolation et -markDDLForBind. La marque de cohérence est mise à jour. Si vous exécutez des instructions SQL dans l'ensemble d'instructions en mode statique, vous devez relier le package créé à partir de l'ensemble d'instructions.

Pendant la procédure de configuration, l'utilitaire Configure remplace la valeur REQUIRED de configureStatus par AUTO.

Pour les ensembles d'instructions dont l'attribut configureStatus a pour valeur AUTO, l'utilitaire Configure applique les options uniquement s'il détermine que l'ensemble d'instructions doit être modifié. La marque de cohérence n'est pas mise à jour si l'ensemble d'instructions n'est pas modifié. Lorsque l'attribut configureStatus correspond à AUTO et que l'option -pkgVersion est indiquée, l'utilitaire met à jour l'ensemble d'instructions en utilisant l'ID version. Si vous exécutez des instructions SQL de l'ensemble d'instructions de manière statique et que l'ensemble d'instructions a été modifié, vous devez lier une nouvelle fois le package créé à partir de l'ensemble d'instructions.

Pour les ensembles d'instructions nommés dont l'attribut configureStatus correspond à FINAL, l'utilitaire Configure affiche des erreurs lorsque des problèmes liés à l'ensemble d'instructions sont détectés. Les erreurs comprennent des numéros de section en ordre décroissant et des instructions de mise à jour de position non associées à une instruction SELECT. L'utilitaire Configure affiche des avertissements lorsque les instructions doivent être supprimées d'un ensemble d'instructions. Par exemple, une instruction peut être supprimée d'un ensemble d'instructions lorsque l'option -removeSQLInactiveForDays est spécifiée et que l'horodatage de l'instruction correspond aux critères de suppression. Une instruction peut être déplacée vers un autre ensemble d'instructions si les valeurs de registre spécial sont associées aux modifications de l'instruction.

Si l'option -groupSQLBySpecialRegisters est spécifiée, un avertissement est consigné en cas de modification apportée à un attribut du registre spécial. Aucune erreur n'est émise dans ce cas.

-collection nom_collection
Qualificatif des packages pour lesquels l'utilitaire pureQuery StaticBinder définit des accès. Ce qualificatif doit satisfaire aux contraintes applicables aux noms de collection pour la base de données DB2 que vous utilisez.
Si vous ne définissez pas ce paramètre, celui-ci prend la valeur par défaut NULLID.
-forceSingleBindIsolation TRUE | FALSE
Indique si vous prévoyez la création d'un package DB2 pour un niveau d'isolement unique et si vous souhaitez associer un nombre au nom du package pour indiquer son niveau d'isolement. La valeur par défaut est FALSE, ce qui signifie que l'indicateur numérique est attaché.
Utilisez cette option avec l'option -isolationLevel de l'utilitaire StaticBinder.

Si vous souhaitez utiliser l'option -isolationLevel pour définir les accès d'un seul ensemble d'instructions en deux ou trois packages différents (chaque package à un autre niveau d'isolement), n'utilisez pas l'option -forceSingleBindIsolation lorsque vous exécutez l'utilitaire Configure sur le fichier pureQueryXML dans lequel apparaît l'ensemble d'instructions.

Par exemple, dans un fichier d'options pour l'utilitaire StaticBinder, supposez que vous avez inclus les deux entrées suivantes :

C:/dir/captureFile.pdqxml:MYPKGA = -isolationLevel UR
C:/dir/captureFile.pdqxml:MYPKGA = -isolationLevel CS

Si vous avez utilisé l'option -forceSingleBindIsolation lors de l'exécution de l'utilitaire Configure sur le fichier captureFile.pdqxml, l'utilitaire StaticBinder effectue les actions suivantes :

  1. Définition des accès du package MYPKGA au niveau d'isolement UR.
  2. Redéfinition des accès du package MYPKGA au niveau d'isolement CS.

Le résultat est un package MYPKGA unique dont les accès sont définis au niveau d'isolement CS.

Si vous voulez avoir deux packages MYPKGA comme résultat, un au niveau d'isolement UR et l'autre au niveau CS, n'utilisez pas l'option -forceSingleBindIsolation lors de l'exécution de l'utilitaire Configure sur captureFile.pdqxml.

-groupSQLBySpecialRegisters TRUE|FALSE
Indique si les instructions SQL sont regroupées dans des ensembles d'instructions sur la base des valeurs des registres spéciaux enregistrés qui sont associés à l'instruction. La valeur par défaut est FALSE, auquel cas les instructions SQL ne sont pas regroupées sur la base des valeurs de registre spécial. Si la valeur est TRUE, les instructions SQL sont regroupées dans des ensembles d'instructions en fonction des paramètres des registres spéciaux. Toutes les instructions SQL contenues dans le même ensemble d'instructions présentent les mêmes valeurs des registres spéciaux enregistrées lors de leur capture. Les règles suivantes s'appliquent lors de la création d'ensembles d'instructions sur la base de registres spéciaux :
  • Les instructions SQL présentant un seul jeu de valeurs de registre spécial enregistré sont regroupées dans des ensembles d'instructions. Un ensemble d'instructions est créé pour chaque jeu de valeurs de registre spécial enregistré.
  • Les instructions SQL sans registre spécial enregistré sont regroupées dans un même ensemble d'instructions.
  • Les instructions SQL associées à plusieurs ensembles de valeurs des registres spéciaux enregistrés sont regroupées dans un ensemble d'instructions unique. Une instruction SQL peut être associée à plusieurs ensembles de valeurs des registres spéciaux enregistrés si elle a été exécutée plusieurs fois par l'application et que les informations du registre spécial ont été modifiées entre les captures de l'instruction SQL.

Lorsque les options -groupSQLBySpecialRegisters et -groupSQLByStrings sont utilisées pour créer des ensembles d'instructions, les instructions sont d'abord regroupées en fonction des valeurs des registres spéciaux. Pour chaque groupe basé sur des registres spéciaux, les instructions SQL sont regroupées en fonction des valeurs indiquées par l'option -groupSQLByStrings. Une fois le regroupement terminé, le regroupement basé sur l'option -sqlLimit est effectué, si nécessaire. Une fois les ensembles d'instructions créés, ils sont nommés.

Si le fichier pureQueryXML contient une combinaison de packages nommés et non nommés et que l'option -cleanConfigure a pour valeur FALSE, seuls les packages non nommés sont regroupés et le regroupement des packages nommés reste inchangé. Si l'option -cleanConfigure est définie sur TRUE, les instructions SQL dans tous les packages, nommés ou non, sont regroupées.

Si vous exécutez les instructions SQL en mode statique, vous pouvez utiliser les options -groupSQLBySpecialRegisters et -optionsFileForBind pour vous aider à lier les packages à une base de données DB2.

Pour obtenir des informations sur les données du registre spécial enregistrées par pureQuery Runtime, reportez-vous aux liens connexes à la fin de cette rubrique.

-groupSQLByStrings (Chaîne1|Chaîne2|...)...(ChaîneN|ChaîneM|...)
Indique le regroupement d'instructions SQL sur la base de sous-chaînes concordantes en utilisant les chaînes spécifiées par l'option. Si l'option n'est pas indiquée, le regroupement est effectué en fonction d'autres options qui contrôlent le regroupement.

Les chaînes entre parenthèses sont utilisées pour rechercher et regrouper les instructions SQL dans un ensemble d'instructions. Plusieurs chaînes peuvent être utilisées pour affecter une instruction SQL à un ensemble d'instructions en séparant les chaînes par une barre verticale ( | ). Un avertissement est consigné si la même chaîne apparaît plusieurs fois ou si une chaîne est une sous-chaîne d'une autre chaîne.

Une instruction SQL est affectée à un ensemble d'instructions si elle contient la chaîne. Si plusieurs chaînes sont utilisées pour créer un ensemble d'instructions, l'instruction SQL est affectée à l'ensemble d'instructions si elle contient l'une des chaînes.

Lorsque vous créez les ensembles d'instructions, les ensembles sont créés dans l'ordre indiqué par l'option groupSQLByStrings et la recherche des instructions concordantes est effectuée dans cet ordre. Par exemple, si l'option a pour valeur (Table1) (Table2 | Table3), l'utilitaire Configure crée les ensembles d'instructions suivants pour un fichier pureQueryXML :
  • Les instructions SQL contenant la chaîne Table1 sont affectées à un ensemble d'instructions.
  • Les instructions SQL contenant la chaîne Table2 ou Table3 sont affectées à un deuxième ensemble d'instructions.
  • Les instructions SQL ne contenant aucune des chaînes spécifiées sont affectées à un troisième ensemble d'instructions.

Lorsque les options -groupSQLBySpecialRegisters et -groupSQLByStrings sont utilisées pour créer des ensembles d'instructions, les instructions sont d'abord regroupées en fonction des valeurs des registres spéciaux. Dans chaque groupe contenant des registres spéciaux, les instructions SQL sont regroupées en fonction des valeurs spécifiées par l'option -groupSQLByStrings. Une fois le regroupement terminé, l'option -sqlLimit est appliquée si nécessaire et les ensembles d'instructions créés sont nommés.

Si le fichier pureQueryXML contient une combinaison de packages nommés et non nommés et que l'option -cleanConfigure est définie sur FALSE, seuls les packages non nommés sont regroupés et le regroupement des packages nommés reste inchangé. Si l'option -cleanConfigure est définie sur TRUE, les instructions SQL dans tous les packages, nommés ou non, sont regroupées.

Pour obtenir des exemples de regroupement des instructions SQL par chaîne, voir Exemples.

-markDDLForBind
Indique la valeur que l'utilitaire Configure définit pour les attributs isBindable associés à toutes les instructions DDL présentes dans un fichier pureQueryXML. L'utilitaire Configure définit également cette valeur pour l'attribut isBindable dans les ensembles d'instructions ne contenant que des instructions DDL.

Les valeurs correctes sont les chaînes TRUE et FALSE (non sensibles à la casse). Il n'y a pas de valeur par défaut.

TRUE
Lorsque la valeur de isBindable est TRUE, des accès sont définis pour l'instruction DDL ou l'ensemble d'instructions DDL correspondant au moment où l'utilitaire StaticBinder traite le fichier pureQueryXML.
FALSE
Lorsque l'attribut isBindable prend la valeur FALSE, aucun accès n'est défini pour l'instruction DDL correspondante ou pour l'ensemble d'instructions DDL correspondant au moment où l'utilitaire StaticBinder traite le fichier pureQueryXML.

Si vous n'utilisez pas cette option, l'utilitaire Configure vérifie si l'option isBindable est TRUE pour l'une des instructions DDL se trouvant dans des ensembles d'instructions sans nom dans le fichier pureQueryXML. Si l'option isBindable est TRUE pour au moins l'une de ces instructions DDL, lorsque l'utilitaire Configure regroupe les instructions DDL dans un ensemble d'instructions DDL unique et nommé, l'utilitaire définit l'attribut isBindable sur TRUE pour l'ensemble d'instructions DDL.

Lorsque l'utilitaire StaticBinder détecte la valeur TRUE pour l'attribut isBindable des ensembles d'instructions, il tente de lier les instructions dont l'attribut isBindable a pour valeur TRUE dans cet ensemble.

-optionsFile nom_fichier
Nom du fichier, chemin absolu ou relatif inclus, qui répertorie les fichiers pureQueryXML que vous voulez modifier avec des métadonnées pour l'utilitaire pureQuery StaticBinder.
-maxMissingSections nombre
Indique le moment où l'utilitaire Configure supprime les écarts inutiles entre des numéros de section d'un jeu d'instructions. Les numéros de section sont attribués à des instructions SQL. Lorsque l'utilitaire pureQuery StaticBinder lie le fichier pureQueryXML, les écarts inutiles entre les numéros de section deviennent des trous de section non utilisés dans les packages DB2 créés par l'opération de liaison.

La valeur nombre indique le nombre maximum d'écarts inutiles autorisés dans un jeu d'instructions avant que l'utilitaire Configure ne réattribue les numéros de section. La valeur nombre peut être un nombre entier de valeur -1 ou supérieure. Avec la valeur par défaut -1, l'utilitaire Configure ne réattribue par les numéros de section. Par exemple, si la valeur de nombre est 0 (zéro) ou 1, tous les écarts inutiles entre les numéros de section sont supprimés.

L'utilitaire Configure réattribue les numéros de section uniquement sur des ensemble d'instructions nommés et dont l'attribut configureStatus n'est pas défini sur FINAL.

Lorsque vous utilisez l'option -removeInvalidSQL ou l'option -removeSQLInactiveForDays, certaines instructions SQL peuvent être supprimées des ensembles d'instructions. L'utilitaire Configure ne réattribue pas automatiquement les numéros de section des instructions SQL restantes. Pour que les numéros de section soient réattribués, les packages de bases de données correspondants doivent être reliés.

Si vous indiquez l'option -removeInvalidSQL ou l'option -removeSQLInactiveForDays avec l'option -maxMissingSections, les instructions SQL sont supprimées avant que les numéros de section ne soient réattribués.

-optionsFileForBind fichier_options_liaison|DEFAULT_IN_PUREQUERYXML_DIRECTORY
Indique que l'utilitaire Configure génère un fichier d'options StaticBinder. Le fichier d'options contient des options de liaison et d'autres informations reposant sur les instructions SQL, les ensembles d'instructions et des informations du registre spécial DB2 figurant dans les fichiers pureQueryXML. Si le fichier existe, il est remplacé par le nouveau fichier.
Cette option utilise les valeurs suivantes :
fichier-options-liaison
Indique le nom du fichier avec son chemin absolu ou relatif.
DEFAULT_IN_PUREQUERYXML_DIRECTORY
Indique que le fichier observed.bindProps est créé dans le répertoire contenant le fichier pureQueryXML.

Si cette valeur est indiquée sur la ligne defaultOptions d'un fichier d'options de l'utilitaire Configure, tous les fichiers pureQueryXML indiqués dans le fichier doivent être stockés dans le même répertoire.

Les options de liaison et les autres informations du fichier vous aident à indiquer un ensemble d'options de liaison pour exécuter une instruction SQL en mode statique en obtenant un comportement comparable à celui obtenu avec une exécution dynamique lancée à partir de l'application. Vous pouvez utiliser les options de liaison avec l'utilitaire pureQuery StaticBinder pour créer des packages dans une base de données DB2 et lier les packages à la base de données.

Le fichier d'options StaticBinder contient les types d'information suivants pour les ensembles d'instructions et les instructions SQL du fichier pureQueryXML :
  • Options de liaison des ensembles d'instructions.
  • Informations et avertissements pour les instructions SQL et les ensembles d'instructions.

    L'utilitaire Configure ajoute des commentaires avec des informations sur les ensembles d'instructions et les ensembles de valeurs des registres spéciaux référencés dans le fichier.

    L'utilitaire Configure ajoute l'option -configureWarning de l'utilitaire StaticBinder avec des avertissements. Les avertissements indiquent pourquoi les instructions SQL risquent de ne pas se comporter comme prévu lors de leur exécution en mode statique, une fois que les packages sont liés à la base de données à partir de l'ensemble d'instructions.

Pour plus d'informations sur le fichier d'options StaticBinder créé par l'utilitaire Configure et les données du registre spécial enregistrées lors de la capture des instructions SQL, reportez-vous aux liens connexes à la fin de cette rubrique.

-pkgVersion AUTO|ID_version
Indique la version du package à utiliser lorsque la définition d'accès est effectuée.

DB2 accepte la présence simultanée de plusieurs versions d'un même package, ce qui vous permet de définir les accès des nouveaux packages sans devoir remplacer les anciennes versions des packages portant un nom identique. Si vous rencontrez des difficultés avec une version récente d'un package, vous pouvez toujours utiliser une version plus ancienne de ce package.

L'utilitaire Configure crée une copie du fichier pureQueryXML en ajoutant l'ID version au nom de ce fichier.

AUTO
Indique que l'ID version doit être généré automatiquement en utilisant l'horodatage en cours. Un horodatage unique est utilisé pour l'ID version.
ID_version
Indique l'identificateur de version d'un package. La chaîne entrée doit être valide pour la version de DB2 que vous utilisez.

L'ID version ne doit inclure que des caractères valides pour les noms de fichier sur votre système d'exploitation. Par ailleurs, la chaîne et le nom du package ne peuvent pas dépasser la longueur acceptée par votre système d'exploitation pour les noms de fichier.

Si vous indiquez cette option et que l'utilitaire Configure ne modifie pas le fichier pureQueryXML, l'utilitaire ne crée pas de copie du fichier pureQueryXML.

Si vous n'indiquez pas cette option, les packages de base de données provenant de liaisons ultérieures sont créés sans version et la copie du fichier n'est pas créée.

La vérification de la version au moment de l'exécution est basée sur la marque de cohérence, et non pas sur le nom de la version.

-pureQueryXml fichier_pureQueryXML
Nom du fichier pureQueryXML. Ce fichier doit avoir l'extension .pdqxml ou .xml. Vous devez indiquer le chemin complet ou relatif du fichier.
-removeSQLInactiveForDays jours
Indique le nombre de jours qui doivent s'écouler avant qu'une instruction SQL non utilisée soit supprimée, sur la base de l'horodatage correspondant à la dernière utilisation de l'instruction. Si la variable jours est définie sur 0, toutes les instructions SQL sont écrites dans le fichier de sortie. Par défaut, toutes les instructions SQL sont écrites dans le fichier de sortie. Si la valeur de la variable jours est un nombre positif, l'utilitaire Configure n'écrit pas d'instructions SQL dans le fichier de sortie si la date de dernière utilisation de l'instruction correspond à la date en cours ou date antérieure moins ce nombre de jours. Si la variable jours est définie sur 1, les instructions SQL ne sont pas écrites si leur dernière utilisation date du jour précédent ou est antérieure.

Par exemple, si la variable jours est définie sur 5 et que nous sommes le 25 novembre, les instructions SQL datées du 20 novembre et antérieures au 20 novembre ne sont pas écrites.

L'horodatage est mis à jour lorsque pureQuery Runtime capture l'instruction SQL ou lors de l'exécution de l'utilitaire Merge avec des fichiers de capture incrémentielle.

Si l'instruction SQL n'est pas horodatée, elle est écrite dans le fichier de sortie. Par exemple, un fichier pureQueryXML d'une version antérieure risque de ne pas avoir d'horodatage. Si vous configurez un fichier pureQueryXML qui ne possède pas d'horodatage (version 3 ou précédente), l'option est ignorée, toutes les instructions SQL sont placées dans le fichier de sortie et un message est affiché.

Un message est consigné dans le fichier journal pour les instructions SQL qui ne sont pas écrites dans le fichier de sortie pureQueryXML. Si l'option -showDetails est définie sur true, toutes les instructions non écrites dans le fichier de sortie s'affichent.

-replaceLocations "(nom_origine1>nouveau_nom1 ) ... (nom_origineN>nouveau_nomN )"
Indique le remplacement de noms d'emplacement existants de la base de données dans le fichier pureQuery par les nouveaux noms d'emplacement. Le nom existant est séparé du nouveau nom par un crochet droit (>). Chaque paire de noms d'emplacements est placée entre parenthèses. La liste de remplacement est placée entre des guillemets doubles ("). Ces derniers, utilisés pour délimiter un nom, doivent être précédés d'un caractère \. L'exemple d'option suivant remplace deux noms d'emplacement de bases de données :
-replaceLocations "(SAMPLE > SAMPLE1) (STLEC1 > STLEC2)"
L'exemple suivant utilise des guillemets doubles :
-replaceLocations "(\"test1\">\"prod1\")"

Le remplacement de nom est un processus exécuté en une seule fois. Par exemple, si vous indiquez la chaîne de remplacement "(S1>S2) (S2>S3)", les occurrences de S1 sont remplacées par S2 et les occurrences d'origine de S2 sont remplacées par S3. L'utilitaire Configure ne remplace pas S1 par S2 en une seule fois, puis il remplace S2 par S3 dans une autre opération. Pour obtenir des exemples de remplacement de nom, consultez l'exemple disponible à la fin de cette rubrique.

Cette option est uniquement prise en charge pour DB2 for z/OS Version 10 et DB2 for Linux, UNIX et Windows Version 9.8. L'utilitaire Configure n'empêche pas le remplacement d'un nom d'emplacement par d'autres versions des bases de données prises en charge. Il affiche un avertissement lorsque vous indiquez un fichier pureQueryXML utilisé avec des versions ultérieures de la base de données. En ce qui concerne les versions antérieures de la base de données, aucun avertissement n'est affiché. L'utilitaire Configure détermine la base de données et la version à partir des informations figurant dans le fichier pureQueryXML.

Avant d'utiliser l'utilitaire Configure avec l'option -replaceLocations, le fichier JAR pdqsqlparser.jar doit être ajouté à votre chemin d'accès aux classes. Le fichier JAR se trouve dans le répertoire d'installation lib/sqlparser de pureQuery Runtime.

La valeur de l'attribut configureStatus influe sur la manière dont l'utilitaire Configure traite les ensembles d'instructions concernés par l'option -replaceLocations.
  • Si la valeur de configureStatus affiche REQUIRED, les valeurs des noms sont rétablies sur celles spécifiées par l'option de remplacement. La marque de cohérence de l'ensemble des instructions est mise à jour.
  • Si la valeur de configureStatus affiche AUTO, les valeurs des noms sont rétablies sur celles spécifiées par les options de remplacement. La marque de cohérence de l'ensemble des instructions est mise à jour à condition qu'un nom soit remplacé.
  • Si la valeur de configureStatus affiche FINAL, les noms ne sont pas changés. L'utilitaire Configure imprime un message indiquant que l'utilitaire n'a pas changé l'emplacement de la base de données ou le nom d'un schéma pour une instruction SQL car la valeur de configureStatus affiche FINAL pour l'ensemble d'instructions contenant l'instruction.
La valeur des options -cleanConfigure et -setPreStatusOfAllPkgs affecte le remplacement des noms.
  • Si la valeur true est attribuée à cleanConfigure, la valeur de setPreStatusOfAllPkgs est ignorée et le remplacement est exécuté avec les valeurs des options -replaceLocations et -replaceSchemas.
  • Si l'option -cleanConfigure est définie sur False, le remplacement est effectué uniquement pour les ensembles d'instructions dont l'option configureStatus affiche les valeurs REQUIRED et AUTO. La définition de la valeur -setPreStatusOfAllPkgs sur FINAL va empêcher l'exécution du remplacement dans ces ensembles d'instructions nommés. Toutefois, les identificateurs de tous les ensembles d'instructions sans noms sont normalement remplacés.

Les valeurs des autres options n'ont aucun effet sur les options -replaceLocations et -replaceSchemas. Le remplacement des noms est effectué avant d'appliquer d'autres options, sauf -cleanConfigure et -setPreStatusOfAllPkgs.

-replaceSchemas "(nom_origine1>nouveau_nom1 ) ... (nom_origineN>nouveau_nomN )"
Indique le remplacement de noms de schéma existants dans le fichier pureQuery par les nouveaux noms de schéma. Le nom existant est séparé du nouveau nom par un crochet droit (>). Chaque paire de noms de schéma est placée entre parenthèses. La liste de remplacement est placée entre des guillemets doubles ("). Ces derniers, utilisés pour délimiter un nom, doivent être précédés d'un caractère \. L'exemple d'option suivant remplace deux noms de schéma :
-replaceSchemas "(MYSCH1 > MYSCH2) (MYSCH3 > MYSCH4)"
L'exemple suivant utilise des guillemets doubles :
-replaceSchemas "(\"schmTest\">\"schmProd\")"

Le remplacement de nom est un processus exécuté en une seule fois. Par exemple, si vous indiquez la chaîne de remplacement "(S1>S2) (S2>S3)", les occurrences de S1 sont remplacées par S2 et les occurrences d'origine de S2 sont remplacées par S3. L'utilitaire Configure ne remplace pas S1 par S2 en une seule fois, puis il remplace S2 par S3 dans une autre opération. Pour obtenir des exemples de remplacement de nom, consultez l'exemple disponible à la fin de cette rubrique.

Cette option est uniquement prise en charge pour DB2 for z/OS Version 10 et DB2 for Linux, UNIX et Windows Version 9.8. L'utilitaire Configure n'empêche pas le remplacement d'un nom de schéma par d'autres versions des bases de données prises en charge. Il affiche un avertissement lorsque vous indiquez un fichier pureQueryXML utilisé avec des versions ultérieures de la base de données. En ce qui concerne les versions antérieures de la base de données, aucun avertissement n'est affiché. L'utilitaire Configure détermine la base de données et la version à partir des informations figurant dans le fichier pureQueryXML.

Avant d'utiliser l'utilitaire Configure avec l'option -replaceSchemas, le fichier JAR pdqsqlparser.jar doit être ajouté à votre chemin d'accès aux classes. Le fichier JAR se trouve dans le répertoire d'installation lib/sqlparser de pureQuery Runtime.

Pour plus d'informations sur les effets de la valeur de l'attribut configureStatus et les options -cleanConfigure et -setPreStatusOfAllPkgs, reportez-vous à l'option -replaceLocations.

-removeInvalidSQL TRUE|FALSE
Indique si l'utilitaire Configure supprime les instructions SQL marquées comme non valides dans le fichier pureQueryXML.

Les valeurs valides sont TRUE et FALSE. Si la valeur par défaut FALSE est définie, les instructions SQL non valides ne sont pas supprimées du fichier pureQueryXML file.

TRUE
L'utilitaire Configure supprime les instructions SQL marquées comme non valides dans le fichier pureQueryXML.

Si la valeur de l'attribut configureStatus de l'ensemble d'instructions est FINAL, les instructions SQL non valides de l'ensemble d'instructions ne sont pas supprimées. Un message d'avertissement s'affiche.

Une erreur s'affiche si vous indiquez également l'option -restoreInvalidSQLForce avec la valeur TRUE.

FALSE
Si la valeur est FALSE ou si l'option n'est pas indiquée, aucune action n'est entreprise sur des instructions SQL marquées comme non valides dans le fichier pureQueryXML.

Pour obtenir des informations sur les instructions SQL marquées comme non valides, reportez-vous à l'option -statementBindError de l'utilitaire pureQuery StaticBinder.

-restoreInvalidSQLForce TRUE|FALSE
Indique si l'utilitaire de configuration restaure les instructions SQL marquées comme non valides dans un fichier pureQueryXML. Une fois les instructions SQL restaurées, elles peuvent être utilisées avec pureQuery Runtime. Utilisez cette option pour restaurer des instructions SQL marquées par erreur comme non valides.

Les valeurs valides sont TRUE et FALSE. La valeur par défaut est FALSE et indique que les instructions SQL marquées comme non valides ne sont pas restaurées.

TRUE
L'utilitaire Configure restaure les instructions SQL non valides pour une utilisation normale dans pureQuery Runtime.

Une erreur s'affiche si vous indiquez également l'option -removeInvalidSQL avec la valeur TRUE.

Remarque : L'utilitaire Configure restaure les instructions SQL dans un ensemble d'instructions même si l'attribut configureStatus de l'ensemble est FINAL.
FALSE
Si la valeur est FALSE ou si l'option n'est pas spécifiée, aucune modification n'est apportée aux instructions SQL.

Lors de la restauration d'instructions SQL non valides, l'utilitaire Configure met à jour les instructions SQL non valides pour qu'elles ne soient plus marquées comme non valides. L'utilitaire Configure procède également à d'autres modifications dans le fichier pureQueryXML pour que pureQuery Runtime reconnaisse les instructions SQL comme valides. Par exemple, des numéros de section sont attribués aux instructions SQL.

Pour obtenir des informations sur les instructions SQL marquées comme non valides, reportez-vos à l'option -statementBindError de l'utilitaire pureQuery StaticBinder.

-rootPkgName racine_nom_package
Indique la racine du nom à utiliser pour les packages DB2. Pour tout détail concernant la façon dont l'utilitaire Configure crée les noms des packages DB2, voir la description donnée pour sqlLimit.

La valeur racine_nom_package doit respecter les contraintes imposées par la base de données DB2 que vous utilisez.

Si vous prévoyez de générer des fichiers DBRM avec l'utilitaire pureQuery StaticBinder plutôt que de créer des packages DB2, vous devez utiliser des majuscules pour la valeur racine_nom_package et cette valeur ne doit pas comporter plus de 6 caractères. L'utilitaire Configure ajoute des caractères à la racine du nom soit lorsque le fichier pureQueryXml contient des instructions DDL, soit lorsque le nombre maximal d'instructions par package (défini avec sqlLimit) est atteint. Si vous utilisez l'utilitaire StaticBinder pour générer un fichier DBRM, cet utilitaire émet une exception dès lors que vous dépassez un total de 8 caractères pour la combinaison racine_nom_package / caractères supplémentaires consécutifs à l'intervention de l'utilitaire Configure / niveau d'isolement.

-setPreStatusOfAllPkgs AUTO|FINAL|REQUIRED
Indique l'état d'un package. L'utilitaire Configure affecte l'état indiqué à tous les ensembles d'instructions avant de les traiter. La valeur peut être définie sur AUTO, FINAL ou REQUIRED.
Si l'option -cleanConfigure est définie sur FALSE ou n'est pas définie, le traitement suivant est appliqué lorsqu'une valeur -setPreStatusOfAllPkgs est spécifiée :
  • AUTO : les instructions non nommées sont configurées selon la procédure standard. Les ensembles nommés sont validés et configurés uniquement si cela s'avère nécessaire.
  • FINAL: affecte l'état FINAL à tous les ensembles d'instructions nommés. L'état des packages non nommés est ignoré et le package est configuré. Les ensembles d'instructions nommés sont validés et les avertissements sont affichés.
  • REQUIRED : pour les packages non nommés, il s'agit de la valeur par défaut. Pour les ensembles d'instructions nommés, une configuration est effectuée et les nouvelles valeurs indiquées pour les options -collection, -forceSingleBindIsolation, -markDDLForBind, pkgVersion et -allowStaticRowsetCursors sont appliquées aux packages nommés.

Si l'option -cleanConfigure est définie sur TRUE, l'option -setPreStatusOfAllPkgs est ignorée. Aucun message n'est consigné.

-setPostStatusOfAllPkgs FINAL
Indique qu'après le traitement, l'utilitaire Configure définit le statut de tous les ensembles d'instruction sur FINAL dans le fichier de sortie pureQueryXML.
Si la valeur de l'option -setPostStatusOfAllPkgs est FINAL, les événements suivants se produisent :
  • Si l'option -cleanConfigure est définie sur FALSE ou n'est pas spécifiée, tous les ensembles d'instructions non nommés sont configurés, tous les ensembles d'instructions sont validés et configurés en fonction des besoins et le statut de tous les packages est défini sur FINAL.
  • Si l'option -cleanConfigure est définie sur TRUE, configurez toutes les instructions SQL et définissez le statut de tous les ensembles d'instructions sur FINAL.
-showDetails TRUE|FALSE
Indique si l'utilitaire Configure doit afficher un récapitulatif de ses activités. La valeur par défaut est FALSE.
-sqlLimit nombre
Indique le nombre maximal d'instructions SQL autorisées dans le package DB2. En règle générale, si le nombre d'instructions SQL dépasse cette limite, l'utilitaire pureQuery StaticBinder lie un autre package dans lequel viennent se placer les instructions excédentaires. Dans certains cas toutefois, le nombre d'instructions SQL que l'utilitaire StaticBinder place dans un package est légèrement supérieur à la limite.

Cette valeur par défaut est 100.

Par exemple, supposons que vous vouliez lier quatre packages (un package pour chacun des quatre niveaux d'isolement) avec le nom racine monPackage et que la base de données prenne en charge les noms de package longs. Si le fichier pureQueryXML que vous utilisez contient entre 101 et 199 instructions et si vous conservez la valeur par défaut de sqlLimit, l'opération de définition d'accès va générer les packages suivants :
Tableau 1. Tableau des packages
  Package avec les 100 premières instructions SQL Package avec les n instructions SQL suivantes, où 100 < n < 200
Niveau d'isolement CS monPackageA1 monPackageB1
Niveau d'isolement RR monPackageA2 monPackageB2
Niveau d'isolement RS monPackageA3 monPackageB3
Niveau d'isolement UR monPackageA4 monPackageB4

Les chiffres représentent le niveau d'isolement des packages, cependant que les lettres représentent le nombre de packages créés selon la valeur de sqlLimit et le nombre d'instructions présentes dans le fichier pureQueryXML. Les lettres sont celles de l'alphabet anglais, de A à Z. Si la lettre Z est atteinte alors qu'il reste des packages à créer, une deuxième lettre est ajoutée à la première, ce qui donne AA, AB, AC, etc. Si les noms deviennent trop longs pour votre base de données, réduisez la longueur du nom racine du package ou augmentez la valeur de sqlLimit. Vous pouvez également utiliser l'option -forceSingleBindIsolation pour supprimer le nombre indiquant le niveau d'isolement, si vous prévoyez de créer un package pour un niveau d'isolement unique.

Dans certaines situations, l'utilitaire Configure dépasse la limite de l'instruction SQL lors de la création d'ensembles d'instructions représentant les packages DB2. Toutes les instructions SQL qui manipulent un curseur doivent se trouver dans le package contenant l'instruction DECLARE CURSOR pour ce curseur. Par exemple, si une application exécute quinze instructions UPDATE différentes qui se réfèrent au même curseur, ces quinze instructions doivent toutes se trouver dans le package DB2 contenant l'instruction DECLARE CURSOR pour ce curseur.

Pour que votre application maintienne des performances optimales, n'indiquez pas de valeur supérieure à 400 pour sqlLimit.

Options de trace
Vous pouvez demander à ce que le fichier journalise les messages et préciser le niveau d'information à journaliser.
Lire le diagrammeSauter le diagramme
>>-+--------------------------+--------------------------------->
   '- -traceFile--nom_fichier-'   

>--+---------------------------+-------------------------------><
   |               .-OFF-----. |   
   '- -traceLevel--+-ALL-----+-'   
                   +-SEVERE--+     
                   +-WARNING-+     
                   +-INFO----+     
                   +-CONFIG--+     
                   +-FINE----+     
                   +-FINER---+     
                   '-FINEST--'     

-traceFile nom_fichier
Indique le chemin absolu ou relatif ainsi que le nom du fichier à utiliser pour la journalisation des informations relatives à l'opération.
Si le fichier existe déjà, pureQuery ajoute les nouveaux messages à la suite des messages déjà placés dans ce fichier. Par défaut, les entrées sont écrites dans System.err.
-traceLevel OFF|SEVERE|WARNING|INFO|CONFIG|FINE|FINER|FINEST|ALL
Indique le type d'informations à journaliser. Le niveau par défaut est OFF. Si vous ne spécifiez pas de fichier dans lequel écrire les entrées de journal et que vous associez cette option à une valeur autre qu'OFF, les entrées sont écrites dans System.err.
-validateXml TRUE|FALSE
Indique si la validation de schéma XML est effectuée dans les fichiers pureQueryXML en entrée à l'aide du schéma pureQueryXML. Si la valeur est définie sur TRUE, la validation est effectuée. Si la valeur est définie sur FALSE ou si l'option n'est pas définie, la validation n'est pas effectuée. La valeur par défaut est FALSE.

Le succès ou l'échec de la validation de schéma XML est déterminé et signalé pour chaque fichier en entrée. Si un fichier en entrée échoue, le traitement de configuration ne s'arrête pas et les fichiers suivants sont traités.

En cas d'échec de la validation de schéma par un fichier pureQueryXML, la configuration du fichier ne s'achève pas. La première erreur de validation de schéma et l'échec de la configuration du fichier sont signalés.

Seule l'édition actuelle ou la version précédente des fichiers pureQueryXML est validée (version 4 ou 3). En cas de détection d'une version antérieure du fichier pureQueryXML, la validation n'est pas appliquée à ce fichier.

Les erreurs de validation sont imprimées en tant que résultats de l'utilitaire Configure.

-help
Affiche des informations sur l'utilisation.
Non valide dans un fichier d'options.

Sortie de l'utilitaire Configure

L'utilitaire Configure génère entre 1 et 4 fichiers supplémentaires pour chaque fichier pureQueryXML mis à jour.
  • Le premier fichier généré, que l'utilitaire Configure produit toujours, est une copie du fichier pureQueryXML que vous avez fourni. Si le nom du fichier pureQueryXML est sampleJDBC.pdqxml, la copie est sampleJDBC.pdqxml.org, où "org" est une abréviation de "original".
  • Le deuxième fichier est généré si vous spécifiez un ID version avec l'option pkgVersion lors de l'exécution de l'utilitaire Configure. Si l'utilitaire Configure modifie le fichier, il ajoute l'ID version au nom d'une copie du fichier pureQueryXML. Par exemple, -pkgVersion Ver1.0 -pureQueryXml sampleJDBC.pdqxml génère un fichier appelé sampleJDBC.pdqxml_Ver1.0. Si l'utilitaire Configure ne modifie pas le fichier, il ne crée pas de copie du fichier avec l'ID version.
    Vous pouvez utiliser la gestion des versions si vous souhaitez pouvoir basculer vers des versions antérieures des packages DB2 associés à votre application. Par exemple, supposons que vous disposiez de trois fichiers pureQueryXML :
    • sampleJDBC.pdqxml et sampleJDBC.pdqxml_3.0, qui sont identiques.
    • sampleJDBC.pdqxml_2.5
    • sampleJDBC.pdqxml_2.0
    Vous disposez également des packages DB2 correspondants qui utilisent les mêmes numéros de version. Après l'exécution de votre application avec la dernière version du package DB2 (version 3.0), vous pouvez rétablir le package précédent (version 2.5). Vous remplacez le fichier sampleJDBC.pdqxml en cours par une copie de sampleJDBC.pdqxml_2.5, puis exécutez votre application. Ensuite, si vous souhaitez rétablir la version 3.0 de votre package DB2, il vous suffit de remplacer sampleJDBC.pdqxml par une copie de sampleJDBC.pdqxml_3.0.
  • Le troisième fichier est généré si le fichier pureQueryXML contient des instructions DDL. A l'exception des instructions DECLARE GLOBAL TEMPORARY TABLE, l'utilitaire Configure copie toutes les instructions DDL du fichier pureQueryXML dans un fichier texte .ddl. Ce fichier permet à un administrateur de base de données d'exécuter les instructions sur le SGBD cible avant de lier les instructions DML qui référencent ces instructions DDL. Les objets de base de données que les instructions DDL créent ou modifient doivent être présentes, de manière à pouvoir lier les instructions DML qui référencent ces objets. Vous pouvez éditer ce fichier .ddl. Par exemple, si le fichier contient des instructions DROP après une instruction CREATE TABLE ou CREATE VIEW correspondante, les instructions DROP doivent être supprimées.
  • Le quatrième fichier est généré si vous indiquez l'option -optionsFileForBind. L'utilitaire Configure génère un fichier d'options qui contient des options de liaison DB2. L'utilitaire Configure ajoute également des commentaires qui contiennent des avertissements et d'autres informations sur le contenu du fichier. Les options de liaison peuvent être utilisées avec le programme pureQuery StaticBinder.

Pour connaître les mises à jour que l'utilitaire Configure apporte à un fichier pureQueryXML, vous pouvez ouvrir ce fichier dans un éditeur.

Vous pouvez capturer davantage d'instructions SQL dans un fichier pureQueryXML déjà traité avec l'utilitaire Configure. Lorsque vous exécutez l'utilitaire Configure pour traiter les nouvelles instructions SQL dans le fichier pureQueryXML, la spécification de l'option -cleanConfigure détermine le mode de traitement des instructions et des ensembles d'instructions SQL existants :
  • Si l'option -cleanConfigure applique sa valeur par défaut, l'utilitaire Configure tente de conserver le contenu des ensembles d'instructions existants, préalablement configurés et liés, dans le fichier pureQueryXML. Un message s'affiche lorsque les informations ne peuvent pas être préservées.

    Utilisez ce paramètre pour continuer à utiliser les packages DB2 créés à partir des instructions SQL dans le fichier pureQueryXML.

  • Lorsque l'option -cleanConfigure a pour valeur TRUE, l'utilitaire Configure ne conserve pas les informations relatives aux ensembles d'instructions.

Attribut XML isBindable dans le fichier pureQueryXML

Le fichier pureQueryXML est un fichier XML qui contient les instructions SQL et les informations connexes capturées par pureQuery Runtime. Dans le fichier, les instructions SQL sont regroupées dans un ou plusieurs ensembles d'instructions. L'attribut XML isBindable est un attribut d'ensembles d'instructions et d'instructions SQL spécifiques. L'attribut isBindable détermine si une instruction SQL est exécutée en mode statique dans une base de données DB2. La valeur de l'attribut peut être true ou false et détermine les actions suivantes :
  • Indique si une opération de liaison doit être effectuée. Lorsque vous exécutez l'utilitaire StaticBinder pour lier des packages à une base de données DB2, l'utilitaire utilise la valeur de l'attribut isBindable pour déterminer si les packages doivent être liés à l'instruction SQL ou à un ensemble d'instructions.
    • Si la valeur est true pour l'ensemble d'instructions, StaticBinder effectue l'opération de liaison.
    • Si la valeur est false pour l'ensemble d'instructions, l'opération n'est pas effectuée.
    • Si la valeur est true pour l'ensemble d'instructions et false pour une instruction SQL, l'opération de liaison est effectuée mais l'instruction est exclue.
  • Indique si l'instruction SQL doit être exécutée en mode statique. Lorsque la valeur de la propriété executionMode de pureQuery Runtime est STATIC et que la valeur de l'attribut isBindable est true pour l'ensemble d'instructions et l'instruction SQL, pureQuery Runtime tente d'exécuter l'instruction en mode statique.

    Si la valeur de l'attribut isBindable est true pour l'ensemble d'instructions et false pour une instruction SQL de l'ensemble, la valeur de la propriété allowDynamicSQL de pureQuery Runtime contrôle si pureQuery Runtime doit tenter d'exécuter l'instruction de manière dynamique ou doit renvoyer une erreur.

    Si la valeur de l'attribut isBindable est false pour l'ensemble d'instructions, la valeur de la propriété allowDynamicSQL de pureQuery Runtime contrôle si pureQuery Runtime doit tenter d'exécuter une instruction SQL de l'ensemble de manière dynamique ou doit renvoyer une erreur.

Vous pouvez utiliser l'éditeur pureQueryXML dans le plan de travail pour modifier la valeur de l'attribut isBindable dans un fichier pureQueryXML pour un ensemble d'instructions et une instruction.

Recommandation : IBM vous recommande fortement de modifier les fichiers pureQueryXML en utilisant uniquement le plan de travail. Si vous éditez un fichier pureQueryXML en dehors du plan de travail, vous risquez de rendre le ficher inutilisable.

Si vous éditez manuellement un fichier pureQueryXML, veillez à créer au préalable une copie de sauvegarde de ce fichier. Utilisez l'option -validateXml avec les utilitaires Merge, Configure ou StaticBinder de pureQuery afin de procéder à la validation de schéma XML sur les fichiers en entrée pureQueryXML.

Si vous devez modifier un fichier pureQueryXML en dehors du plan de travail, associez l'attribut configureStatus à la valeur REQUIRED dans la balise de début de l'ensemble d'instructions statementSet à modifier. Une fois le fichier modifié, exécutez l'utilitaire Configure sur le fichier.

Le fragment XML suivant associe l'attribut configureStatus à la valeur REQUIRED :
<statementSet configureStatus="REQUIRED">

Si vous modifiez un fichier pureQueryXML en dehors du plan de travail, vous pouvez modifier la valeur de l'attribut isBindable pour un ensemble d'instructions et une instruction.

Pour modifier l'attribut isBindable d'un ensemble d'instructions, modifiez la valeur de l'attribut isBindable de l'élément de package correspondant à l'élément enfant de l'élément de l'ensemble d'instructions.

Pour modifier l'attribut isBindable d'une instruction SQL, modifiez la valeur de l'attribut isBindable de l'élément statementAttributes correspondant à l'élément enfant de l'élément de l'instruction.

Le fragment XML suivant fait partie d'un ensemble d'instructions d'un fichier pureQueryXML :
<statementSet configureStatus="AUTO">
      <package collection="NULLID" consistencyToken="0000012551b7579f" isBindable="true" 
            isDDLPackage="false" name="pureQu" version=""/>
      <statements>
         <statement id="1" sectionNumber="1">
            <statementDescriptor>
               <prepareSql>SELECT CID FROM CUSTOMER WHERE CID &gt; 1002 </prepareSql>
               <statementType>QUERY</statementType>
               <resultSetMetadata>
                  <column columnName="CID" columnNameX="CID" databaseName="XMLTEST" 
                      databaseSchema="TEST " db2type="492" length="8" nullable="false" 
                      tableName="CUSTOMER"/>
               </resultSetMetadata>
               <statementAttributes cursorName="DB_PDQ_SPC2" isBindable="true" 
                    prepareOptions="FOR READ ONLY " resultSetConcurrency="CONCUR_READ_ONLY" 
                    resultSetHoldability="HOLD_CURSORS_OVER_COMMIT" 
                    resultSetType="TYPE_FORWARD_ONLY"/>
               <processedSql />
            </statementDescriptor>
            <statementMetadata>
               <traceInfo>
                  <sqlDefinitionStackTraces>
                     <trace>
          . . .
</statementSet>

Dans le fragment XML suivant de l'exemple, l'attribut isBindable se trouve dans la balise de début de l'élément du package. La valeur est true.

<package collection="NULLID" consistencyToken="0000012551b7579f" isBindable="true" 
     isDDLPackage="false" name="pureQu" version=""/>

L'exemple d'ensemble d'instructions suivant contient l'instruction SQL SELECT CID FROM CUSTOMER WHERE CID > 1002. Dans le fragment XML suivant, l'attribut isBindable de l'instruction SQL est un attribut de l'élément statementAttributes. L'élément statementAttributes est un élément enfant de l'élément de l'instruction qui contient l'instruction SQL. La valeur est true.

<statementAttributes cursorName="DB_PDQ_SPC2" isBindable="true" 
      prepareOptions="FOR READ ONLY " resultSetConcurrency="CONCUR_READ_ONLY" 
      resultSetHoldability="HOLD_CURSORS_OVER_COMMIT" 
      resultSetType="TYPE_FORWARD_ONLY"/>

Registres DB2 spéciaux

Lorsque pureQuery Runtime capture des instructions SQL exécutées dans une base de données DB2, certaines valeurs des registres spéciaux DB2 sont contrôlées et enregistrées avec les instructions SQL. Les valeurs des registres spéciaux enregistrées sont des valeurs couramment définies et qui peuvent affecter le comportement de l'instruction SQL si elles sont modifiées.

L'utilitaire Configure affiche l'activité du registre spécial enregistrée dans le fichier pureQueryXML dans le cadre de son activité.

Pour créer des ensembles d'instructions en fonction des informations des registres spéciaux enregistrées avec les instructions SQL, indiquez l'option -groupSQLBySpecialRegisters.

Pour créer un fichier d'options StaticBinder contenant des informations de liaison basées sur les données des registres spéciaux enregistrées lors de la capture des instructions SQL, indiquez l'option -optionsFileForBind. Vous pouvez créer un fichier d'options StaticBinder même si vous n'avez pas indiqué l'option -groupSQLBySpecialRegisters pour créer des ensembles d'instructions en fonction des informations des registres spéciaux des instructions SQL. Pour plus d'informations sur le fichier et les données des registres spéciaux enregistrées par pureQuery Runtime, reportez-vous aux liens connexes à la fin de cette rubrique.

Informations des registres spéciaux dans le fichier pureQueryXML

Lorsque pureQuery Runtime capture une instruction SQL dans un fichier pureQueryXML, il enregistre les informations des registres spéciaux pour l'instruction. Dans le fichier, les informations des registres spéciaux sont stockées dans l'élément XML nommé specialRegValuesSet.

L'élément specialRegValuesSet contient une ou plusieurs instances de l'élément XML nommé specialRegValue. L'attribut specialRegValueId est un attribut de l'élément specialRegValue. La valeur de l'attribut specialRegValueId est l'ID de l'élément specialRegValue.

L'élément specialRegValue contient également un ensemble d'informations des registres spéciaux enregistrées lors de la capture de l'instruction SQL. Les instructions SQL capturées sont stockées dans une instance de l'élément XML statementSet. Chaque élément statementSet contient une ou plusieurs instances d'un élément XML nommé statement. Chaque instruction contient des informations SQL sur l'instruction SQL capturée.

La valeur de l'attribut specialRegValueId permet de lier les informations du registre spécial de l'élément specialRegValue aux instructions SQL. pureQuery Runtime indique la valeur de l'attribut specialRegValueId sous la forme de la valeur d'un attribut de l'élément nommé statementAttributes de l'instruction SQL.

Pour plus d'informations sur les données des registres spéciaux enregistrées par pureQuery Runtime, reportez-vous aux liens connexes à la fin de cette rubrique.

Le fragment XML suivant présente un exemple de l'élément specialRegValuesSet d'un fichier pureQueryXML :

<specialRegValuesSet>
    <specialRegValue specialRegValueId="0" 
         specialRegisterVectorValue="UNTRACKED_SET: FALSE|
         SCHEMA: MYTEST |
         PATH: &quot;SYSIBM&quot;,&quot;SYSFUN&quot;,&quot;SYSPROC&quot;,
            &quot;SYSIBMADM&quot;,&quot;MYTEST&quot;|
         SQLID: MYTEST |
         DECFLOAT ROUNDING: ROUND_HALF_EVEN"/>
    <specialRegValue specialRegValueId="1" 
         specialRegisterVectorValue="UNTRACKED_SET: FALSE|
         SCHEMA: DB2ADMIN|
         PATH: &quot;SYSIBM&quot;,&quot;SYSFUN&quot;,&quot;SYSPROC&quot;,
            &quot;SYSIBMADM&quot;,&quot;DB2ADMIN&quot;|
         SQLID: DB2ADMIN|
         DECFLOAT ROUNDING: ROUND_HALF_EVEN"/>
</specialRegValuesSet> 
Le fragment suivant du fichier pureQueryXML affiche une partie de l'élément d'une instruction SQL dans le fichier pureQueryXML.
<statement id="1" sectionNumber="1">
     <statementDescriptor>
        <prepareSql>SELECT count(EMPNO) FROM EMPLOYEE WHERE WORKDEPT NOT LIKE 'E21' </prepareSql>
        <statementType>QUERY</statementType>
        <resultSetMetadata>
           <column columnName="1" databaseName="SAMPLE" db2type="496" length="4" nullable="false" 
               unnamedColumn="1"/>
        </resultSetMetadata>
        <statementAttributes cursorName="DB_PDQ_SPC5" 
            isBindable="true" prepareOptions="FOR READ ONLY " resultSetConcurrency="CONCUR_READ_ONLY" 
            resultSetHoldability="HOLD_CURSORS_OVER_COMMIT" resultSetType="TYPE_FORWARD_ONLY" 
            specialRegValuesUsed="0,1"/>
        <processedSql />
     </statementDescriptor>
     . . .
</statement>

Dans l'exemple, la valeur de l'attribut specialRegValuesUsed de l'élément statementAttributes indique les deux ID des ensembles du registre spécial. Les valeurs des ID de l'ensemble sont 0 et 1. pureQuery Runtime a capturé l'instruction SQL plusieurs fois. Lorsque pureQuery a capturé l'instruction, deux ensembles différents d'informations du registre spécial ont été enregistrés.

Exemple d'une première exécution de l'utilitaire Configure sur deux fichiers

Soit deux fichiers pureQueryXML, un pour chaque connexion réalisée par l'application d'API différente de pureQuery. Ces fichiers sont nommés capture_sales.pdqxml (contenant 450 instructions SQL) et capture_employee.pdqxml (contenant également 450 instructions SQL, dont 50 sont des instructions DDL).

Pour ces fichiers, vous souhaitez fournir les valeurs suivantes à l'utilitaire Configure lors de la première exécution de l'utilitaire sur ces fichiers :

Tableau 2. Exemple de valeurs pour l'utilitaire Configure
Options pour l'utilitaire Configure capture_sales.pdqxml capture_employee.pdqxml
-collection first second
-markDDLForBind FALSE FALSE
-pkgVersion 1.0 1.0
-rootPkgName PK001S PK005E
-sqlLimit 200 200
Dans ce cas, deux méthodes permettent d'exécuter l'utilitaire Configure.
  • Exécutez deux fois l'utilitaire Configure et indiquez à chaque fois un fichier .pdqxml différent :
    java com.ibm.pdq.tool.Configure -collection first -pkgVersion 1.0 -rootPkgName PK001S \
    -sqlLimit 200 -pureQueryXml C:\capture_files\capture_sales.pdqxml
    java com.ibm.pdq.tool.Configure -collection second -pkgVersion 1.0 -rootPkgName PK005E \
    -sqlLimit 200 -pureQueryXml C:\capture_files\capture_employee.pdqxml
  • Exécutez une fois l'utilitaire Configure et indiquez un fichier d'options contenant les fichiers .pdqxml.

    La commande peut se présenter comme suit :

    java com.ibm.pdq.tool.Configure -optionsFile myOptionsFile.txt

    Le fichier d'options, qui peut porter tout nom et extension pris en charge par votre système d'exploitation, contient les entrées suivantes :

    defaultOptions = -pkgVersion 1.0 -sqlLimit 200
    
    C:\capture_files\capture_sales.pdqxml = -collection first -rootPkgName PK001S
    
    C:\capture_files\capture_employee.pdqxml = -collection second -rootPkgName PK005E
Quelle que soit la méthode utilisée, l'utilitaire Configure met à jour les deux fichiers .pdqxml avec les valeurs spécifiées pour les différentes options. Il génère également les fichiers suivants :
Des fichiers basés sur capture_sales.pdqxml
capture_sales.pdqxml.org

capture_sales.pdqxml_1.0

Des fichiers basés sur capture_employee.pdqxml
capture_employee.pdqxml.org

capture_employee.pdqxml_1.0

capture_employee.ddl

Exemples de création d'ensembles d'instructions avec l'option -groupSQLByStrings

Les exemples suivants supposent que le fichier pureQueryXML contient les trois instructions SQL suivantes :
SELECT * FROM TABLE3
SELECT * FROM TABLE2
SELECT * FROM TABLE1
Si la valeur de l'option -groupSQLByStrings est (TABLE3) (TABLE2) (TABLE1), les instructions sont affectés aux ensembles d'instructions suivants :
Statement set 1: 
    SELECT * FROM TABLE3
Statement set 2: 
    SELECT * FROM TABLE2
Statement set 3: 
    SELECT * FROM TABLE1
Si la valeur est (TABLE1) (TABLE3|TABLE2), les instructions sont affectées aux ensembles d'instructions suivants :
Statement set 1: 
    SELECT * FROM TABLE1
Statement set 2: 
    SELECT * FROM TABLE2
    SELECT * FROM TABLE3
Si la valeur est (TABLE1|TABLE2) (TABLE3|TABLE2), les instructions sont affectées aux ensembles d'instructions suivants :
Statement set 1: 
    SELECT * FROM TABLE1, 
    SELECT * FROM TABLE2
Statement set 2: 
    SELECT * FROM TABLE3
Remarque : Il est déconseillé d'utiliser le même nom de table dans plusieurs définitions d'ensembles d'instructions. Le cas échéant, un message d'avertissement sera consigné.

Mise à jour des noms de schéma et des emplacements de base de données

Le remplacement de nom est un processus en un seul passage. Par exemple, si vous indiquez la chaîne de remplacement "(S1>S2) (S2>S3)", les occurrences de S1 sont remplacées par S2 et les occurrences d'origine de S2 sont remplacées par S3. L'utilitaire Configure remplace S1 par S2 en un seul passage puis remplace S2 par S3 lors d'un autre passage.

Si vous spécifiez une chaîne de remplacement similaire à "(SCH1>SCH2) (SCH2>SCH3)", il est possible que vous receviez des résultats inattendus si vous configurez un fichier pureQueryXML plusieurs fois. Lors de la première configuration, le nom SCH1 passe sur SCH2 et le nom qui était à l'origine SCH2 dans le fichier passe sur SCH3. Lors de la deuxième configuration du fichier, le nom SCH2 passe sur SCH3, notamment les instances du nom SCH2 modifiées lors de la première configuration. Tous les noms qui étaient à l'origine SCH1 ou SCH2 dans le fichier passent sur SCH3.

Si vous souhaitez effectuer un remplacement de nom, par exemple remplacer les noms de schéma SCHIf par SCH2 puis SCH2 par SCH1, exécutez deux fois l'utilitaire Configure. Exécutez d'abord l'utilitaire avec l'option -replaceSchemas "(SCH1>SCH2)" puis réexécutez-le avec l'option -replaceSchemas "(SCH2>SCH1)".

Exemples de remplacement de nom

L'utilitaire Configure peut distinguer l'identificateur et le littéral de chaîne de caractères. Par exemple, un fichier pureQueryXML contient l'instruction SQL suivante. Dans l'instruction, le même identificateur apparaît comme nom de schéma dans un littéral de chaîne de caractères :
INSERT INTO "schm0".table0 (col1, col2, col3) values (1, 'schm0', 'col3')
Si vous indiquez -replaceSchemas "(\"schm0\">\"prodSch\")", l'utilitaire remplace le nom de schéma mais pas le littéral :
INSERT INTO "prodSch".table0 (col1, col2, col3) values (1, 'schm0', 'col3')
Si les noms de remplacement contiennent des espaces, l'utilitaire enlève les espaces de début et de fin entre guillemets. Par exemple, les deux options -replaceLocations suivantes sont identiques :
-replaceLocations " (   sample >   testDB ) "
-replaceLocations "(sample > testDB)"
Pour définir des noms d'emplacement de base de données et de schéma délimités dans une instruction SQL, l'utilitaire peut modifier le nom de schéma qui apparaît dans les deux instructions suivantes :
SET CURRENT SCHEMA = "schm0"
SET CURRENT SCHEMA = 'schm0';
Avec une chaîne de remplacement "('schm0'>'prodSchm')" ou "(\"schm0\">\"prodSchm\")", les deux noms sont remplacés et les guillemets sont préservés :
SET CURRENT SCHEMA = "prodSchm"
SET CURRENT SCHEMA = 'prodSchm';
Si l'instruction SQL suivante se trouve dans un fichier pureQueryXML d'une base de données DB2 for Linux, UNIX et Windows :
SET PACKAGE PATH = 'schema1, schema2'
L'utilitaire Configure reconnaît les deux noms comme noms de schéma et les remplace si nécessaire.
Cependant, si cette instruction SQL se trouve dans un fichier pureQueryXML pour une base de données DB2 for z/OS, la valeur abc est un ID collection qui n'est pas modifié.
SET PACKAGE PATH = 'abc'
Pour l'instruction SET PATH suivante, la valeur schema1 est un nom de schéma pour DB2 for z/OS et pour DB2 for Linux, UNIX et Windows.
SET PATH = 'schema1';
Le nom est modifié par l'utilitaire si nécessaire.

Commentaires