Das Dienstprogramm ManageRepository erstellt ein Repository in einer Datenbank und verwaltet es. Das Repository enthält pureQuery-Daten, die von pureQuery-aktivierten Anwendungen, wie Konfigurationsdaten und pureQueryXML-Daten, verwendet werden. Das Repository kann erfasste SQL-Daten aus Anwendungen speichern, die für die pureQuery-Clientoptimierung aktiviert sind.
Es muss eine Datenbank verfügbar sein, die die Installation eines Repositorys unterstützt, und die Anwendung muss für die Verwendung der pureQuery-Clientoptimierung konfiguriert sein. Informationen zu den pureQuery-Systemvoraussetzungen finden Sie in Systemvoraussetzungen für Optim pureQuery Runtime.
In den folgenden Abschnitten wird das Dienstprogramm ManageRepository beschrieben:
Eine Beschreibung der im Diagramm verwendeten Konventionen finden Sie in Syntaxdiagramme lesen.
Operationen auf Repository-Ebene
Zu den Operationen von ManageRepository auf Repository-Ebene gehören das Erstellen eines Repositorys in einer Datenbank, das Entfernen eines Repositorys aus einer Datenbank, das Überprüfen der Gültigkeit des Repositorys und das Anzeigen der Version des Repositorys.
Wenn Sie die SQL-Anweisungen anzeigen wollen, die erforderlich sind, um ein Repository zu erstellen, zu entfernen oder zu binden, verwenden Sie die Option -generateScriptOnly.
Die Anweisungen werden generiert, ohne die Operation auszuführen. Wenn Sie die SQL-Anweisungen ändern und die Anweisungen absetzen, können Sie das Repository unter Verwendung von -verify repository überprüfen.
Wenn Sie pureQuery erstellen wollen, das nur die pureQueryXML-Informationen enthält und in dem kein erfasstes SQL gespeichert wird, verwenden Sie die Option
repositoryType mit dem Parameter -pureQueryRuntimeOnly.
Syntax des Befehls ManageRepository für Operationen auf Repository-Ebene

