Utilitaire GeneratePureQueryXml

L'utilitaire GeneratePureQueryXml génère un pureQueryXML basé sur les informations SQL issue de l'entrée spécifiée. La source des informations peut être un fichier script SQL qui contient les informations d'attribut des instructions et du curseur, un fichier InfoSphere Optim Query Workload Tuner XML ou la mémoire cache dynamique d'une base de données.

L'utilitaire GeneratePureQueryXml lit les instructions SQL et les informations relatives aux instructions, puis crée un fichier pureQueryXML. Lorsque le fichier pureQueryXML est créé, utilisez l'utilitaire Configure pour préparer le fichier à utiliser avec pureQuery Runtime. Une fois le fichier pureQueryXML configuré, utilisez l'utilitaire StaticBinder pour créer et lier les packages DB2 contenant les instructions SQL dans le fichier pureQueryXML configuré.

Syntaxe de la commande

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

>-- -username--ID_utilisateur-- -password--mot_de_passe-- -url--URL-JDBC-->

>--+---------------------------------------------+-------------->
   |               .-com.ibm.db2.jcc.DB2Driver-. |   
   '- -driverName--+-pilote_JDBC---------------+-'   

>-- -pureQueryXml--nom_fichier---------------------------------->

>-- -inputSql--+-nom_fichier-----------------+------------------>
               |  (2)                        |   
               '-------| Cache_instruction |-'   

>--+------------------------------------------------+----------->
   |                  (3).- - - ------------------. |   
   '- -commentStart------+-indicateur_commentaire-+-'   

>--+---------------------------------------+-------------------->
   |                           .-NOT_SET-. |   
   '- -sqlLiteralSubstitution--+-DISABLE-+-'   
                               '-ENABLE--'     

>--+--------------------------------------+--------------------->
   |                       .-;----------. |   
   '- -statementDelimiter -+-délimiteur-+-'   

>--+------------------------------------------------------+----->
   |                         .-HOLD_CURSORS_OVER_COMMIT-. |   
   '- -resultSetHoldability -+-CLOSE_CURSORS_AT_COMMIT--+-'   

>--+----------------------------------------------+------------->
   |                         .-CONCUR_READ_ONLY-. |   
   '- -resultSetConcurrency--+-CONCUR_UPDATABLE-+-'   

>--+--------------------------------------------+--------------->
   |                  .-TYPE_FORWARD_ONLY-----. |   
   '- -resultSetType--+-TYPE_SCROLL_SENSITIVE-+-'   
                      '-TYPE_SCROLL_SENSITIVE-'     

>--+--------------------------+--+--------+--------------------><
   |                      (4) |  '- -help-'   
   '-| Options de trace |-----'               

Cache_instruction

|--DYNAMIC_STATEMENT_CACHE--+----------------------------------------------------------------------------+--|
                            |                     .-,-----------------------------------------------.    |   
                            |                     V  (5)                                            |    |   
                            '- -filterCacheBy--"--------+---clientProgramId-- -ID_programme-------+-+--"-'   
                                                        +---clientUser-- -ID_utilisateur_client---+          
                                                        +---currentSqlId-- -ID_autorisation-------+          
                                                        +---currentSchema-- -Nom_schéma-----------+          
                                                        '---cachedAfter-- -heure_cache------------'          

Remarques:
  1. Vous pouvez spécifier les options dans n'importe quel ordre.
  2. Les instructions SQL peuvent être récupérées à partir du cache d'instruction dynamique uniquement pour les bases de données DB2 for z/OS.
  3. La valeur par défaut est deux tirets (--)
  4. Pour la syntaxe, voir la description de ces options.
  5. Chaque filtre peut être spécifié une fois au maximum. Les filtres peuvent être spécifiés dans n'importe quel ordre.

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

Description des options

-username ID_utilisateur
La variable ID_utilisateur indique l'ID utilisateur permettant de procéder à une authentification avec la base de données.
-password mot_de_passe
Spécifie le mot de passe à utiliser pour l'authentification avec la base de données.
-url URL-JDBC
Indique l'adresse URL JDBC à utiliser pour établir une connexion avec la base de données.
-driverName pilote_JDBC
Indique le nom qualifié complet du pilote JDBC à utiliser pour établir une connexion avec la base de données. La valeur par défaut est com.ibm.db2.jcc.DB2Driver, le pilote d'IBM® Data Server Driver for JDBC and SQLJ.
-pureQueryXml fichier
Spécifie le chemin d'accès absolu ou relatif au fichier de sortie pureQueryXML.
-inputSql fichier | DYNAMIC_STATEMENT_CACHE filtres_cache
Spécifie la source des informations SQL utilisées pour créer le fichier pureQueryXML.

