Utilitaire Configure

Avec l'utilitaire Configure de pureQuery, vous pouvez définir plusieurs caractéristiques des modules DB2 que vous avez éventuellement créés pour les instructions SQL dans vos fichiers pureQueryXML. Vous pouvez définir la collection, la version et le nom de module racine des modules DB2, ainsi que le nombre maximal d'instructions SQL admises dans un module. La validation de schéma XML peut également être effectuée au niveau des fichiers pureQueryXML en 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 se trouvant dans un fichier pureQueryXML d'un module DB2, l'utilitaire lit ces caractéristiques.

Remarque : Le fichier pureQueryXML en entrée peut être un fichier pureQueryXML créé comme suit :
  • Le fichier a été créé pour capturer des instructions SQL supplémentaires lorsque les propriétés outputPureQueryXml et pureQueryXML sont spécifiées. Lorsque les deux propriétés sont spécifiées, le fichier PureQueryXML en sortie contient des instructions SQL capturées qui n'apparaissent pas dans le fichier pureQueryXML spécifié par la propriété pureQueryXML. Avant toute configuration, vous devez fusionner les deux 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 toute configuration, vous devez extraire les données pureQueryXML de la version du groupe d'exécution et fusionner les deux 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.

Sortie de l'utilitaire Configure

L'utilitaire Configure génère entre un et trois fichiers supplémentaires pour chaque fichier pureQueryXML qu'il met à 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. Ce dernier ajoute la valeur au nom d'une copie du fichier pureQueryXML. Par exemple, -pkgVersion Ver1.0 -pureQueryXml sampleJDBC.pdqxml génère un fichier nommé sampleJDBC.pdqxml_Ver1.0 identique au fichier sampleJDBC.pdqxml mis à jour, à l'exception de son nom.
    Vous pouvez utiliser la gestion des versions si vous souhaitez pouvoir basculer vers des versions antérieures des modules DB2 associés à votre application. Par exemple, supposons que vous disposiez de quatre fichiers pureQueryXML :
    • sampleJDBC.pdqxml et sampleJDBC.pdqxml_3.0, qui sont identiques.
    • sampleJDBC.pdqxml_2.5
    • sampleJDBC.pdqxml_2.0
    Vous disposez également des modules 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 module DB2 (version 3.0), vous pouvez rétablir le module 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 module 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.

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 utilisez l'utilitaire Configure pour traiter les nouvelles instructions SQL dans le fichier pureQueryXML, l'utilisation de l'option -cleanConfigure affecte le traitement des instructions et des ensembles d'instructions SQL existants :
  • Si l'option -cleanConfigure est définie sur sa valeur par défaut, l'utilitaire Configure tente de préserver 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 poursuivre la création des packages DB2 à partir des instructions SQL dans le fichier pureQueryXML.

  • Lorsque l'option -cleanConfigure est définie sur la valeur TRUE, l'utilitaire Configure ne préserve pas les informations relatives aux ensembles d'instructions.

Registres DB2 spéciaux

Lorsque pureQuery Runtime capture des instructions SQL s'exécutant sur une base de données DB2, certaines valeurs de registre spécial DB2 sont contrôlées et capturées avec les instructions SQL. Les valeurs de registre spécial capturées correspondent aux valeurs qui sont les plus fréquemment définies et qui peuvent affecter les données renvoyées par l'instruction SQL en cas de modification.

Pour afficher les activités de registre spécial capturées dans le fichier pureQueryXML en entrée dans le résumé des activités de l'utilitaire Configure, définissez l'option -showDetails sur true.

Fichiers d'options

Le fichier d'options répertorie le ou les fichiers pureQueryXML que l'utilitaire pureQuery Configure doit traiter, ainsi que les options indiquant aux utilitaires comment traiter les fichiers. Vous pouvez définir les options par défaut s'appliquant à 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 -traceFile C:\logs\configure.txt -traceLevel ALL
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 de collecte des packages DB2 qui seront créés et dont les accès seront définis. La ligne indique également le fichier dans lequel les messages sont journalisés. Les deux lignes suivantes suppriment l'ID de collecte 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 interfaces individuelles 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 module 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_module----------------------------->

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

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

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

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

>--+------------------------+----------------------------------->
   |             .-100----. |   
   '- -sqlLimit--+-nombre-+-'   

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

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

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

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

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

>--+--------------------------+--+--------------------------+--->
   |                .-FALSE-. |  |                      (2) |   
   '- -validateXml--+-TRUE--+-'  '-| options de trace |-----'   

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

Remarques:
  1. Vous pouvez spécifier les options dans n'importe quel ordre.
  2. 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 modules 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-. |   
   '- -showDetails--+-TRUE--+-'   

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

>--+------------------------+----------------------------------->
   |             .-100----. |   
   '- -sqlLimit--+-nombre-+-'   

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

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

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

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

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