(1)
>>-------java--com.ibm.pdq.tools.ManageRepository--------------->
>--+- -create repository-- -repositoryType--+-pureQueryOnly--------+-+-->
| '-pureQueryRuntimeOnly-' |
| (2) |
+------- -bind packages-------------------------------------------+
+- -verify repository---------------------------------------------+
+- -report--+-repositoryData-- -file--Dateiname-+-----------------+
| '-repositoryVersion-----------------' |
'- -delete repository--+--------------------+---------------------'
| .-FALSE-. |
'- -force--+-TRUE--+-'
>--| Verbindungsinformationen |--------------------------------->
>--+-------------------------------------------------+---------->
| (3) |
'------- -generateScriptOnly--Pfad-zu-Scriptdatei-'
>--+--------+--------------------------------------------------><
'- -help-'
Verbindungsinformationen
|-- -repositoryURL--URL-zu-Repository-Datenbank----------------->
>-- -repositoryUsername--Benutzer-ID-- -repositoryPassword--Kennwort-->
>-- -repositoryDriverClass--Treiberklasse-----------------------|
Anmerkungen:
- Sie können die Optionen in beliebiger Reihenfolge angeben.
- Die Option -bind packages darf nur mit einer Datenbank verwendet werden, die statisches SQL unterstützt.
- Die Option -generateScriptOnly darf nicht zusammen mit der Option -report verwendet werden.
Beschreibung der Optionen für Operationen auf Repository-Ebene
In der folgenden Liste werden die unterstützten ManageRepository-Optionen und -Variablen beschrieben.
- -create repository
- Das Dienstprogramm ManageRepository verwendet die Verbindungsinformationen, um den Typ der Datenbankplattform zu ermitteln, und setzt die entsprechenden DDL-Anweisungen ab, um die Tabellen im angegebenen Schema zu erstellen.
Es wird eine Nachricht mit der Mitteilung angezeigt, dass durch diesen Befehl Daten ersetzt werden.
Der Benutzer hat die Option, die Aktion abzubrechen.
- -repositoryType
- Geben Sie den Typ des zu erstellenden Repositorys an. Die folgenden Typen werden für Repositorys unterstützt:
- pureQueryOnly. Der Standard. Das Repository enthält Informationen aus pureQueryXML-Dateien, die von den Bindeoptionen der pureQuery-Clientoptimierungsoptionen, generierten erfassten SQL-Optionen und pureQueryXML-Daten verwendet werden.
- pureQueryRuntimeOnly Das Repository enthält nur die Informationen aus pureQueryXML-Dateien, die von der pureQuery-Clientoptimierung verwendet werden.
Verwenden Sie die Option
-generateScriptOnly, um ein SQL-Script zu generieren, das die SQL-Anweisungen zum Erstellen eines Repositorys enthält, ohne das Repository zu erstellen. Nachdem Sie das Script geprüft haben, können Sie das Script ausführen, um das Repository zu erstellen. Wenn Sie die SQL-Anweisungen ändern und das Script ausführen, können Sie das Repository mit der Option -verify repository prüfen.
- -bind packages
- Gibt auf Datenbankplattformen, die statisches SQL unterstützen, an dass Datenbankpakete erstellt werden, um den Zugriff auf das Repository zu regeln.
Der Objektgruppenname und die Paketnamen werden vom Dienstprogramm ausgewählt und können vom Benutzer nicht geändert werden.
Nachdem das Repository erstellt wurde, werden die Optionen -grant und -revoke des Dienstprogramms ManageRepository verwendet, um den Paketen Zugriffsrechte zu erteilen oder zu entziehen. Informationen dazu, wie den Paketen Zugriffsrechte erteilt werden, finden Sie in Operationen für die Berechtigungsverwaltung von Laufzeitgruppen
Verwenden Sie die Option -generateScriptOnly, um nur das Script zu generieren, ohne dass die Bindeoperation ausgeführt wird.
- -report repositoryData | repositoryVersion
- Zeigt Informationen zum Repository an.
- repositoryData -file Dateiname
- Generiert einen HTML-Bericht mit der Beschreibung der Laufzeitgruppeninformationen im Repository. Der Dateiname ist der Pfad und Dateiname für die Datei, die den Bericht enthält.
- repositoryVersion
- Gibt die Version des Repositorys zurück.
- -report repositoryVersion
- -verify repository
- Prüft die Tabellen im Repository, um sicherzustellen, dass die Tabellen mit den Spalten und den Spaltentypen wie erwartet korrekt erstellt wurden.
Außerdem werden Tests zum richtigen Lese- und Schreibzugriff auf das Repository ausgeführt, um sicherzustellen, dass die ausführende Benutzer-ID über die richtigen Berechtigungen verfügt.
Zur zurückgegebenen Ausgabe gehören Informationen zu den verschiedenen Komponenten des Repositorys und zu den Nachrichten, die angeben, wenn Probleme im Zusammenhang mit dem Repository auftreten, wie falsche Berechtigungen oder Tabellen mit fehlenden Spalten.
Verwenden Sie die Option -generateScriptOnly, um ein SQL-Script zu generieren, ohne das Repository zu prüfen.
- -delete repository
- Löscht alle vom Repository verwendeten Tabellen. Alle Daten des Repositorys werden gelöscht.
Es wird eine Nachricht angezeigt, die den Benutzer auffordert, das Entfernen der Datenbanktabellen zu bestätigen.
- -force TRUE|FALSE
- Ein boolescher Wert, um das Entfernen des Repositorys zu bestätigen.
Verwenden Sie -force TRUE, um das Entfernen zu bestätigen, ohne eine Nachricht anzuzeigen.
Verwenden Sie die Option -generateScriptOnly, um ein SQL-Script zu generieren, ohne das Repository zu löschen.
- -generateScriptOnly >Pfad-zu-Scriptdatei
- Generiert ein SQL-Script mit den SQL-Anweisungen zum Simulieren der Operation ManageRepository, ohne die Operation auszuführen.
Sie können das Script so modifizieren, dass Tabellen nicht in die Standardtabellenbereiche, sondern in ihre eigenen Tabellenbereiche gestellt werden. Der Schemaname, Tabellennamen oder Spaltennamen können jedoch nicht modifiziert werden.
Nach der Prüfung und Änderung des Scripts kann ein Datenbankadministrator das Repository durch Ausführen des Scripts erstellen. So fügt der Datenbankadministrator beispielsweise den SQL-Anweisungen im Script Tabellenbereich hinzu.
Nach dem Erstellen des Repositorys können Sie das Repository mit der Option -verify repository prüfen.
Für die Option -bind packages werden der Objektgruppenname und die Paketnamen vom Dienstprogramm ausgewählt und können vom Benutzer nicht geändert werden.
- -help
- Zeigt Übersichtsdaten zur Verwendung an.
Beschreibung der Optionen für Verbindungsinformationen
In der folgenden Liste werden die für die Herstellung einer Verbindung zur Repository-Datenbank erforderlichen Informationen beschrieben:
- -repositoryURL URL-zu-Repository-Datenbank
- URL zur Repository-Datenbank
- -repositoryUsername Benutzer-ID -repositoryPassword Kennwort
- ID und Kennwort für die Herstellung der Verbindung zur Datenbank
- -repositoryDriverClass Treiberklasse
- Vollständig qualifizierter Klassenname der JDBC-Treiberklasse, der zum Herstellen der Verbindung zur Repository-Datenbank verwendet werden soll.
Operationen für die Laufzeitgruppenverwaltung
Zu den Laufzeitgruppenoperationen von ManageRepository gehören das Erstellen, Verwalten und Entfernen von Laufzeitgruppen und Gruppenversionen in einem Repository.
Die in einer Laufzeitgruppenversion gespeicherten pureQuery-Daten enthalten pureQuery-Konfigurationsdaten, pureQueryXML-Daten und SQL-Daten, die aus den für die pureQuery-Clientoptimierung aktivierten Anwendungen optional erfasst wurden.
Laufzeitgruppenversionen enthalten außerdem andere Informationen, die von pureQuery Runtime verwendet werden, um die Laufzeit und die aktive Version der Gruppe anzugeben.
Syntax für Operationen für die Laufzeitgruppenverwaltung