Pour plus d'informations sur le format du fichier script SQL, voir Format du fichier script SQL utilisé par l'utilitaire GeneratePureQueryXml.

fichier
Indique le chemin relatif ou absolu d'un fichier de script SQL avec l'extension .sql ou d'un fichier XML avec l'extension .xml.
Si un fichier XML est spécifié, il doit s'agir d'un fichier InfoSphere Optim Query Workload Tuner valide. Si le fichier XML n'est pas valide, une erreur est signalée. Pour obtenir des informations sur l'exportation d'un fichier Query Workload Tuner, voir la documentation sur InfoSphere Optim Query Workload Tuner. Lors de la capture des instructions SQL, InfoSphere Optim Query Workload Tuner prend en charge les fonctionnalités suivantes :
  • Pour les bases de données DB2 for Linux, UNIX, and Windows, vous pouvez capturer les instructions SQL à partir de la mémoire cache de package.
  • Pour les bases de données DB2 for z/OS, vous pouvez capturer les instructions SQL à partir du cache d'instruction. Vous pouvez exclure les instructions SQL exécutées par InfoSphere Optim Query Workload Tuner en activant l'option Exclude dynamic queries issued by the capture process (Exclure les requêtes dynamiques émises par le processus de capture).

Si une instruction SQL figure plusieurs fois dans le fichier en entrée, elle apparaît une seule fois dans le fichier de sortie pureQueryXML. Pour savoir comment les doublons d'instructions SQL sont identifiés, voir Identification des instructions SQL en double dans un fichier SQL.

DYNAMIC_STATEMENT_CACHE -filterCacheBy "chaîne_options_filtre"
Spécifie que l'utilitaire GeneratePureQueryXml copie les instructions SQL de la mémoire cache dynamique de la base de données spécifiée par l'option -url dans le fichier pureQueryXML de sortie. L'option DYNAMIC_STATEMENT_CACHE est uniquement valide lorsque la connexion est dirigée vers une base de données DB2 for z/OS. Autrement, une erreur est renvoyée. L'option DYNAMIC_STATEMENT_CACHE ne peut être spécifiée avec les options suivantes :
  • -commentStart
  • -resultSetConcurrency
  • -resultSetHoldabillity
  • -resultSetType
  • -statementDelimiter

Le filtre du cache -filterCacheBy "chaîne_options_filtre" est facultatif. Le filtre du cache limite les instructions SQL copiées vers le fichier pureQueryXML de sortie basé sur les propriétés associées à l'instruction. Si le filtre du cache n'est pas spécifié, toutes les instructions de la mémoire cache dynamique sont copiées vers le fichier pureQueryXML.

chaîne_options_filtre est une liste d'une ou de plusieurs paires clé-valeur séparées par des virgules et entre guillemets. Si plusieurs filtres sont spécifiés, seules les instructions SQL qui respectent tous les critères sont copiées vers le fichier pureQueryXML de sortie. Cette liste décrit les options et les valeurs valides pour chaîne_options_filtre :

