Szenarios: Speicherung von pureQuery-Daten mit pureQuery-Laufzeiteigenschaften steuern

Mit pureQuery-Laufzeiteigenschaften können Sie die Speicherposition steuern, die von pureQuery Runtime verwendet wird, um pureQuery-Informationen abzurufen und erfasste SQL-Daten zu speichern.
Die folgenden Szenarios beschreiben, wie Sie pureQuery-Laufzeiteigenschaften verwenden können, um zu steuern, wie pureQuery Runtime verschiedene Speicherpositionen verwendet:

Anwendung für die Verwendung der pureQuery-Clientoptimierung und eines Repositorys konfigurieren

Die folgenden Schritte zeigen auf, wie ein Repository anfänglich für die pureQuery-Clientoptimierung verwendet werden kann:
  1. Der Datenbankadministrator erstellt ein SQL-Verwaltungsrepository.
  2. Der Administrator erstellt mindestens eine Laufzeitgruppenversion in dem Repository.
  3. Der Anwendungsadministrator legt die folgenden pureQuery-Laufzeiteigenschaften für eine Laufzeitgruppenversion fest. Der Datenbankadministrator lädt die pureQuery-Laufzeiteigenschaften in eine Laufzeitgruppenversion hoch:
    executionMode
    Der Wert ist auf DYNAMIC gesetzt.
    captureMode
    Der Wert ist auf ON gesetzt.
    propertiesRefreshInterval
    Der Wert ist auf 1 (eine Minute) gesetzt.

    Andere pureQuery-Laufzeiteigenschaften werden wie für die Anwendung erforderlich festgelegt.

    Die Laufzeitgruppenversion enthält keine pureQueryXML-Daten.

  4. Der Datenbankadministrator aktiviert die Laufzeitgruppenversion.
  5. Für die für die Verwendung der pureQuery-Clientoptimierung konfigurierte Anwendung gibt der Anwendungsadministrator die folgenden pureQuery-Laufzeiteigenschaften für das Abrufen der pureQuery-Daten aus dem SQL-Verwaltungsrepository an:
    finalRepositoryProperties
    Gibt das zuvor erstellte Repository an.
    propertiesGroupId
    Gibt die zuvor erstellte pureQuery-Laufzeitgruppe an.
    repositoryRequired
    Der Wert wird auf das vom Anwendungsadministrator angegebene Verhalten gesetzt.
    propertiesRefreshInterval
    Der Wert ist auf 1 (eine Minute) gesetzt.
  6. Der Anwendungsadministrator startet die Anwendung.
  7. Die Anwendung wird ausgeführt. Die pureQuery-Clientoptimierung erfasst SQL-Daten und speichert sie als Teil der Laufzeitgruppendaten im Repository.
  8. Der Datenbankadministrator führt die folgenden Schritte aus, um das erfasste SQL für die Verwendung mit der pureQuery-Clientoptimierung vorzubereiten:
    1. Extrahieren der erfassten SQL-Daten und der anderen pureQuery-Daten aus dem Repository mit dem Dienstprogramm ManageRepository.
    2. Zusammenführen der erfassten SQL-Daten in einer pureQueryXML-Datei, falls erforderlich.
    3. Konfigurieren der pureQueryXML-Datei.
    4. Verwenden des Dienstprogramms StaticBinder, um für die Anwendungsdatenbank Pakete aus den SQL-Anweisungen in der pureQueryXML-Datei zu erstellen und die Pakete an die Datenbank zu binden.
  9. Der Datenbankadministrator lädt die folgenden pureQuery-Daten an das Repository in eine neue Version der vorhandenen Laufzeitgruppe hoch.
    • Die pureQueryXML-Daten.
    • Die folgenden pureQuery-Laufzeiteigenschaften:
      executionMode
      Der Wert ist auf STATIC gesetzt.
      allowDynamicSQL
      Der Wert ist auf TRUE gesetzt.
      captureMode
      Der Wert ist auf OFF gesetzt. Die Eigenschaft kann auf ON gesetzt werden, um zusätzliche SQL-Anweisungen aus der Anwendung zu erfassen.
      propertiesRefreshInterval
      Bleibt auf 1 Minute.
  10. Der Datenbankadministrator setzt die neue Laufzeitgruppenversion auf aktiv.
  11. Nachdem die pureQuery-fähige Anwendung die pureQuery-Informationen auf Änderungen geprüft und die pureQuery-Informationen aktualisiert hat, ruft die Anwendung die statischen SQL-Anweisungen für die Anweisungen auf, die erfasst und an die Datenbank gebunden wurden.
    Anmerkung: Wenn einige SQL-Anweisungen, die WHERE CURRENT OF verwenden, eine lange Ausführungszeit benötigen, kann dies dazu führen, dass die Verwendung der statischen SQL-Anweisung verzögert wird.
  12. Der Datenbankadministrator kann den Prozess wiederholen und die Erfassung von SQL-Daten aus der Anwendung und die Aktualisierung der pureQuery-Informationen fortsetzen, um andere pureQuery-Funktionen zu testen. Der Anwendungsserveradministrator braucht die Anwendung während der Tests des Datenbankadministrators nicht erneut zu starten.