(1)
>>-------java--com.ibm.pdq.tools.ManageRepository--------------->
>--+- -create runtimeGroup--+---------------------+-------------------------------------------------+-->
| '-| pureQuery-Daten |-' |
+- -update runtimeGroup--+---------------------+-------------------------------------------------+
| '-| pureQuery-Daten |-' |
+- -delete runtimeGroup--+--------------------+--------------------------------------------------+
| | .-FALSE-. | |
| '- -force--+-TRUE--+-' |
+- -delete incremental-- -inputDirectory--Pfad-zu-Verzeichnis-- -incrementalCapture--Dateipräfix-+
+- -list runtimeGroupVersions--------------------------------------------------------------------+
+- -activate runtimeGroup------------------------------------------------------------------------+
+- -deactivate runtimeGroup----------------------------------------------------------------------+
'- -copy runtimeGroup--+---------------------------------+-- -targetVersion--Zielversion---------'
'- -sourceVersion--Quellenversion-'
>-- -runtimeGroupId--Gruppen-ID--------------------------------->
(2)
>-------- -runtimeGroupVersion--Version------------------------->
>--+-----------------------------------------+--+--------+------>
'- -contact--Ansprechpartnerinformationen-' '- -help-'
>--| Verbindungsinformationen |--------------------------------><
pureQuery-Daten
(3)
|-------- -inputDirectory--Pfad-zu-Verzeichnis------------------>
>--+----------------------------------------+------------------->
'- -pureQueryXml--pureQueryXML-Dateiname-'
>--+--------------------------------------------------------+--->
'- -pureQueryProperties--Datei-mit-Laufzeiteigenschaften-'
>--+------------------------------------------------------------------+-->
'- -optionsFileForConfigure -Datei-mit-Konfigurationseigenschaften-'
>--+----------------------------------------------------+-------|
'- -optionsFileForBind -Datei-mit-Bindeeigenschaften-'
Verbindungsinformationen
|-- -repositoryURL--URL-zu-Repository-Datenbank----------------->
>-- -repositoryUsername--Benutzer-ID-- -repositoryPassword--Kennwort-->
>-- -repositoryDriverClass--Treiberklasse-----------------------|
Anmerkungen:
- Sie können die Optionen in beliebiger Reihenfolge angeben.
- Die Option -runtimeGroupVersion kann nicht zusammen mit der Option -copy runtimeGroup angegeben werden.
- Wenn Sie pureQuery-Daten aktualisieren, muss mindestens eine Datei angegeben werden.
Beschreibung der Optionen für die Laufzeitgruppenverwaltung
In der folgenden Liste werden die unterstützten ManageRepository-Optionen und -Variablen beschrieben.
- -create runtimeGroup
- Erstellt eine Laufzeitgruppe mit der angegebenen Gruppen-ID und Version.
Ist die Laufzeitgruppen-ID bereits im Repository vorhanden, wird ein Fehler angezeigt.
Beim Erstellen einer Laufzeitgruppenversion gibt es die folgenden pureQuery-Standardeinstellungen:
- Die Eigenschaft executionMode ist auf STATIC gesetzt (statisches SQL ausführen und dynamisches SQL ermöglichen).
- Die Eigenschaft captureMode ist auf ON gesetzt (der Aufzeichnungsmodus ist auf inkrementell gesetzt).
Wenn Sie die Standardeinstellungen überschreiben und andere Eigenschaften angeben wollen, geben Sie die Dateien an, die die Eigenschaften und ihre Werte enthalten.
- -update runtimeGroup
- Die Daten in der Laufzeitgruppenversion werden mit den pureQuery-Daten aus den angegebenen Dateien aktualisiert.
- -delete runtimeGroup
- Löscht die Laufzeitgruppe Gruppen-ID aus dem Repository.
Es wird eine Nachricht angezeigt, die den Benutzer auffordert, das Entfernen der Laufzeitgruppe zu bestätigen. Der Benutzer hat die Option, die Aktion abzubrechen.
- -force TRUE|FALSE
- Geben Sie TRUE oder FALSE an, um das Entfernen der Laufzeitgruppe zu bestätigen.
TRUE löscht die Laufzeitgruppe ohne Bestätigung. Der Standardwert ist FALSE.
Verwenden Sie die Option -force TRUE, um das Entfernen zu bestätigen, ohne eine Nachricht anzuzeigen.
- -delete incremental
- Löscht erfasste SQL-Daten aus einer Laufzeitgruppenversion. Die Daten in den angegebenen erfassten SQL-Dateien werden mit den Repository-Daten verglichen und wenn sie übereinstimmen, werden die erfassten SQL-Daten des Repositorys entfernt.
Nachdem die erfassten SQL-Daten mit pureQueryXML-Daten für eine Laufzeitgruppenversion zusammengeführt wurden, können die für die Version erfassten SQL-Daten gelöscht werden.
- -inputDirectory Pfad-zu-Verzeichnis
- Der vollständige Pfad zum Verzeichnis, in dem sich die erfassten SQL-Dateien befinden.
- -capture-prefix Dateipräfix
- Das von den erfassten SQL-Dateien verwendete Präfix.
- -list runtimeGroupVersions
- Zeigt Informationen zu den Laufzeitgruppenversionen an.
- -activate runtimeGroup
- Aktivieren einer Laufzeitgruppenversion.
Wenn pureQuery Runtime auf eine Laufzeitgruppe im Repository zugreift, werden die pureQuery-Informationen in der aktiven Laufzeitgruppenversion verwendet.
- -deactivate runtimeGroup
- Inaktivieren einer Laufzeitgruppe.
Wenn pureQuery Runtime auf eine Laufzeitgruppe im Repository zugreift, werden die pureQuery-Informationen in Laufzeitgruppen, die nicht aktiv sind, ignoriert.
- -copy runtimeGroup
- Kopiert die Laufzeitgruppendaten aus der in der Option -sourceVersion angegebenen Version in dieselbe Gruppe mit dem in der Option -targetVersion angegebenen Versionsnamen.
- -sourceVersion Quellenversion
- Gibt eine vorhandene Version in der Laufzeitgruppe an, die zum Erstellen einer neuen Laufzeitgruppenversion verwendet wird.
Wird keine Quellenversion angegeben, wird die aktive Laufzeitgruppenversion verwendet. Wird keine Quellenversion angegeben und ist keine aktive Laufzeitgruppenversion vorhanden, wird ein Fehler angezeigt.
- -targetVersion Zielversion
- Gibt die Laufzeitgruppenversion an, die beim Kopieren der Quellenversion der Laufzeitgruppenversion erstellt wird.
- -runtimeGroup Gruppen-ID
- Gibt die ID der Repository-Laufzeitgruppe an.
- -runtimeGroupVersion Version
- Gibt den Namen einer Laufzeitgruppenversion an. Die Option -runtimeGroupVersion kann nicht zusammen mit der Option -copy runtimeGroup angegeben werden.
- -contact Ansprechpartnerinformationen
- Eine Zeichenfolge, die optionale Ansprechpartnerinformationen angibt, die mit der Laufzeitgruppenversion gespeichert werden.
- -help
- Zeigt Übersichtsdaten zur Verwendung an.
Beschreibung der PureQuery-Datenoptionen
In der folgenden Liste werden die pureQuery-Datenoptionen beschrieben:
- -inputDirectory Pfad-zu-Verzeichnis
- Der vollständige Pfad zum Verzeichnis der pureQuery-Dateien.
- -pureQueryXml pureQueryXML-Dateiname
- Der Name der pureQueryXML-Datei.
- -pureQueryProperties Laufzeiteigenschaftendatei
- Der Name der pureQuery-Laufzeiteigenschaftendatei.
- -optionsFileForConfigure Datei-mit-Konfigurationseigenschaften
- Die Datei, die die vom Dienstprogramm Configure verwendeten Optionen enthält.
- -optionsFileForBind Datei-mit-Bindeeigenschaften
- Die Datei, die die Optionen enthält, die vom Dienstprogramm StaticBinder zum Binden von SQL-Anweisungen in der pureQueryXML-Datei verwendet werden.
Beschreibung der Optionen für Verbindungsinformationen
In der folgenden Liste werden die für die Herstellung einer Verbindung zur Repository-Datenbank erforderlichen Informationen beschrieben:
- -repositoryURL URL-zu-Repository-Datenbank
- URL zur Repository-Datenbank
- -repositoryUsername Benutzer-ID -repositoryPassword Kennwort
- ID und Kennwort für die Herstellung der Verbindung zur Datenbank
- -repositoryDriverClass Treiberklasse
- Vollständig qualifizierter Klassenname der JDBC-Treiberklasse, der zum Herstellen der Verbindung zur Repository-Datenbank verwendet werden soll.
Operationen für die Berechtigungsverwaltung von Laufzeitgruppen
Die Operationen für die Berechtigungsverwaltung werden ausgeführt nachdem die SQL-Erfassungsdaten in der Repository-Datenbank gespeichert wurden.
Ein Administrator muss den Anwendungen Lese- und Schreibberechtigungen für die Repository-Datenbanktabellen erteilen.
Syntax für Operationen für die Berechtigungsverwaltung