clientProgramId ID_programme
Une instruction est copiée vers le fichier pureQueryXML si elle est placée dans la mémoire cache dynamique par une connexion dont la valeur de propriété clientProgramId correspond à ID_programme.
Remarque : Pour filtrer des instructions SQL avec l'option clientProgramId, une application doit utiliser une connexion ou une définition de source de données qui spécifie la propriété JDBC personnalisée clientProgramId. Lorsque les instructions SQL de l'application sont placées dans la mémoire cache dynamique, les informations de la propriété clientProgramId sont associées à l'instruction. Si la connexion ou la définition de source de données ne spécifie pas la propriété clientProgramId, aucune information clientProgramId n'est stockée avec l'instruction.
clientUser ID_utilisateur_client
Une instruction est copiée vers le fichier pureQueryXML si elle est placée dans la mémoire cache dynamique par une connexion dont la valeur de propriété clientUser correspond à ID_utilisateur_client.
Remarque : Pour filtrer des instructions SQL avec l'option clientUser, une application doit utiliser une connexion ou une définition de source de données qui spécifie la propriété JDBC personnalisée clientUser. Lorsque des instructions SQL d'application sont placées dans la mémoire cache dynamique, les informations de la propriété clientUser sont associées à l'instruction. Si la connexion ou la définition de source de données ne spécifie pas la propriété clientUser, aucune information clientUser n'est stockée avec l'instruction.
currentSqlId ID_autorisation
Une instruction est copiée vers le fichier pureQueryXML si elle est placée dans la mémoire cache dynamique par une connexion dont la valeur CURRENT SQLID correspond à ID_autorisation.
currentSchema nom_schéma
Une instruction est copiée vers le fichier pureQueryXML si elle est placée dans la mémoire cache dynamique par une connexion dont la valeur CURRENT SCHEMA correspond à nom_schéma.
cachedAfter heure_cache
Une instruction est copiée vers le fichier pureQueryXML si elle est placée dans la mémoire cache dynamique après heure_cache. La valeur heure_cache doit être une représentation de chaîne DB2 valide d'une date, d'une heure ou d'un horodatage. Pour plus d'informations sur les valeurs de date, d'heure et d'horodatage DB2, voir les valeurs de date et/ou heure.
-commentStart indicateur_commentaire
Pour un fichier de script SQL, il indique la combinaison de caractères de début qui identifie une ligne commentaire. Une ligne commentaire peut contenir les attributs de curseur applicables à l'instruction SQL immédiatement après le commentaire. Il s'agit par défaut de deux tirets (--). Les caractères de début et de fin de commentaire /* et */ ne sont pas pris en charge pour cette option.

Cette option n'est pas prise en charge si le fichier en entrée est un fichier XML. Un message d'avertissement s'affiche, indiquant que l'option spécifiée est ignorée.

-sqlLiteralSubstitution ENABLE|DISABLE|NOT_SET
Indique si l'utilitaire GeneratePureQueryXml remplace les valeurs littérales des instructions SQL par des marqueurs de paramètre. Si la valeur par défaut NOT_SET est définie, les valeurs littérales ne sont pas remplacées dans les instructions SQL. Le processus de substitution littérale SQL est identique au processus de substitution effectué lorsque pureQuery Runtime capture les instructions SQL avec la substitution littérale SQL activée.

La liste suivante décrit les valeurs prises en charge :

DISABLE
Indique que l'utilitaire n'effectue pas de substitution littérale. Les instructions SQL ne sont pas modifiées.

La valeur de l'attribut de substitution littérale SQL est définie sur DISABLE dans le fichier de sortie pureQueryXML.

ENABLE
Indique que l'utilitaire remplace les valeurs littérales des instructions SQL par des marqueurs de paramètre. Les valeurs littérales SQL ne sont pas remplacées si l'utilitaire détermine que cela peut affecter les résultats de l'instruction SQL. Lors de la substitution littérale SQL, les commentaires sont supprimés des instructions. Pour les instructions SQL où le remplacement de valeurs littérales SQL est effectué, les espaces multiples, notamment les espaces de début et de fin, sont remplacés par un seul espace.

L'utilitaire supprime les instructions SQL en double créées lors du processus de substitution littérale SQL.

La valeur de l'attribut de substitution littérale SQL est définie sur ENABLE dans le fichier de sortie pureQueryXML.

NOT_SET
Indique que la substitution littérale n'est pas effectuée sur ce fichier. Il s'agit de la valeur par défaut.

La valeur de l'attribut de substitution littérale SQL est définie sur NOT_SET dans le fichier de sortie pureQueryXML.

Lorsque pureQuery Runtime capture des instructions SQL dans un fichier pureQueryXML, le paramètre de substitution littérale SQL du fichier est la valeur de la propriété sqlLiteralSubstitution de pureQuery Runtime lors de la capture des instructions.

Pour plus d'informations sur la substitution littérale SQL pureQuery Runtime, voir la propriété sqlLiteralSubstitution.

Pour obtenir des informations sur l'attribut de substitution littérale SQL lors de la fusion de fichiers pureQueryXML, voir Utilitaire Merge.

