ManageRepository (Dienstprogramm)

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 InfoSphere 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 und das Upgrade 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 der Option -verify repository überprüfen.

Wenn Sie ein Repository erstellen wollen, das nur die Informationen von pureQuery-Dateien enthält, die für die pureQuery-Clientoptimierung verwendet werden, verwenden Sie die Option repositoryType mit dem Wert -pureQueryRuntimeOnly.

Syntax des Befehls ManageRepository für Operationen auf Repository-Ebene

Syntaxdiagramm lesenSyntaxdiagramm überspringen
    (1)                                             
>>-------java--com.ibm.pdq.tools.ManageRepository--------------->

>--+- -create repository-- -repositoryType--+-pureQueryOnly--------+-+-->
   |                                        '-pureQueryRuntimeOnly-' |   
   |  (2)                                                            |   
   +------- -bind packages-------------------------------------------+   
   +- -verify repository---------------------------------------------+   
   +- -report--+-repositoryData-- -file--Dateiname-+-----------------+   
   |           '-repositoryVersion-----------------'                 |   
   +- -delete repository--+--------------------+---------------------+   
   |                      '- -force--+-FALSE-+-'                     |   
   |                                 '-TRUE--'                       |   
   '- -upgrade-------------------------------------------------------'   

>--| Verbindungsinformationen |--------------------------------->

>--+-------------------------------------------------+---------->
   |  (3)                                            |   
   '------- -generateScriptOnly--Pfad-zu-Scriptdatei-'   

>--+--------+--------------------------------------------------><
   '- -help-'   

Verbindungsinformationen

|-- -repositoryURL--URL-zu-Repository-Datenbank----------------->

>-- -repositoryUsername--Benutzer-ID-- -repositoryPassword--Kennwort-->

>-- -repositoryDriverClass--Treiberklasse-----------------------|

Anmerkungen:
  1. Sie können die Optionen in beliebiger Reihenfolge angeben.
  2. Die Option -bind packages darf nur mit einer Datenbank verwendet werden, die statisches SQL unterstützt.
  3. 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 Möglichkeit, die Aktion abzubrechen.

-repositoryType
Geben Sie den Typ des zu erstellenden Repositorys an. Die folgenden Typen werden für Repositorys unterstützt:
pureQueryOnly
Dieser Wert ist der Standardwert. Das Repository kann Informationen aus pureQuery-Dateien, die von für pureQuery-Clientoptimierung aktivierten Anwendungen verwendet werden, pureQuery Runtime-Eigenschaften und pureQueryXML-Daten enthalten. Das Repository kann auch Bindeoptionen enthalten sowie Optionen zum Konfigurieren von pureQueryXML-Dateien.

Wenn Sie die Inhalte einer pureQueryXML-Datei in ein Repository hochladen, extrahiert das Dienstprogramm ManageRepository die SQL-Anweisungen aus den pureQueryXML-Daten und speichert sie getrennt im Repository.

Das Repository kann SQL-Daten enthalten, die aus IBM® Data Studio in das Repository exportiert wurden.

pureQueryRuntimeOnly
Das Repository kann Informationen aus pureQuery-Dateien, die von für pureQuery-Clientoptimierung aktivierten Anwendungen verwendet werden, pureQuery Runtime-Eigenschaften und pureQueryXML-Daten enthalten. Das Repository kann auch Bindeoptionen enthalten sowie Optionen zum Konfigurieren von pureQueryXML-Dateien.

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 Wert Dateiname ist der Pfad und der Dateiname für die Datei, die den Bericht enthält.
repositoryVersion
Gibt die Version des Repositorys zurück.
-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 im Repository. Die Ausgabe umfasst auch 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 müssen die Informationen für die Verbindung zur Repository-Datenbank angeben.

Sie können Objektnamen im Script zur Erstellung eines Repositorys modifizieren. Der Schemaname, Tabellennamen oder Spaltennamen können jedoch nicht modifiziert werden. Informationen zum Umgang mit den ManageRepository-Scripts finden Sie in Hinweise.

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.

-upgrade
Aktualisiert ein Repository zur Unterstützung der Speicherung von pureQuery-Protokollereignissen im Repository. Wenn das Repository bereits die korrekte Ebene hat, wird keine Aktion durchgeführt.