Vorhandene Anwendung für die Verwendung eines Repositorys konfigurieren

Eine vorhandene Anwendung, die für die pureQuery-Clientoptimierung aktiviert ist, kann konfiguriert werden, dass sie ein SQL-Verwaltungsrepository verwendet. Wenn die Anwendung die pureQuery-Daten des Repositorys verwendet, kann der Datenbankadministrator die pureQuery-Daten im Repository ändern, ohne dass dafür die Anwendung erneut implementiert werden muss.

Die folgenden Schritte zeigen auf, wie pureQuery-Laufzeiteigenschaften und pureQueryXML-Daten in ein Repository versetzt werden. In den folgenden Schritten wird die folgende Umgebung vorausgesetzt:
  • Die Anwendung verwendet zurzeit die pureQuery-Clientoptimierung und führt statisches SQL aus.
  • Die pureQuery-Eigenschaften und pureQueryXML befinden sich in der EAR-Datei der Anwendung und in DataSource.pdqProperties.
  1. Der Anwendungsadministrator ermittelt die pureQuery-Eigenschaften, die die Anwendung zurzeit verwendet.
    Anmerkung: Zur Prüfung der aktuellen Eigenschaftseinstellungen kann der Administrator einen JCC-Trace verwenden, um die aktuellen Eigenschaften anzuzeigen.
  2. Der Anwendungsadministrator ruft die aktuelle pureQueryXML-Datei ab. Er kann die Datei z. B. aus der EAR-Datei oder aus einem Quellcodekontrollsystem extrahieren.
  3. Der Anwendungsadministrator erstellt eine pureQuery-Eigenschaftendatei, die alle aktuellen Eigenschaften und Werte enthält.
    Anmerkung: Die Eigenschaft pureQueryXml ist nicht in dieser Datei enthalten. Die Eigenschaften finalRepositoryProperties und propertiesGroupId geben die Speicherposition der pureQueryXML-Datei an.
  4. Der Datenbankadministrator erstellt ein SQL-Verwaltungsrepository, wenn noch keines vorhanden ist.
  5. Der Datenbankadministrator erstellt eine Laufzeitgruppenversion im Repository und lädt die pureQuery-Laufzeiteigenschaftendatei und die pureQueryXML-Datei des Anwendungsadministrators hoch.
  6. Der Datenbankadministrator aktiviert die Laufzeitgruppenversion.
  7. Der Anwendungsadministrator aktualisiert die pureQuery-Laufzeiteigenschaften, die von der Anwendung beim Systemstart verwendet werden, um die pureQuery-Informationen aus dem Repository abzurufen:
    finalRepositoryProperties
    Gibt das Repository an, das die pureQueryXML-Daten und Laufzeiteigenschaften der Anwendung enthält.
    propertiesGroupId
    Gibt die Laufzeitgruppe im Repository an.
    repositoryRequired
    Wird auf das vom Anwendungsadministrator angegebene Verhalten gesetzt.
  8. Der Anwendungsadministrator fügt die pureQuery-Laufzeiteigenschaften einer der folgenden Speicherpositionen hinzu:
    • DataSource.pdqProperties, wenn alle Anwendungen, die diese Datenquelle verwenden, das Repository verwenden können.
    • pdq.appwide.properties in der EAR-Datei, wenn die Anwendung nur eine Datenquelle verwendet.
    • pdq.targetDSName.properties in der EAR-Datei, wobei targetDSName den Namen der Datenquelle angibt, die auf die Repository-Eigenschaften und pureQueryXML-Daten verweist.
    Anmerkung: Wurde die EAR-Datei geändert, muss der Anwendungsadministrator die aktualisierte EAR-Datei erneut implementieren.
  9. Der Anwendungsadministrator implementiert die Anwendung erneut und startet sie. Die Anwendung ruft die pureQuery-Laufzeiteigenschaften und die pureQueryXML-Daten aus der Laufzeitgruppenversion im Repository ab.