-statementDelimiter délimiteur
Indique la combinaison de caractères utilisée dans le fichier script SQL pour séparer les instructions. Il s'agit par défaut d'un point-virgule (;).

Cette option n'est pas prise en charge si le fichier en entrée est un fichier XML InfoSphere Optim Query Workload Tuner. Un message d'avertissement s'affiche, indiquant que l'option spécifiée est ignorée.

-resultSetHoldability mise en suspens
Indique la mise en suspens de l'ensemble de résultats afin d'appliquer l'ensemble des instructions dans le fichier. La variable mise en suspens peut être définie sur l'une des valeurs suivantes :
  • CLOSE_CURSORS_AT_COMMIT : mise en suspens de l'ensemble de résultats définie de sorte que les curseurs se ferment sur validation. Cette valeur définit la valeur JDBC sur java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT.
  • HOLD_CURSORS_OVER_COMMIT : mise en suspens de l'ensemble de résultats définie de sorte que les curseurs se maintiennent sur validation. Cette valeur définit la valeur JDBC sur java.sql.ResultSet.HOLD_CURSORS_OVER_COMMIT.

La valeur par défaut est HOLD_CURSORS_OVER_COMMIT.

Dans les fichiers de script SQL, la valeur de mise en suspens peut être remplacée par une instruction SQL spécifique dans le fichier, en indiquant la mise en suspens dans une ligne de commentaire juste avant l'instruction SQL.

Pour les fichiers XML Query Workload Tuner issus de DB2 for z/OS, la mise en suspens de l'ensemble de résultats de la préparation initiale d'une instruction SQL est stockée dans le fichier. Si les informations de mise en suspens de l'ensemble de résultats se trouvent dans le fichier, l'utilitaire utilise cette valeur pour l'instruction SQL dans le fichier de sortie pureQueryXML.

Pour obtenir des informations sur la mise en suspens de l'ensemble de résultats pour les instructions SQL dans un fichier XML InfoSphere Optim Query Workload Tuner, voir Notes concernant le fichier de sortie pureQueryXML

-resultSetConcurrency accès concurrent
Indique le paramètre d'accès concurrent à appliquer à toutes les instructions pour l'ensemble de résultats. Cette variable peut être définie sur l'une des valeurs suivantes :
  • CONCUR_READ_ONLY : définit le mode d'accès concurrent des curseurs sur lecture uniquement.
  • CONCUR_UPDATABLE définit le mode d'accès concurrent des curseurs sur actualisable.

La valeur par défaut est CONCUR_READ_ONLY.

Dans les fichiers de script SQL, la valeur d'accès concurrent peut être remplacée dans une instruction SQL spécifique en indiquant l'accès concurrent dans une ligne de commentaire juste avant l'instruction SQL.

Pour obtenir des informations sur la configuration de l'accès concurrent d'ensemble de résultats pour les instructions SQL dans un fichier XML InfoSphere Optim Query Workload Tuner, voir Notes concernant le fichier de sortie pureQueryXML

-resultSetType type
Indique le type d'ensemble de résultats à appliquer à toutes les instructions. Le type peut être défini sur l'une des valeurs suivantes :
  • TYPE_FORWARD_ONLY : définit le type d'ensemble de résultats sur déplacement avant uniquement.
  • TYPE_SCROLL_SENSITIVE : définit le type d'ensemble de résultats sur sensible au défilement.
  • TYPE_SCROLL_INSENSITIVE : définit le type d'ensemble de résultats sur non sensible au défilement.

La valeur par défaut est TYPE_FORWARD_ONLY. Dans les fichiers de script SQL, la valeur de type de l'ensemble de résultats peut être remplacée dans une instruction SQL spécifique en indiquant le type d'ensemble de résultats dans une ligne de commentaire juste avant l'instruction.

Pour obtenir des informations sur la configuration du type d'ensemble de résultats pour les instructions SQL dans un fichier XML InfoSphere Optim Query Workload Tuner, voir Notes concernant le fichier de sortie pureQueryXML

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 de nouveaux messages au contenu existant du 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.
-help
Affiche des informations sur l'utilisation.

Notes concernant le fichier de sortie pureQueryXML