Wenn Sie die ManageRepository-Option -bind packages zum Erstellen von Datenbankpaketen für die Steuerung des Zugriffs auf das Repository verwendet haben, müssen Sie die Option -bind packages verwenden, um die Paket erneut zu binden.

Bei einem Repository, das die Speicherung von Protokollereignissen unterstützt, können Sie die pureQuery-Protokolliereigenschaft com.ibm.pdq.database angeben, um pureQuery-Ereignisse in das Repository zu schreiben.

Verwenden Sie die Option -generateScriptOnly, um ein SQL-Script zu generieren, ohne das Repository zu aktualisieren.

-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

Syntaxdiagramm lesenSyntaxdiagramm überspringen
    (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:
  1. Sie können die Optionen in beliebiger Reihenfolge angeben.
  2. Die Option -runtimeGroupVersion kann nicht zusammen mit der Option -copy runtimeGroup angegeben werden.
  3. 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 DYNAMIC gesetzt (SQL-Anweisungen dynamisch ausführen).
  • 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 Möglichkeit, 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.
-incrementalCapture 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 Laufzeitgruppenversion verwendet wird.

Wird kein Wert Quellenversion angegeben, wird die aktive Laufzeitgruppenversion verwendet. Wird kein Wert 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

Syntaxdiagramm lesenSyntaxdiagramm überspringen
    (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:
  1. Sie können die Optionen in beliebiger Reihenfolge angeben.
  2. Auf Plattformen, die statisches SQL unterstützen, ist executePackage die einzige Option, die unterstützt wird, nachdem die Option -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 mit den statisch gebundenen SQL-Anweisungen zugreifen können, die vom Dienstprogramm ManageRepository erstellt werden.
-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:
  1. Extrahieren der inkrementellen Daten.
  2. Verwenden des Dienstprogramms Merge, um die erfassten SQL-Dateien mit der pureQueryXML-Datei zusammenzuführen.
  3. Verwenden des Dienstprogramms Configure, um die aktualisierte pureQueryXML-Datei zu konfigurieren.
  4. 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.
  5. Aktualisieren der Laufzeitgruppe mit den neuen Daten.

Syntax für Operationen zum Extrahieren, Exportieren und Importieren von Daten

Syntaxdiagramm lesenSyntaxdiagramm überspringen
    (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:
  1. Sie können die Optionen in beliebiger Reihenfolge angeben.
  2. 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.
  3. 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 Data Studio-Exportfunktion 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 zur 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. 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

Syntaxdiagramm lesenSyntaxdiagramm überspringen
    (1)                                             
>>-------java--com.ibm.pdq.tools.ManageRepository--------------->

>-- -report pureQueryXMLChanges--------------------------------->

>-- -oldPureQueryXml--pureQueryXML-Datei------------------------>

>-- -newPureQueryXml--pureQueryXML-Datei------------------------>

>-- -file--Berichtsdatei--| Verbindungsinformationen |---------><

Verbindungsinformationen

|-- -repositoryURL--URL-zu-Repository-Datenbank----------------->

>-- -repositoryUsername--Benutzer-ID-- -repositoryPassword--Kennwort-->

>-- -repositoryDriverClass--Treiberklasse-----------------------|

Anmerkungen:
  1. 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 angeben, 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.

Bei dynamischen Plattformen wird durch die Angabe der Option -grant privilege und der Option -privilege TABLEACCESS sichergestellt, 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 unterstützen pureQueryXML-Daten. Das Dienstprogramm ManageRepository kann pureQueryXML-Daten an ein Optim Performance Manager-Repository hochladen.

Mit dem Dienstprogramm ManageRepository können Sie nur pureQueryXML-Daten an ein Optim Performance Manager-Repository hochladen. Andere Daten, wie pureQuery-Laufzeiteigenschaften, können nicht hochgeladen werden.

Mit dem Dienstprogramm ManageRepository können Laufzeitgruppen in einem Optim Performance Manager-Repository erstellt, aktualisiert, gelöscht und aufgelistet werden. Andere ManageRepository-Befehle werden nicht unterstützt.

Repository mit einem externen DB2-Sicherheitsmechanismus verwalten
Beim Erstellen eines Repositorys erstellt das Dienstprogramm ManageRepository Pakete zur Verwaltung des Repositorys. Das Dienstprogramm erstellt je nach Typ des erstellten Repositorys unterschiedliche Pakete. Wenn Sie einen externen DB2-Sicherheitsmechanismus zur Verwaltung eines Repositorys verwenden, müssen Sie im entsprechenden Sicherheitstool Zugriffsrechte auf die Pakete erteilen. In der folgenden Tabelle werden der Paketname und die erforderlichen Zugriffsrechte für den jeweiligen Repositorytyp aufgelistet:
Tabelle 1. Erforderliche Zugriffsrechte für Repositorypakete bei der Verwaltung eines Repositorys mit einem externen DB2-Sicherheitsmechanismus
Repositorytyp Repositorypaketname Zugriffsrechte auf Managerebene (voll) Zugriffsrechte auf Anwendungsebene (eingeschränkt)
pureQueryRuntimeOnly AMDL X  
pureQueryRuntimeOnly oder pureQueryOnly AMDA X X
pureQueryOnly AMD X  
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
ManageRepository-Script zum Erstellen eines Repositorys
Sie können ein Script zum Erstellen eines Repositorys generieren, indem Sie die Option -generateScriptOnly als Teil des Befehls zum Erstellen eines Repositorys angeben. Einige Objektnamen können Sie anpassen, andere können nicht geändert werden.

Wenn Sie die SQL-Anweisungen ändern und das Script ausführen, können Sie das Repository mit der Option -verify repository prüfen.

Wenn Sie ein Repository mithilfe eines angepassten Scripts erstellen, müssen Sie zum Löschen des Repositorys ebenfalls ein angepasstes Script verwenden. Ein Script zum Löschen eines Repositorys erstellen Sie, indem Sie die Option -generateScriptOnly mit dem Befehl zum Löschen eines Repositorys angeben. Bevor Sie das Script ausführen, ändern Sie die Objektnamen, die Sie in dem zur Erstellung des Repositorys verwendeten Script geändert haben.

Die Namen der folgenden Elemente können im Script zum Erstellen eines Repositorys geändert werden:
  • Der Datenbankname. Der Datenbankname wird in der IN-Klausel der CREATE TABLESPACE-Anweisungen angegeben.
  • Die Tabellenbereichsnamen. Die Tabellenbereichsnamen werden in der IN-Klausel der CREATE TABLE-Anweisungen angegeben.
  • Die Speichergruppen-ID. Die Speichergruppen-ID wird in der USING STOGROUP-Klausel von CREATE-Anweisungen angegeben.
  • Die Pufferpool-ID. Die Pufferpool-ID wird in der BUFFERPOOL-Klausel und INDEXBP-Klausel angegeben.
Folgende Elemente können im Script zum Erstellen eines Repositorys nicht geändert werden:
  • Der Schemaname IBMPDQ.
  • Die Tabellennamen, Sichtnamen und zugehörigen Schemadefinitionen.
  • Der Objektgruppenname und die Paketnamen können nicht geändert werden, wenn Sie die Option -bind packages angeben.
Die Scripts können über die folgenden beiden Methoden ausgeführt werden:
  • Führen Sie das Script über eine SQL-Scriptdatei unter Verwendung des SQL- und XQuery-Editors in IBM Data Studio aus. Informationen zum SQL- und XQuery-Editor finden Sie in Mit SQL-Anweisungen arbeiten.
  • Führen Sie das Script über eine Datei unter Verwendung der DB2-Befehlszeile aus. Über die DB2-Befehlszeile können Sie eine Verbindung zur Repository-Datenbank herstellen und das Script ausführen. Im folgenden Beispiel wird eine Verbindung zur Datenbank SAMPLE hergestellt und das Script in der Datei testcreate.sql ausgeführt.
    db2 connect to sample
    db2 -tvf Dateiname

    Informationen zur DB2-Befehlszeile finden Sie im Abschnitt zum Befehlszeilenprozessor im DB2 Information Center.

ManageRepository-Beispielscripts
Beispielbefehlszeilenscripts, die die Verwendung der ManageRepository-Befehle veranschaulichen, sind im Installationsverzeichnis von pureQuery Runtime for Linux, UNIX, and Windows enthalten.

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, mit dem ein Repository in der Datenbank erstellt werden 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:
java com.ibm.pdq.tools.ManageRepository –delete repository
  -repositoryURL jdbc:db2://test.user.com:17593/SAMPLE 
  -repositoryUsername mytestid 
  -repositoryPassword testpwd 
  -repositoryDriverClass com.ibm.db2.jcc.DB2Driver

Feedback