(1)
>>-------java--com.ibm.pdq.tools.ManageRepository--------------->
>--+- -revoke-+------------------------------------------------->
'- -grant--'
.-,----------------.
V |
>----"--grantees--(----Berechtigungs-ID-+--) -"----------------->
>-- -privilege--+-tableAccess----------+------------------------>
| (2) |
'-------executePackage-'
>-- -accessLevel -+-APPLICATION-+------------------------------->
'-MANAGER-----'
>--| Verbindungsinformationen |--+--------+--------------------->
'- -help-'
>--+--------------------------------------------+--------------><
'- -generateScriptOnly--Pfad-zu-Ausgabedatei-'
Verbindungsinformationen
|-- -repositoryURL--URL-zu-Repository-Datenbank----------------->
>-- -repositoryUsername--Benutzer-ID-- -repositoryPassword--Kennwort-->
>-- -repositoryDriverClass--Treiberklasse-----------------------|
Anmerkungen:
- Sie können die Optionen in beliebiger Reihenfolge angeben.
- Auf Plattformen, die statisches SQL unterstützen ist executePackage die einzige Option, die unterstützt wird, nachdem -bind packages abgesetzt wurde.
Beschreibung der Berechtigungsverwaltungsoptionen für Repositorys
In der folgenden Liste werden die unterstützten ManageRepository-Optionen und -Variablen beschrieben:
- -grant
- Erteilt den in der Liste grantees aufgeführten Benutzern den in der Option -privilege angegebenen Zugriff.
- -revoke
- Entzieht alle Berechtigungen für Metadatenrepositorytabellen, die den in der Liste grantees angegebenen Benutzern erteilt wurden.
Die Angabe einer Rolle ist für die Option -revoke nicht erforderlich.
- "grantees(erste_ID, zweite_ID,
...)"
- Schlüsselwort, das die Liste der beteiligten Datenbankbenutzer angibt. Die Klausel für Berechtigte, das Schlüsselwort und die Benutzerliste, muss mit einem Anführungszeichen (") beginnen und enden. Die Benutzernamen müssen durch Kommas voneinander getrennt werden.
Im folgenden Beispiel werden drei Berechtigungs-IDs als Berechtigte aufgelistet.
"grantees(test1, test2, user1)"
- Berechtigungs-ID
- Die Datenbankbenutzer-ID, der Berechtigungen erteilt oder entzogen werden.
PUBLIC kann als ID angegeben werden.
Die Berechtigungs-ID muss die gleiche Groß-/Kleinschreibung aufweisen wie die Datenbankbenutzer-ID. Wenn beispielsweise die DB2-Benutzer-ID in Großbuchstaben geschrieben ist, muss die
Berechtigungs-ID in Großbuchstaben eingegeben werden.
- -privilege tableAccess|executePackage
- Geben Sie den Typ des zu erteilenden Zugriffsrechts an. Die folgenden Werte werden für Zugriffsrechte unterstützt:
- tableAccess
- Zugriffsrecht für Plattformen, die nur dynamisches SQL unterstützen. Damit ist sichergestellt, dass dynamische Anwendungen Zugriff auf die zugrundeliegenden Metadatenrepositorytabellen haben. tableAccess ist für dynamische SQL-Umgebungen, in denen Zugriffsrechte auf die Repository-Tabellen selbst erforderlich sind.
- executePackage
- Zugriffsrecht für Plattformen, die statisches SQL unterstützen, auf denen die ManageRepository-Option -bind
packages abgesetzt wurde. Stellt sicher, dass Anwendungen auf das Metadatenrepository zugreifen können, indem sie die statisch gebundenen SQL-Anweisungen verwenden, die vom Dienstprogramm ManageRepository erstellt wurden.
- -accessLevel MANAGER|APPLICATION
Die folgenden Werte werden für die Option
-accessLevel unterstützt:
- APPLICATION
- Eine Benutzer-ID, der das Zugriffsrecht APPLICATION erteilt wurde, darf die pureQueryXML-Daten lesen und in die Tabellen schreiben, die zum Speichern der erfassten SQL-Daten verwendet werden.
- MANAGER
- Das Zugriffsrecht MANAGER erteilt uneingeschränkten Zugriff auf alle Metadatenrepository-Tabellen. Die Berechtigungen werden der Berechtigtenliste mit Benutzer-IDs erteilt.
Wenn anstatt eines Repositorys ein Optim Performance
Manager-Repository das Ziel ist, ist nur die Zugriffsebene MANAGER verfügbar.
- -generateScriptOnly >Pfad-zu-Scriptdatei
- Generiert ein SQL-Script mit den SQL-Anweisungen zum Simulieren der Operation ManageRepository, ohne die Operation auszuführen.
Nach der Prüfung und Änderung des Scripts kann ein Datenbankadministrator das Repository durch Ausführen des Scripts erstellen. Nach dem Erstellen des Repositorys können Sie das Repository mit der Option
-verify repository prüfen.
Für die Option -bind packages werden der Objektgruppenname und die Paketnamen vom Dienstprogramm ausgewählt und können vom Benutzer nicht geändert werden.
- -help
- Zeigt Übersichtsdaten zur Verwendung an.
Beschreibung der Optionen für Verbindungsinformationen
In der folgenden Liste werden die für die Herstellung einer Verbindung zur Repository-Datenbank erforderlichen Informationen beschrieben:
- -repositoryURL URL-zu-Repository-Datenbank
- URL zur Repository-Datenbank
- -repositoryUsername Benutzer-ID -repositoryPassword Kennwort
- ID und Kennwort für die Herstellung der Verbindung zur Datenbank
- -repositoryDriverClass Treiberklasse
- Vollständig qualifizierter Klassenname der JDBC-Treiberklasse, der zum Herstellen der Verbindung zur Repository-Datenbank verwendet werden soll.
Operationen zum Extrahieren, Exportieren und Importieren
Wenn die inkrementelle Erfassung festgelegt ist, fährt das pureQuery-Clientoptimierungsprogramm mit der Erfassung neuer SQL-Anweisungen und der Aufzeichnung von SQL-Aktivitäten fort, so dass veraltete SQL-Anweisungen entfernt werden können. Abhängig von den Einstellungen in der pureQuery-Laufzeiteigenschaftendatei können die erfassten SQL-Daten in demselben Repository gespeichert werden, in dem die pureQueryXML-Datei gespeichert ist, oder in einem anderen Repository. Nach der Erfassung können die erfassten SQL-Daten mit pureQueryXML zusammengeführt werden, so dass neues pureQueryXML hochgeladen werden kann. Die einzelnen Schritte sind:
- Extrahieren der inkrementellen Daten.
- Verwenden des Dienstprogramms Merge, um die erfassten SQL-Dateien mit der pureQueryXML-Datei zusammenzuführen.
- Verwenden des Dienstprogramms Configure, um die aktualisierte pureQueryXML-Datei zu konfigurieren.
- Optionales Verwenden des Dienstprogramms StaticBind, um aus den Anweisungsgruppen in der pureQueryXML-Datei in einer Datenbank Pakete mit SQL-Anweisungen zu erstellen und die Pakete anschließend in der Datenbank zu binden.
- Aktualisieren der Laufzeitgruppe mit den neuen Daten.
Syntax für Operationen zum Extrahieren, Exportieren und Importieren von Daten

(1)
>>-------java--com.ibm.pdq.tools.ManageRepository--------------->
>--+- -export data-- -file--Pfad-und-Name-der-ZIP-Datei-+------->
+- -extract runtimeGroup--| pureQuery-Daten |--------+
'- -import data-- -file--Pfad-und-Name-der-ZIP-Datei-'
>-- -runtimeGroupId--Gruppen-ID--------------------------------->
>-- -runtimeGroupVersion--Versions-ID--------------------------->
>--| Verbindungsinformationen |--------------------------------->
>--+-------------------------------------------------+---------->
| (2) |
'-------| Erfasste SQL-Verbindungsinformationen |-'
>--+--------+--------------------------------------------------><
'- -help-'
pureQuery-Daten
(3)
|-------- -outputDirectory--Pfad-zu-Verzeichnis----------------->
>--+----------------------------------------+------------------->
'- -pureQueryXml--pureQueryXML-Dateiname-'
>--+--------------------------------------------------------+--->
'- -pureQueryProperties--Datei-mit-Laufzeiteigenschaften-'
>--+------------------------------------------------------------------+-->
'- -optionsFileForConfigure -Datei-mit-Konfigurationseigenschaften-'
>--+----------------------------------------------------+------->
'- -optionsFileForBind -Datei-mit-Bindeeigenschaften-'
>--+------------------------------+-----------------------------|
'- -incrementalCapture--Präfix-'
Verbindungsinformationen
|-- -repositoryURL--Repository-Datenbank-URL-------------------->
>-- -repositoryUsername--Benutzer-ID-- -repositoryPassword--Kennwort-->
>-- -repositoryDriverClass--Treiberklasse-----------------------|
Erfasste SQL-Verbindungsinformationen
|-- -incrementalRepositoryURL--Repository-Datenbank-URL--------->
>-- -incrementalRepositoryUsername--Benutzer-ID-- -incrementalRepositoryPassword--Kennwort-->
>-- -incrementalRepositoryDriverClass--Treiberklasse------------|
Anmerkungen:
- Sie können die Optionen in beliebiger Reihenfolge angeben.
- Wird nur mit der Option -extract runtimeGroup verwendet.
Geben Sie die Informationen zum Extrahieren der erfassten SQL-Daten an, wenn diese sich in einem von den übrigen pureQuery-Daten getrennten Repository befinden.
- Wenn Sie pureQuery-Daten aktualisieren, muss mindestens eine Datei angegeben werden.
Beschreibung der Optionen zum Exportieren und Extrahieren von Daten
In der folgenden Liste werden die unterstützten ManageRepository-Optionen und -Variablen beschrieben:
- -export data
- Exportiert pureQuery-Daten aus allen Versionen einer Laufzeitgruppe in eine ZIP-Datei. Die ZIP-Datei kann zum Importieren von Daten als Quelle verwendet werden.
- -file Pfad-und-Name-der-ZIP-Datei
- Der vollständige Pfad und Dateiname der ZIP-Datei, die die exportierten pureQuery-Daten der Laufzeitgruppe enthält.
- -extract runtimeGroup
- Extrahiert alle oder einige der pureQuery-Daten aus der angegebenen Laufzeitgruppenversion in mindestens eine Datei. Der Typ der pureQuery-Daten wird aus der Laufzeitgruppenversion in der angegebenen Datei extrahiert.
- -import data
- Importiert pureQuery-Daten aus der ZIP-Datei, die beim Exportieren der pureQuery-Daten aus einem Repository erstellt wurde.
Wurden die Daten über die ODS-Exportbenutzerschnittstelle (ODS – Operationsdatenspeicher) exportiert und wurde mindestens ein pureQuery-Projekt für den Export ausgewählt, werden nur die pureQuery-Daten des letzten Projekts in die mit der Option -runtimeGroupId angegebene Laufzeitgruppe importiert.
- -file Pfad-und-Name-der-ZIP-Datei
- Geben Sie den Pfad und Dateinamen einer ZIP-Datei an, in der sich die Exportdaten befinden. Die Datei wird verwendet, um pureQuery-Daten aus einem Repository einer Laufzeitgruppenversion zu exportieren oder um pureQuery in ein Repository einer Laufzeitgruppenversion zu importieren.
- -runtimeGroupId Gruppen-ID
- Gibt die ID der Repository-Laufzeitgruppe an.
- -runtimeGroupVersion Version
- Gibt die Versions-ID der Laufzeitgruppe an.
- -help
- Zeigt Übersichtsdaten zur Verwendung an.
Beschreibung der PureQuery-Datenoptionen
In der folgenden Liste werden die pureQuery-Datenoptionen beschrieben:
- -outputDirectory Pfad-zu-Verzeichnis
- Geben Sie den vollständigen Pfad zum Verzeichnis der pureQuery-Dateien an.
- -pureQueryXml pureQueryXML-Dateiname
- Geben Sie den Namen der pureQueryXML-Datei an.
- -pureQueryProperties Laufzeiteigenschaftendatei
- Geben Sie den Namen der pureQuery-Laufzeiteigenschaftendatei an.
- -optionsFileForConfigure Datei-mit-Konfigurationseigenschaften
- Geben Sie die Datei an, die die pureQuery-Eigenschaften zum Generieren von SQL-Erfassungsdateien enthält.
- -optionsFileForBind Datei-mit-Bindeeigenschaften
- Geben Sie die Datei an, die die pureQuery-Eigenschaften enthält, die zum Binden von SQL-Anweisungen in der pureQueryXML-Datei verwendet werden.
- -incrementalCapture Präfix
- Geben Sie das Dateipräfix an, das verwendet wird, wenn Gruppen erfasster SQL-Daten in Dateien exportiert werden. Die Namen der Dateien, die die extrahierten erfassten SQL-Daten enthalten, haben das Format Präfix_N.pdqxml, wobei N für eine ganze Zahl steht, die bei 1 beginnt und für jede während des Exports erstellte Datei ansteigt.
So können beispielsweise für die Option
-incrementalCapture
"testApp" die folgenden Dateien erstellt werden.
testApp_1.pdqxml
testApp_2.pdqxml
Die erfassten SQL-Daten können von einem anderen Repository als dem, in dem sich die pureQueryXML-Daten befinden, abgerufen werden. Geben Sie die Verbindungsinformationen in der Befehlszeile für das Repository an, in dem sich die erfasste SQL-Datenbank befindet.
Beschreibung der Optionen für Verbindungsinformationen
In der folgenden Liste werden die für die Herstellung einer Verbindung zur Repository-Datenbank erforderlichen Informationen beschrieben:
- -repositoryURL Repository-Datenbank-URL
- Geben Sie die URL zur Repository-Datenbank an.
- -repositoryUsername Benutzer-ID -repositoryPassword Kennwort
- Geben Sie die ID und das Kennwort für die Herstellung der Verbindung zur Datenbank an.
- -repositoryDriverClass Treiberklasse
- Geben Sie den vollständig qualifizierten Klassennamen der JDBC-Treiberklasse an, der zum Herstellen der Verbindung zur Repository-Datenbank verwendet werden soll.
Beschreibung der Optionen für Verbindungsinformationen für erfasstes SQL
Wird nur mit der Option extract runtimeGroup verwendet.
Wenn Sie pureQuery-Daten extrahieren, befindet sich das erfasste SQL möglicherweise in einer anderen Repository-Datenbank als die übrigen pureQuery-Daten. Die folgende Liste beschreibt die Verbindungsinformationen, die erforderlich sind, um eine Verbindung zu einer Repository-Datenbank herzustellen, die das erfasste SQL enthält.
- -incrementalRepositoryURL Repository-Datenbank-URL
- Geben Sie die URL zur Repository-Datenbank an.
- -incrementalRepositoryUsername Benutzer-ID -incrementalRepositoryPassword Kennwort
- Geben Sie die ID und das Kennwort für die Herstellung der Verbindung zur Repository-Datenbank an.
- -incrementalRepositoryDriverClass Treiberklasse
- Geben Sie den vollständig qualifizierten Klassennamen der JDBC-Treiberklasse an, der zum Herstellen der Verbindung zur Repository-Datenbank verwendet werden soll.
Bericht für die Unterschiede zwischen zwei pureQueryXML-Dateien
Die ManageRepostiory-Option -report pureQueryXMLChanges erstellt einen HTML-Bericht der Unterschiede zwischen zwei pureQueryXML-Dateien.
Sie können einen Bericht erstellen, der zwei Versionen einer pureQueryXML-Datei vergleicht, die mit einer Anwendung verwendet wird, die für die pureQuery-Clientoptimierung aktiviert ist.
Der Bericht enthält Zusammenfassungs- und Detailinformationen der Änderungen zwischen den beiden Dateien. Der Bericht enthält Folgendes:
- Informationen zu hinzugefügten, entfernten und geänderten Paketen wie Versions-ID und Objektgruppen-ID, Bindestatus und die Anzahl hinzugefügter, entfernter und geänderter SQL-Anweisungen.
- Informationen zu hinzugefügten, entfernten und geänderten SQL-Anweisungen in den Paketen wie Abschnittsnummer, Zeit der letzten Anweisungsausführung und Anzahl Anweisungsausführungen.
Die pureQueryXML-Dateien, die das Dienstprogramm ManageRepository vergleicht, müssen sich in Ihrem Dateisystem befinden. Eine Verbindung zu einer Datenbank ist erforderlich.
Syntax für das Generieren eines pureQueryXML-Unterschiedsberichts

(1)
>>-------java--com.ibm.pdq.tools.ManageRepository--------------->
>-- -report pureQueryXMLChanges - -oldPureQueryXml--pureQueryXML-Datei-- -newPureQueryXml--pureQueryXML-Datei-- -file--Berichtsdatei-><
Verbindungsinformationen
|-- -repositoryURL--URL-zu-Repository-Datenbank----------------->
>-- -repositoryUsername--Benutzer-ID-- -repositoryPassword--Kennwort-->
>-- -repositoryDriverClass--Treiberklasse-----------------------|
Anmerkungen:
- Sie können die Optionen in beliebiger Reihenfolge angeben.
Beschreibung von Optionen zum Generieren eines Berichts mit Unterschieden zwischen zwei pureQueryXML-Dateien
In der folgenden Liste werden die ManageRepository-Optionen und -Variablen beschrieben, mit denen der Bericht generiert wird:
- -report pureQueryXMLChanges
- Generiert einen HTML-Bericht der Unterschiede zwischen den beiden pureQueryXML-Dateien.
- -oldPureQueryXml ursprüngliche pureQueryXML-Datei
- Gibt den Namen der ursprünglichen pureQueryXML-Datei an.
- -newPureQueryXml aktualisierte pureQueryXML-Datei
- Gibt den Namen der aktualisierten pureQueryXML-Datei an.
- -file Dateiname
- Gibt den Namen der Datei an, die den Bericht enthält.
- -help
- Zeigt Übersichtsdaten zur Verwendung an.
Beschreibung der Optionen für Verbindungsinformationen
In der folgenden Liste werden die für die Herstellung einer Verbindung zur Repository-Datenbank erforderlichen Informationen beschrieben:
- -repositoryURL Repository-Datenbank-URL
- Geben Sie die URL zur Repository-Datenbank an.
- -repositoryUsername Benutzer-ID -repositoryPassword Kennwort
- Geben Sie die ID und das Kennwort für die Herstellung der Verbindung zur Datenbank an.
- -repositoryDriverClass Treiberklasse
- Geben Sie den vollständig qualifizierten Klassennamen der JDBC-Treiberklasse an, der zum Herstellen der Verbindung zur Repository-Datenbank verwendet werden soll.
Hinweise
- Repository-Unterstützung für dynamisches und statisches SQL
- SQL-Anweisungen werden verwendet, um auf ein Repository zuzugreifen und es zu bearbeiten.
Für Plattformen, die statisches SQL unterstützen, können diese Anweisungen statisch an die Datenbank gebunden sein. Für andere Plattformen werden die Anweisungen dynamisch abgesetzt.
Für Plattformen, die statisches SQL unterstützen, können Sie die Option -grant privilege und die Option -privilege EXECUTEPACKAGE verwenden, um sicherzustellen, dass Anwendungen unter Verwendung von statisch gebundenen Anweisungen auf das Metadatenrepository zugreifen können. Für Plattformen, die statisches SQL unterstützen, kann das Dienstprogramm ManageRepository entweder die gebundenen Pakete verwenden oder dynamische SQL-Anweisungen absetzen, nachdem -bind packages abgesetzt wurde. Wenn die gebundenen Pakete nicht vorhanden sind oder der Benutzer nicht über die Ausführungsberechtigung für die gebundenen Pakete verfügt, verwendet 'ManageRepository' dynamisches SQL, um auf die Repository-Tabellen zuzugreifen.
Für dynamische Plattformen stellt die Verwendung der Option -grant privilege und der Option -privilege TABLEACCESS sicher, dass dynamische Anwendungen auf die zugrundeliegenden Metadatenrepository-Tabellen zugreifen können. Dies ist die einzige verfügbare Option für Plattformen, die statisches SQL nicht unterstützen.
- ManageRepository-Unterstützung für Optim Performance Manager-Repository
Optim Performance Manager und Optim Performance Manager Extended
Insight können pureQueryXML-Daten verwenden. Das Dienstprogramm ManageRepository kann pureQueryXML-Daten an ein
Optim Performance
Manager-Repository hochladen.
Sie können das Dienstprogramm ManageRepository nur verwenden, um pureQueryXML-Daten an ein Optim Performance
Manager-Repository hochzuladen. Andere Daten, wie pureQuery-Laufzeiteigenschaften, können nicht hochgeladen werden.
Sie können das Dienstprogramm ManageRepository verwenden, um Laufzeitgruppen in einem
Optim Performance Manager-Repository zu erstellen, zu aktualisieren, zu löschen und aufzulisten. Andere ManageRepository-Befehle werden nicht unterstützt.
- Oracle-Datenbanken
- Sie müssen bei Oracle-Datenbanken ein Schema für ein Repository erstellen, bevor Sie das Repository mit der ManageRepository-Option -create
repository erstellen. Das Standardschema ist IBMPDQ. Beispielsweise werden durch die Ausführung des folgenden Oracle SQL*Plus-Befehls ein Benutzer und das Schema IBMPDQ für eine Oracle-Datenbank erstellt:
create user IBMPDQ identified by Kennwort
Alle Benutzer mit Verwaltungsberechtigungen für die Datenbank können ein Repository erstellen.
Der folgende
ManageRepository-Beispielbefehl setzt voraus, dass der Benutzer 'tiger' Verwaltungsberechtigungen für die Oracle-Datenbank TEST hat und dass das Schema IBMPDQ für die Datenbank erstellt wird:
java com.ibm.pdq.tools.ManageRepository
-create repository -repositoryType pureQueryOnly
-repositoryURL jdbc:db2://test.ora.com:17593/test
-repositoryUsername tiger
-repositoryPassword testpwd
-repositoryDriverClass com.ibm.db2.jcc.DB2Driver
Beispiele
Der folgende Befehl stellt unter Verwendung der Verbindungsinformationen eine Verbindung zur Datenbank her und erstellt ein Repository.
java com.ibm.pdq.tools.ManageRepository
-create repository -repositoryType pureQueryOnly
-repositoryURL jdbc:db2://test.user.com:17593/SAMPLE
-repositoryUsername mytestid
-repositoryPassword testpwd
-repositoryDriverClass com.ibm.db2.jcc.DB2Driver
Der folgende Befehl stellt eine Verbindung zur Datenbank her und generiert ein SQL-Script zum Erstellen eines Repositorys, das ein Repository in der Datenbank erstellen kann:
java com.ibm.pdq.tools.ManageRepository
-create repository -repositoryType pureQueryOnly
-repositoryURL jdbc:db2://test.user.com:17593/SAMPLE
-repositoryUsername mytestid
-repositoryPassword testpwd
-repositoryDriverClass com.ibm.db2.jcc.DB2Driver
-generateScriptOnly D:\test\scripts\createtest.sql
Der folgende Befehl entfernt ein Repository:
ManageRepository –remove repository
-repositoryURL jdbc:db2://test.user.com:17593/SAMPLE
-repositoryUsername mytestid
-repositoryPassword testpwd
-repositoryDriverClass com.ibm.db2.jcc.DB2Driver