La liste suivante contient des informations concernant l'utilisation du fichier pureQueryXML :
  • Lors de la création d'un fichier pureQueryXML à partir d'un fichier de script SQL ou d'un fichier XML InfoSphere Optim Query Workload Tuner, vérifiez que les critères suivants sont remplis pour chaque instruction SQL :
    • Le texte de l'instruction SQL du fichier correspond à l'instruction SQL émise par l'application. La capitalisation et les blancs des instructions doivent correspondre.
    • Les paramètres de mise en suspens, d'accès concurrent et de type de l'ensemble de résultats pour l'instruction SQL dans le fichier correspondent aux paramètres de l'instruction SQL émise par l'application.

    Si les informations ne correspondent pas, l'optimisation client pureQuery ne met pas en correspondance l'instruction SQL et l'instruction émise par l'application lorsque la propriété executionMode de pureQuery Runtime est définie sur STATIC ou lorsque la propriété capturedOnly de pureQuery Runtime est définie sur TRUE.

    Les éléments suivants s'appliquent lorsque le fichier en entrée est un fichier XML Query Workload Tuner :
    • Le fichier XML contient certaines informations de registre spéciales pour les instructions SQL. Lorsque l'utilitaire GeneratePureQueryXml génère un fichier pureQueryXML à partir d'un fichier XML, les informations de registre spécial sont incluses dans le fichier pureQueryXML en tant que métadonnées. Il existe des différences entre les informations de registre spécial capturées par pureQuery Runtime et par Query Workload Tuner. L'utilitaire GeneratePureQueryXml inclut les informations de registre spécial normalement capturées par pureQuery Runtime.

      Lorsque vous configurez le fichier pureQueryXML à l'aide de l'utilitaire de configuration, vous pouvez spécifier l'option -groupSQLBySpecialRegisters pour regrouper les instructions SQL dans le fichier en fonction des paramètres de registre spécial. Vous pouvez également indiquer l'option -optionsFileForBind pour générer un exemple de fichier d'options StaticBinder contenant des options de liaison basées sur les paramètres de registre spécial. Pour obtenir des informations sur les options de configuration, voir Utilitaire Configure.

      Pour plus d'informations sur les informations de registre spécial suivies et enregistrées par pureQuery Runtime, voir : Suivi des changements apportés au registre spécial DB2 à l'aide de l'optimisation client pureQuery.

      Vous devez configurer une base de données DB2 for z/OS pour capturer des performances de statistiques SQL dans un fichier InfoSphere Optim Query Workload Tuner XML. Pour plus d'informations sur l'activation de la collection de statistiques, voir Capture des statistiques de performance DB2 for z/OS dans un fichier InfoSphere Optim Query Workload Tuner XML.

    • Avant d'ajouter une instruction SQL au fichier pureQueryXML, l'utilitaire prépare l'instruction pour collecter les métadonnées correspondantes. Si une valeur du registre spécial CURRENT SCHEMA figure dans le fichier XML, l'utilitaire utilise cette valeur lors de la préparation.
    • Si l'utilitaire détermine que l'instruction SQL du fichier XML a été exécutée de façon statique, l'instruction n'est pas incluse dans le fichier de sortie pureQueryXML.
    • L'utilitaire GeneratePureQueryXml copie certaines statistiques du fichier XML dans le fichier de sortie pureQueryXML. Les statistiques du fichier XML en entrée dépendent du type et de la version de base de données et de la version de InfoSphere Optim Query Workload Tuner. Ces statistiques n'affectent pas la façon dont les instructions SQL du fichier pureQueryXML sont liées ou à la façon dont pureQuery Runtime met en correspondance les instructions SQL et les instructions émises par une application.

      Lorsque l'utilitaire ne trouve pas d'informations d'horodatage pour les instructions SQL, l'utilitaire utilise l'heure et la date actuelles.

    • Les attributs de curseur ne peuvent pas être spécifiés dans le fichier XML. Vous pouvez indiquer des attributs de curseur avec les options -resultSetType, -resultSetHoldability et -resultSetConcurrency de l'utilitaire GeneratePureQueryXml. Les options s'appliquent à toutes les instructions SQL du fichier XML.

      Pour les fichiers XML de DB2 for z/OS, la mise en suspens de l'ensemble de résultats de la préparation initiale d'une instruction SQL est stockée dans le fichier. Lorsque les informations de mise en suspens de l'ensemble de résultats se trouvent dans le fichier, l'utilitaire utilise cette valeur pour l'instruction SQL dans le fichier pureQueryXML de sortie.

      pureQuery Runtime prend en compte l'instruction SQL et les attributs du curseur d'instruction pour contrôler le mode d'exécution d'une instruction SQL. Par exemple, vous pouvez configurer pureQuery Runtime pour qu'il exécute des instructions SQL en mode statique. Si l'instruction et les attributs dans le fichier pureQueryXML ne correspondent pas à l'instruction et aux attributs d'application, pureQuery Runtime n'exécute pas l'instruction en mode statique.

    • Si les instructions SQL du fichier de sortie pureQueryXML requièrent des options de liaison différentes pour une exécution statique, vous pouvez utiliser l'éditeur pureQueryXML dans le plan de travail afin de regrouper les instructions SQL en ensembles d'instructions. Vous pouvez ensuite spécifier des options de liaison différentes pour les ensembles d'instructions lorsque vous exécutez l'utilitaire StaticBinder.

      Vous pouvez exécuter l'utilitaire StaticBinder à l'aide de l'option -statementBindError en indiquant la valeur REMOVE ou MARK_INVALID. L'utilitaire StaticBinder ignore les instructions SQL qui renvoient une erreur SQL lors du processus de liaison.

  • Les éléments suivants s'appliquent lorsque l'entrée est un ensemble d'instructions SQL récupéré d'un cache d'instruction dynamique DB2 for z/OS :
    • Vous devez configurer un sous-système DB2 for z/OS comme cible de cette opération de récupération. Pour plus d'informations sur la configuration d'un sous-système DB2 for z/OS, voir Configuration d'un sous-système z/OS pour récupérer des instructions SQL à partir d'une mémoire cache dynamique.
    • L'utilitaire GeneratePureQueryXml autorise les propriétés pour la définition des valeurs par défaut pour certains registres spéciaux et attributs de curseur. En règle générale, ces attributs ne sont pas pris en charge lors de la récupération d'instructions SQL à partir du cache d'instruction dynamique. Puisque les valeurs réelles sont récupérées du cache, la substitution des valeurs n'est pas nécessaire.
    • Avant d'ajouter une instruction SQL au fichier pureQueryXML, l'utilitaire prépare l'instruction pour collecter les métadonnées correspondantes. S'il existe une valeur du registre spécial CURRENT SCHEMA, l'utilitaire utilise la valeur du registre spécial CURRENT SCHEMA lors de la préparation.
    • L'utilitaire utilise les informations d'horodatage de la mémoire cache dynamique lors du traitement des instructions SQL récupérées.
    • Le contenu du fichier de sortie pureQueryXml dépend du contenu actuel du cache d'instruction dynamique DB2 et des valeurs de l'option filterCacheBy spécifiées. Les éléments suivants peuvent affecter les instructions récupérées par l'utilitaire GeneratePureQueryXml :
      • A tout moment, le cache peut contenir des instructions préparées par différentes applications. Si vous récupérez des instructions à partir du cache sans spécifier de filtre, vous pouvez récupérer des instructions qui ne sont pas associées à votre application.
      • Lorsqu'un filtre est spécifié, il peut éliminer une instruction utilisée par votre application. Par exemple, supposons que l'application A et l'application B utilisent une instruction SQL commune. Elles peuvent alors partager cette instruction dans le cache, mais DB2 peut enregistrer que cette instruction est insérée dans le cache par l'application A. Si vous spécifiez un filtre (par exemple, clientProgramId B), l'instruction n'apparaît pas dans le fichier de sortie.
      • Les instructions exécutées lors d'une exécution récente de votre application peuvent ne pas figurer dans le cache. Avec la grandeur de taille du cache offerte par les éditions récentes de DB2, cette situation peut ne pas survenir.
  • Le fichier de sortie pureQueryXML ne peut être directement utilisé avec l'optimisation client pureQuery pour exécuter des instructions SQL en mode statique. Avant d'utiliser l'utilitaire StaticBinder, utilisez l'utilitaire Configure pour modifier le fichier pureQueryXML afin qu'il puisse être utilisé avec l'optimisation client pureQuery.
  • Le fichier de sortie pureQueryXML ne contient pas d'informations relatives à l'exécution de l'application telles que des informations sur la trace de pile et les registres spéciaux disponibles dans un fichier pureQueryXML créé lorsque pureQuery Runtime capture des instructions SQL à partir d'une application utilisant l'optimisation client pureQuery.
  • Le fichier de sortie pureQueryXML ne contient pas les informations d'instruction SQL suivantes, utilisées par l'optimisation client pureQuery pour identifier une instruction en tant qu'instruction SQL lors de l'exécution :
    • Noms de colonne de clé autogénérés
    • Index Noms de colonne de clé autogénérés
    • Indicateur de clé autogénéré

    Si une application utilisant l'optimisation de client pureQuery est configurée pour exécuter des instructions SQL de façon statique ou en mode capture uniquement, et utilise un fichier pureQueryXML créé par l'utilitaire GeneratePureQueryXml, une instruction émise par l'application ne s'exécute pas de façon statique si l'instruction utilise l'une des trois fonctionnalités, même si le texte des instructions SQL est identique.