pureQueryXML-Daten aktualisieren, die in einem Repository mit erfassten SQL-Daten gespeichert sind

Die folgenden Schritte zeigen auf, wie die in einem Repository gespeicherten erfassten SQL-Daten verwendet werden. In den folgenden Schritten wird die folgende Umgebung vorausgesetzt:
  • Die Anwendung, die für die Verwendung der pureQuery-Clientoptimierung konfiguriert ist, ruft statisches SQL auf und die inkrementelle Erfassung ist aktiviert.
  • Die pureQuery-Eigenschaften und die erfassten SQL-Daten befinden sich im Repository und der Wert der Eigenschaft propertiesRefreshInterval ist auf 60, also auf eine Stunde, gesetzt.
Der Datenbankadministrator führt die folgenden Schritte aus:
  1. Extrahieren des erfassten SQL aus der Laufzeitgruppe in einem Repository und, falls erforderlich, Extrahieren der pureQueryXML-Daten und der Konfigurationsdaten. Verwenden des Dienstprogramms ManageRepository.
    Anmerkung: Während die erfassten SQL-Daten abgerufen werden, bleibt der Wert der Eigenschaft captureMode auf ON gesetzt. Die SQL-Daten werden weiter erfasst. Das Dienstprogramm ManageRepository extrahiert jedoch nur die vollständigen Gruppen erfasster SQL-Daten.
  2. Verwenden der Dienstprogramme Merge, Configure und StaticBinder, um eine neue pureQueryXML-Datei zu erstellen und die SQL-Anweisungen in der pureQueryXML-Datei an die Datenbank zu binden.
  3. Hochladen des neuen pureQueryXML und der pureQuery-Laufzeiteigenschaften an das Repository in eine neue Version der Laufzeitgruppe.
  4. Optional: Löschen der erfassten SQL-Daten, die in der pureQueryXML-Datei zusammengeführt wurden.
  5. Die neue Laufzeitgruppenversion als aktiv festlegen.

Innerhalb einer Stunde prüft die Anwendung mit pureQuery Runtime das Repository auf aktualisierte pureQuery-Daten und verwendet die aktualisierten pureQueryXML-Daten und pureQuery-Eigenschaften in der neuen Version der Laufzeitgruppe.

Anmerkung: Wenn Sie die Workbench verwenden, können Sie eine Verbindung zum Repository herstellen und den Editor für Arbeitskopie der Laufzeitgruppe verwenden, um die pureQuery-Daten in einer Laufzeitgruppenversion zu verwalten.

Feedback