>--+--------------------------+--+--------------------------+--><
   |                .-FALSE-. |  |                      (2) |   
   '- -validateXml--+-TRUE--+-'  '-| options de trace |-----'   

Remarques:
  1. Vous pouvez spécifier les options dans n'importe quel ordre.
  2. Pour la syntaxe, voir la description de ces options.

Syntaxe permettant de spécifier les options de fichiers pureQueryXML individuels 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_module----------------------------->

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

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

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

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

>--+------------------------+----------------------------------->
   |             .-100----. |   
   '- -sqlLimit--+-nombre-+-'   

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

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

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

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

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

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

Remarques:
  1. Vous pouvez spécifier les options dans n'importe quel ordre.

Descriptions des options

pureQueryXML-file = (au début d'une ligne d'un fichier d'options)
Indique le nom du fichier pureQueryXML, chemin absolu ou relatif inclus, auquel s'appliquent les options placées sur cette ligne du fichier d'options. Ce fichier doit avoir 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, and 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 utilise des curseurs d'ensemble de lignes, et uniquement lorsque les propriétés IBM Data Server Driver for JDBC and SQLJ indiquent que les curseurs d'ensemble de lignes doivent être utilisés. 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.

Si vous n'indiquez pas cette option, pureQuery utilise par défaut les curseurs d'ensemble de lignes pour les instructions pour lesquelles le pilote IBM Data Server Driver for JDBC and SQLJ a utilisé des curseurs d'ensemble de lignes 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
Pour tous les ensembles d'instructions, l'utilitaire Configure définit la valeur de configureStatus sur AUTO. Remplace la valeur FINAL pour l'ensemble d'instructions configureStatus.

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. Les ensembles d'instructions du fichier de sortie peuvent être différents de ceux du fichier en entrée.

Vous devez indiquer une valeur pour l'option -rootPkgName.

FALSE
Les noms et ID de collecte 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é.

Il s'agit de la valeur par défaut. Vous devez indiquer une valeur pour l'option -rootPkgName.

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

Pour les ensembles d'instructions nommés avec l'option REQUIRED pour configureStatus, certaines options sont appliquées, telles que -collection, -pkgVersion, -forceSingleBindIsolation et -markDDLForBind. La marque de cohérence est mise à jour.

Pour les ensembles d'instructions dont l'ensemble d'indicateurs est défini sur AUTO, la configuration applique les options uniquement si l'utilitaire Configure 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é.

Pour les ensembles d'instructions nommés dont l'ensemble d'indicateurs configureStatus est défini sur FINAL, l'utilitaire Configure affiche des erreurs lorsque des problèmes sont trouvés dans l'ensemble d'instructions. 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 modificiations de l'instruction.

-collection nom_collection
Qualificatif des modules 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 jeu 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 le jeu 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'isolation 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.

-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 rencontre la valeur TRUE pour l'attribut isBindable de l'ensemble d'instructions DDL, il tente de définir les accès de toute instruction de cet ensemble dont l'attribut isBindable est défini sur TRUE.

-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.
-pkgVersion AUTO|ID_version
Indique la version du module à 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 module, ce qui vous permet de définir les accès des nouveaux modules sans devoir remplacer les anciennes versions des modules portant un nom identique. Si vous rencontrez des difficultés avec une version récente d'un module, vous pouvez toujours utiliser une version plus ancienne de ce module.

Si vous n'utilisez pas cette option, les modules de base de données résultant de définitions d'accès ultérieures sont créés sans version.

AUTO
Indique que la version doit être générée de façon automatique en utilisant l'horodatage en cours.
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'utilitaire Configure crée une copie du fichier pureQueryXML en ajoutant l'ID version au nom de ce fichier. L'ID version ne peut donc 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 module ne peuvent pas excéder la longueur acceptée par votre système d'exploitation pour les noms de fichier.

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. Il doit s'agir d'une ressource placée dans le chemin d'accès aux classes de l'application, ou bien vous devez indiquer le chemin complet ou relatif de ce fichier.
-rootPkgName racine_nom_module
Indique la racine du nom à utiliser pour les modules DB2. Pour tout détail concernant la façon dont l'utilitaire Configure crée les noms des modules DB2, voir la description donnée pour sqlLimit.

La valeur racine_nom_module 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 modules DB2, vous devez utiliser des majuscules pour la valeur racine_nom_module 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 module (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_module / caractères supplémentaires consécutifs à l'intervention de l'utilitaire Configure / niveau d'isolement.

-showDetails true|false
Indique si l'utilitaire Configure doit afficher un récapitulatif de ses activités. La valeur par défaut est false.

Lorsque cette option est définie sur true, l'utilitaire Configure affiche les activités de registre spécial capturées dans le fichier pureQueryXML en entrée dans le résumé des activités.

-sqlLimit nombre
Indique le nombre maximal d'instructions SQL autorisées dans le module DB2. En règle générale, si le nombre d'instructions SQL dépasse cette limite, l'utilitaire pureQuery StaticBinder crée un autre module 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 module est légèrement supérieur à la limite.

Cette valeur par défaut est 100.

Par exemple, supposons que vous vouliez créer quatre modules (un module pour chacun des quatre niveaux d'isolement) avec le nom racine monModule et que votre base de données prenne en charge les noms de module 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 modules suivants :
Tableau 1. Tableau des modules
  Module avec les 100 premières instructions SQL Module avec les n instructions SQL suivantes, où 100 < n < 200
Niveau d'isolement CS monModuleA1 monModuleB1
Niveau d'isolement RR monModuleA2 monModuleB2
Niveau d'isolement RS monModuleA3 monModuleB3
Niveau d'isolement UR monModuleA4 monModuleB4

Les chiffres représentent le niveau d'isolement des modules, cependant que les lettres représentent le nombre de modules 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 modules à 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 module 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 module 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 module 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.
-removeSQLInactiveForDays jours
Indique le nombre de jours qui doit 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 définie sur un nombre positif, l'utilitaire Configure n'écrit pas d'instructions SQL dans le fichier de sortie si leur dernière utilisation remonte au nombre de jours indiqué par la variable à compter de la date du jour ou si elle est antérieure. 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.

Si l'instruction SQL n'est pas horodatée, elle est écrite dans le fichier de sortie. Par exemple, si une version antérieure du fichier pureQueryXML n'est autre qu'un fichier en entrée, l'instruction SQL n'est pas horodatée. En cas de version précédente d'un fichier pureQueryXML (version 3 ou antérieure), l'option est ignorée, toutes les instructions SQL sont écrites dans le fichier de sortie et un message s'affiche.

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.

-setPreStatusOfAllPkgs AUTO|FINAL|REQUIRED
Indique l'état d'un module. L'utilitaire Configure définit tous les packages à l'état indiqué 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 packages non nommés sont normalement configurés. Les packages nommés sont validés et configurés, uniquement si nécessaire.
  • FINAL : définit le statut de tous les packages nommés sur FINAL. Le statut des packages non nommés est ignoré et les packages sont validés et configurés.
  • REQUIRED : pour les packages non nommés, il s'agit de la valeur par défaut. Pour les packages nommés, ils sont configurés et toute nouvelle valeur spécifiée pour les options -collection, -forceSingleBindIsolation, -markDDLForBind, pkgVersion et -allowStaticRowsetCursors est appliquée 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 packages dans le fichier pureQueryXML en sortie. Ce qui suit se produit si la valeur de l'option -setPreStatusOfAllPkgs est définie sur FINAL :
  • Si l'option -cleanConfigure est définie sur FALSE ou n'est pas définie, tous les packages non nommés sont configurés, tous les packages nommés sont validés et configurés comme il se droit et le statut de tous les packages est défini sur FINAL.
  • Si l'option -cleanConfigure est définie sur TRUE, configurez tous les packages et définissez leur statut sur FINAL.
-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 définie sur TRUE, les instructions SQL sont regroupées dans des ensembles d'instructions. Toutes les instructions SQL contenues dans le même ensemble d'instructions présentent les mêmes valeurs de registre spécial enregistré 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 à plus d'un jeu de valeurs de registre spécial enregistré sont regroupées dans un même ensemble d'instructions. Une instruction SQL peut être associée à des jeux de valeurs de registre spécial capturé si l'instruction SQL a été émise plusieurs fois par l'application et que les informations relatives aux registres spéciaux ont changé entre les captures de l'instruction SQL.

Lorsque les options -groupSQLBySpecialRegisters et -groupSQLByStrings sont toutes deux utilisées pour créer des ensembles d'instructions. Les instructions sont tout d'abord regroupés en fonction de valeurs de registre spécial. Pour chaque groupe basé sur des registres spéciaux, les instructions SQL sont regroupées sur la base 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.

-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 définie, le regroupement par défaut est appliqué.

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.

Lors de la création d'ensembles d'instructions, ces derniers sont créés dans l'ordre indiqué par l'option groupSQLByStrings et la recherche d'instructions correspondantes est effectuée dans l'ordre spécifié par l'option. Par exemple, si l'option est définie sur la 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 toutes deux utilisées pour créer des ensembles d'instructions. Les instructions sont tout d'abord regroupés en fonction de valeurs de registre spécial. Dans chaque groupe utilisant des registres spéciaux, les instructions SQL sont regroupées sur la base des valeurs indiqué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.

-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. En cas d'échec d'un fichier en entrée, le traitement de la 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 un récapitulatif des informations d'utilisation.
Non valide dans un fichier d'options.

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 ressembler à ce qui suit :

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

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

    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 à l'aide de 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ées 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é.


Commentaires