Dans l'exemple suivant, le fichier pureQueryXML c:\statements.pdqxml est créé. Il contient des informations sur les instructions figurant dans le fichier de script SQL c:\mystatements.sql. La valeur de l'option -sqlLiteralSubstitution est définie sur ENABLE afin de remplacer les valeurs littérales par des marqueurs de paramètres dans les instructions SQL.
java com.ibm.pdq.tools.GeneratePureQueryXml 
    -username db2admin –password mypass 
    –url jdbc:db2://localhost:50000/mydb 
    -sqlLiteralSubstitution ENABLE
    –pureQueryXml "C:\statements.pdqxml" –inputSql "C:\mystatements.sql"

Identification des instructions SQL en double dans un fichier SQL

L'utilitaire GeneratePureQueryXml identifie deux instructions SQL comme doublon si le texte des deux instructions est identique, à l'exception des espaces de début et de fin, et si les attributs suivants sont identiques :
  • Type de l'ensemble de résultats
  • Accès concurrent de l'ensemble de résultats
  • Mise en suspens de l'ensemble de résultats

Les deux entrées suivantes d'un fichier SQL sont considérées comme identiques. Pour les instructions SQL, seuls les espaces de début et de fin sont différents :

-- resultSetType=TYPE_FORWARD_ONLY
-- resultSetConcurrency=CONCUR_READ_ONLY
         SELECT * FROM EMPLOYEE     ;

-- resultSetType=TYPE_FORWARD_ONLY
-- resultSetConcurrency=CONCUR_READ_ONLY
SELECT * FROM EMPLOYEE     ;

Les deux entrées suivantes d'un fichier SQL ne sont pas considérées comme identiques. Le nombre d'espaces dans les instructions SQL est différent :

-- resultSetType=TYPE_FORWARD_ONLY
-- resultSetConcurrency=CONCUR_READ_ONLY
SELECT * FROM EMPLOYEE;

-- resultSetType=TYPE_FORWARD_ONLY
-- resultSetConcurrency=CONCUR_READ_ONLY
SELECT * FROM EMPLOYEE;

Ces deux entrées de fichier SQL ne sont pas identiques car les attributs de curseur spécifiés sont différents :

-- resultSetType=TYPE_FORWARD_ONLY
-- resultSetConcurrency=CONCUR_READ_ONLY
SELECT * FROM EMPLOYEE;

-- resultSetType=TYPE_SCROLL_SENSITIVE
-- resultSetConcurrency=CONCUR_READ_ONLY
SELECT * FROM EMPLOYEE;
Les entrées suivantes se trouvent dans un fichier SQL en entrée. Les instructions SQL sont identiques, à l'exception des valeurs littérales.
SELECT * FROM EMPLOYEE WHERE EMPNO = '000010'
SELECT * FROM EMPLOYEE WHERE EMPNO = '000020'
SELECT * FROM EMPLOYEE WHERE EMPNO = '000030'
Si vous exécutez l'utilitaire GeneratePureQueryXml avec l'option sqlLiteralSubstitution définie sur ENABLE, les valeurs littérales sont remplacées par un marqueur de paramètre et les doublons créés par le remplacement sont supprimés. Il en résulte une instruction SQL unique écrite dans le fichier pureQueryXML :
SELECT * FROM EMPLOYEE WHERE EMPNO = ?

Commentaires