Überlegungen zu 'get' mit SQL

Im Kontext von SQL ruft die Anweisung 'get' Datensatzdaten aus einer Ergebnismenge ab.

Sie können eine Ergebnismenge auf zweierlei Art in einer Anweisung 'get' verwenden:

EGL erstellt eine SQL-Anweisung SELECT in Ihrem generierten Code auf Basis Ihrer Anweisung 'get' und der Eigenschaften der SQL-Datensatzvariablen in dieser Anweisung. Weitere Informationen zu diesem impliziten SQL-Code finden Sie unter SQL-Datenzugriff. Alternativ können Sie eine Direktive vom Typ '#sql' verwenden, um Ihren eigenen eingebetteten SQL-Code zu schreiben (siehe sql (Direktive)). Sie können SQL-Code auch zur Ausführungszeit assemblieren, indem Sie eine EGL-Anweisung 'prepare' verwenden und anschließend diesen Code über Ihre Anweisung 'get' referenzieren. Weitere Informationen zu dieser Verwendung von dynamischem SQL-Code finden Sie unter SQL-Datenzugriff.

Wenn Sie die Option 'singleRow' angeben, steht die SQL-Anweisung SELECT für sich allein. Wenn Sie 'singleRow' nicht angeben, wird die SQL-Anweisung SELECT zu einer Klausel in einer Cursordeklaration (einer SQL-Anweisung OPEN). Weitere Informationen zu dem von EGL generierten SQL-Code finden Sie unter SQL-Datenzugriff.

EGL stellt eine Reihe von Positionsoptionen mit der Anweisung 'get' bereit (wie beispielsweise 'absolute' und 'next'), die es Ihnen ermöglichen, einen bestimmten Datensatz relativ zur aktuellen Position in der Ergebnismenge abzurufen. Hierfür müssen Sie Ihre aktuelle Position mithilfe eines Cursors überwachen. Um auf die Ergebnismenge für Ihren Cursor zugreifen zu können, verwenden Sie die EGL-Anweisung 'open', bevor Sie die positionsgebundene Anweisung 'get' verwenden. Sie können auch eine Anweisung 'get...forUpdate' verwenden. Diese Vorgehensweise ist jedoch weniger üblich.

Wenn das Ziel der Anweisung 'get' eine einzelne SQL-Datensatzvariable ist, gibt die Anweisung den ersten Datensatz zurück, der den von Ihnen bereitgestellten Kriterien (implizit oder eingebettet) entspricht. Sie können auch eine dynamische Feldgruppe aus SQL-Datensatzvariablen als Ziel der Anweisung angeben. In diesem Fall gibt die Anweisung 'get' jede übereinstimmende Zeile als Element in der Feldgruppe zurück.

Syntax

Syntaxdiagramm für die Anweisung 'get'
SQL-Datensatzvariable
Der Name einer SQL-Datensatzvariablen. Das Standardverhalten besteht darin, Datenbankzeilen in Übereinstimmung mit den Werten in den folgenden Datensatzabschnittseigenschaften zu suchen: 'keyItems' und 'defaultSelectCondition'.
forUpdate
Wenn Sie eine neue Ergebnismenge mit Ihrer Anweisung 'get' erstellen und davon ausgehen, dass Datenbankzeilen zu einem späteren Zeitpunkt ersetzt (replace) oder gelöscht (delete) werden, schließen Sie dieses Schlüsselwort ein, um die Zeilen zu sperren, die Ihrer Ergebnismenge entsprechen. Der Datenbankmanager erlaubt es anderen Programmen erst dann, gesperrte Zeilen zu ändern, nachdem eine Commit-Operation ausgeführt wurde. Details zur Commitverarbeitung finden Sie unter Logische Arbeitseinheit (LUW).
Ergebnismengen-ID
Wenn Sie eine neue Ergebnismenge mit Ihrer Anweisung 'get' erstellen, können Sie eine ID Ihrer Wahl mit dem Schlüsselwort 'forUpdate' angeben, um dieselbe Ergebnismenge in einer späteren EGL-Anweisung 'replace', 'delete' oder 'execute', einer späteren positionsgebundenen EGL-Anweisung 'get' oder einer späteren EGL-Anweisung 'close' zu verwenden.
singleRow
Mit dieser Option wird eine effizientere SQL-Anweisung erstellt, die Sie verwenden können, wenn Sie sicher sind, dass der Schlüssel in der Anweisung 'get' nur für eine einzige Zeile gilt, und wenn Sie nicht beabsichtigen, diese Zeile zu aktualisieren oder zu löschen. In diesem Fall erstellt EGL keinen Cursor. Wenn Sie diese Option angeben, wenn der Schlüssel für mehrere Zeilen gilt, tritt ein Laufzeit-E/A-Fehler auf.
#sql{ SQL-Anweisung_SELECT }
Wenn Sie ein erfahrener SQL-Programmierer sind, können Sie den von EGL generierten SQL-Code überschreiben, indem Sie Ihre eigene SQL-Anweisung SELECT einbetten (siehe hierzu sql (Direktive)). Zwischen '#sql' und der linken geschweiften Klammer darf kein Leerzeichen stehen.
Betrachen Sie folgenden Fall: Ihr Code enthält eine Anweisung 'get' oder 'open', die einen SQL-Datensatz verwendet, eine explizite SQL-Anweisung einschließt und keine INTO-Klausel aufweist. Es folgt ein Beispiel eines EGL-Codes, der eine solche Anweisung 'get' einschließt:
customer CustomerRecordPart{};
get customer with #sql{
   select MySCHEMA.CUSTOMER.Column01
   from MYSCHEMA.CUSTOMER
   where MYSCHEMA.Column02 = "AZ"}; 
Der folgende Datensatzabschnitt (Record) wurde in diesem Code referenziert:
Record CustomerRecordPart type SQLRecord {tableNames = [["MYSCHEMA.CUSTOMER"]]}
   customerNumber INT    {column = "MYSCHEMA.CUSTOMER.Column01"};
   ...
end

In der zuvor beschriebenen Anweisung 'get' oder 'open' muss die für einen Spaltennamen in der SQL-Klausel SELECT verwendete Qualifizierung mit der Qualifizierung übereinstimmen, die für das entsprechende Feld im Datensatzabschnitt verwendet wird.

Einschränkung: Wenn Sie eine relativ komplexe SQL-Anweisung SELECT codieren, müssen Sie unter Umständen die Klausel INTO angeben, anstatt sich darauf zu verlassen, dass der EGL-Generator diese Klausel erstellt. Diese Situation tritt (beispielsweise) ein, wenn ein SQL-CASE-Ausdruck in einer Anweisung SELECT verwendet wird. Beispiel:
SELECT 
   CASE 
      WHEN  address1 <> '' THEN address1 
      WHEN  address2 <> '' THEN address2 
   END... 
Die Situation tritt nicht ein, wenn jeder Eintrag in der anfänglichen SELECT-Klausel aus einer der folgenden Kategorien stammt:
  • Spaltenname
  • Literal
  • Sonderregister wie beispielsweise CURRENT TIMESTAMP
  • Spaltennamen, Literale und Sonderregister werden durch einen der folgenden Operatoren verknüpft: ||, +, -, *, /
Dennoch kann eine komplexe SELECT-Klausel zu einem Problem führen, wenn Sie einen SQL-Datensatz verwenden, da Sie zum Generieren einer gültigen INTO-Klausel der Eigenschaft 'column' zwecks Abgleichs des ausgewählten Inhalts einen Wert zuordnen müssen. Es folgt ein Beispiel einer anfänglichen SELECT-Klausel, die eine Kombination aus Einträgen aus den zuvor genannten Kategorien einschließt:
SELECT COLUMN01 || 10 + COLUMN02 * 5
Der zugehörige SQL-Datensatzabschnitt sieht wie folgt aus:
Record MyRecordPart type SQLRecord
   myField int { column = "COLUMN01 || 10 + COLUMN02 * 5" };
end

Im letzten Fall sollten Sie darüber nachdenken, Ihre eigene INTO-Klausel zu schreiben, anstatt die Eigenschaft 'column' zu setzen. Dies hat folgenden Grund: Wenn Sie eine EGL-Anweisung 'add' oder 'replace' codieren, die auf einen komplexen Wert der Eigenschaft 'column' zugreift, sind die für Sie generierten SQL-Anweisungen INSERT und UPDATE möglicherweise nicht gültig.

into ... Ziel
Diese Klausel entspricht der INTO-Klausel in dem von EGL erstellten impliziten SQL-Code. Die INTO-Klausel gibt die EGL-Variablen an, die Werte aus der Ergebnismenge empfangen. Sie können einzelne Variablen angeben oder Sie können einen Datensatznamen angeben. In letzterem Fall verwendet EGL sämtliche Felder im Datensatz. Diese Klausel ist erforderlich, wenn Sie SQL in einem der folgenden Fälle verarbeiten:
  • Sie haben keine SQL-Datensatzvariable in der Anweisung 'get' angegeben.
  • Sie haben sowohl eine SQL-Datensatzvariable als auch eine eingebettete SQL-Anweisung SELECT angegeben, aber in der SQL-Anweisung SELECT ist mindestens eine Spalte vorhanden, für die es keine entsprechenden Felder in der SQL-Zieldatensatzvariablen gibt.

Schreiben Sie die INTO-Klausel in EGL, nicht in SQL. Beginnen Sie die Namen der Variablen in der Klausel nicht mit Doppelpunkten, wie es für Hostvariablen in einer SQL-Anweisung möglich ist. Weitere Informationen finden Sie unter Hostvariablen.

Bei Verwendung mit 'get Positionsoption dynamische_SQL-Feldgruppe' kann es sich bei den Zielen um ein Feld einer dynamischen Feldgruppe in einer Datensatzvariablen handeln oder um strukturierte Datensätze, für deren Felder 'occurs' angegeben ist. Durch die Verwendung von strukturierten Datensätzen kann bei COBOL-Generierung eine bessere Leistung erzielt werden. Wenn die zugeordnete Zeilengruppengröße (rowSetSize) größer ist als die Elemente, die in dem mit 'occurs' angegebenen Feld im strukturierten Datensatz angegeben sind, sollte eine Ausnahmebedingung vom Typ 'IndexOutOfBoundException' ausgelöst werden, wenn die Anweisung 'get Positionsoption' versucht, einen Wert in ein Element zu füllen, der den Maixmalindex der mit 'occurs' angegebenen Feldgruppe überschreitet.
ID_der_vorbereiteten_Anweisung
Diese Kennung zeigt auf eine EGL-Anweisung 'prepare', mit der zur Ausführungszeit eine SQL-Anweisung SELECT vorbereitet wird. Die Anweisung 'get' führt die SQL-Anweisung SELECT dynamisch aus. Weitere Informationen finden Sie unter Überlegungen zu 'prepare' mit SQL.
using ... Feld
Diese Klausel entspricht der USING-Klausel in dem von EGL erstellten impliziten SQL-Code. Die USING-Klausel gibt die EGL-Variablen an, die Sie für die vorbereitete SQL-Anweisung SELECT zur Ausführungszeit verfügbar machen. Schreiben Sie die USING-Klausel in EGL, nicht in SQL. Beginnen Sie die Namen der Variablen in der Klausel nicht mit Doppelpunkten, wie es für Hostvariablen in einer SQL-Anweisung üblich ist. Weitere Informationen hierzu finden Sie in Hostvariablen.
usingKeys ... Feld
Sie können hier Feldnamen aus Ihrem SQL-Datensatz angeben, um die Schlüsselfelder zu überschreiben, die Sie in dieser Datensatzdefinition angegeben haben. Wenn beispielsweise 'customerNumber' (Kundennummer) das in 'CustomerRecord' definierte Schlüsselfeld ist, die Suche nach Datensätzen aber nach Kundennamen (customerName) erfolgen soll, können Sie den folgenden Code verwenden:
get myCustomer usingKeys myCustomer.customerName;
Sie können die Suche auch auf Basis eines Felds aus einem gänzlich anderen Datensatz durchführen:
get myCustomer usingKeys myOrders.customerName;

Das Feld (oder die Felder), das Sie mit 'usingKeys' angeben, wird in die WHERE-Klausel in der impliziten SQL-Anweisung integriert, die EGL aus der Anweisung 'get' generiert. Folgt auf diese Anweisung ein eingebetteter SQL-Code, setzt dieser eingebettete Code den impliziten Code außer Kraft.

Im Falle einer dynamischen Feldgruppe dürfen die Felder in der Klausel 'usingKeys' (bzw. die Hostvariablen im SQL-Datensatz) nicht in der SQL-Datensatzvariablen vorhanden sein, auf der die dynamische Feldgruppe basiert.

Wenn Sie das Schlüsselwort 'forUpdate' angeben, werden die den Schlüsselelementen zugeordneten Spalten aus den in der Klausel FOR UPDATE OF aufgelisteten Spalten ausgeschlossen.

Positionsoption
Verwenden Sie diese Option, um Daten aus einer vorhandenen Ergebnismenge abzurufen, anstatt eine neue Ergebnismenge zu erstellen. Die verfügbaren Optionen und eine zugehörige Beschreibung finden Sie unter 'Positionsoptionen verwenden' in diesem Thema.
from Ergebnismengen-ID
Wenn Sie Positionsoptionen verwenden, können Sie mithilfe einer Ergebnismengen-ID diejenige Ergebnismenge angeben, aus der Sie Datensatzinformationen nach Position abrufen wollen. Sie haben diese ID in einer vorherigen Anweisung 'open' oder 'get' zugeordnet. Wenn Sie keine Ergebnismenge angeben, bestimmt EGL Ihre aktuelle Ergebnismenge aus dem Kontext. Siehe 'Positionsoptionen verwenden' in diesem Thema.
dynamische_SQL-Feldgruppe
Diese Variable benennt eine dynamische Feldgruppe, die sich aus SQL-Datensatzvariablen zusammensetzt. EGL ruft alle übereinstimmenden Zeilen aus der Ergebnismenge ab und fügt dieser Werte in die einzelnen Datensatzvariablenelemente der Feldgruppe ein. Setzen Sie die Eigenschaft 'maxSize' der Feldgruppe, um zu verhindern, dass pro Abruf mehr Daten abgerufen werden, als das Programm verarbeiten kann. Nachdem die Feldgruppe ihre Maximalgröße erreicht hat, stoppt EGL den Abruf von Ergebnissen. Siehe Eigenschaften dynamischer Feldgruppen.
Bei Verwendung mit 'Positionsoption' erfolgt die Rückgabe der nächsten Zeilengruppe in die dynamische Feldgruppe auf Basis der Eigenschaft 'rowSetSize' in der Variablendeklaration 'SQLDynamicArray' oder in der Anweisung 'open'. Handelt es sich hierbei um die erste Ausführung von 'get Positionsoption', dann werden die Feldgruppenelemente erstellt. Handelt es sich um die zweite oder spätere Ausführung von 'get Positionsoption' werden die Elemente in der Feldgruppe ersetzt.
SQL-Aufrufanweisung
Ein Aufruf an eine gespeicherte Prozedur im Datenbankmanagementsystem. Die Prozedur muss genau eine Ergebnismenge zurückgeben. Beispiele finden Sie unter 'Gespeicherte Prozedur aufrufen'.

Positionsoptionen verwenden

Wenn Sie Positionsoptionen mit der Anweisung 'get' verwenden, erstellen Sie keine neue Ergebnismenge, sondern rufen Datensätze aus einer Ergebnismenge ab, die in einer vorherigen Anweisung 'get' oder 'open' erstellt wurde. Da sie mit einer vorhandenen Ergebnismenge arbeiten, gelten die folgenden Einschränkungen:
  • Sie können keine SQL-Anweisung in eine Direktive '#sql' einbetten.
  • Sie können nicht die Option 'singleRow' verwenden.
  • Sie können nicht die Option 'forUpdate' verwenden (diese Option war möglicherweise in der Anweisung gesetzt, mit der die Ergebnismenge erstellt wurde).
  • Sie können keine vorbereitete Anweisung verwenden.
Die Positionsoptionen für die Anweisung 'get' sind verfügbar, wenn die folgenden Bedingungen erfüllt sind:
  • Sie haben eine Ergebnismenge mithilfe der EGL-Anweisung 'open' erstellt.
  • Sie haben die Option 'scroll' mit der Anweisung 'open' verwendet.

Die Positionsoption 'next' ist auch unter anderen Umständen verfügbar.

absolute (Position)
Ruft eine Zeile ab, die Sie mit einer Nummer angeben. Wenn Sie einen positiven Wert angeben, wird vom Anfang der Ergebnismenge vorwärts gezählt. Wenn Sie einen negativen Wert angeben, wird vom Ende der Ergebnismenge rückwärts gezählt.
current
Ruft die Zeile an Ihrer aktuellen Cursorposition ab.
first
Ruft die erste Zeile in der Ergebnismenge ab.
last
Ruft die letzte Zeile in der Ergebnismenge ab.
next
Ruft die erste Zeile nach Ihrer aktuellen Cursorposition ab.
previous
Ruft die letzte Zeile vor Ihrer aktuellen Cursorposition ab.
relative (Position)
Ruft eine Zeile ab, die Sie mit einer Nummer angeben. Wenn Sie einen positiven Wert angeben, wird von der aktuellen Cursorposition vorwärts gezählt. Wenn Sie einen negativen Wert angeben, wird von der aktuellen Cursorposition rückwärts gezählt. Bei Angabe des Werts Null wird der Datensatz an der aktuellen Cursorposition abgerufenen. Dies ist äquivalent zur Option 'current'.

Die Anfangsposition des Cursors (oder des Positionszeiger) für eine Ergebnismenge liegt vor der ersten Zeile der Ergebnisse. Um die Ergebnisse zu iterieren, verwenden Programme üblicherweise eine Anweisung 'forEach' oder wiederholt die Anweisung 'get next'.

Implizite SQL-Anweisung SELECT

Wenn Sie eine SQL-Datensatzvariable in der Anweisung 'get', aber keine eingebettete SQL-Anweisung mit der Direktive '#sql' angeben, erstellen Sie einen impliziten SQL-Code. Die implizite SQL-Anweisung SELECT weist die folgenden Merkmale auf:

  • Die datensatzspezifische Eigenschaft 'defaultSelectCondition' legt die Tabellenzeile fest, die die Anweisung 'get' auswählt, solange der Wert in jeder Schlüsselspalte der SQL-Tabelle mit dem Wert in dem entsprechenden Schlüsselfeld der SQL-Datensatzvariablen identisch ist. Wenn Sie weder einen Datensatzschlüssel noch eine Standardauswahlbedingung angeben, enthält die Ergebnismenge alle Tabellenzeilen. Wenn mehrere Tabellenzeilen ausgewählt werden und Sie eine einzelne SQL-Datensatzvariable (und keine Feldgruppe aus Datensatzvariablen) als Ziel der Anweisung 'get' angegeben haben, wird die erste abgerufene Zeile in die Datensatzvariable gestellt.
  • Infolge der Zuordnungen zwischen Datensatzfeldern und SQL-Tabellenspalten in der Datensatzdefinition empfängt ein bestimmtes Feld den Inhalt der zugehörigen SQL-Ergebnismengenspalte.
  • Wenn Sie die Option 'forUpdate' angeben, schließt die SQL-Anweisung SELECT FOR UPDATE keine Datensatzfelder ein, die schreibgeschützt sind.
  • Die SQL-Anweisung SELECT für einen bestimmten Datensatz ist mit der folgenden Anweisung vergleichbar, außer dass die Klausel FOR UPDATE OF nur dann vorhanden ist, wenn die Anweisung get die Option forUpdate enthält:
      SELECT Spalte01, 
             Spalte02, 
             ... 
             SpalteNN
      FROM   Tabellenname 
      WHERE  Schlüsselspalte01 = :Schlüsselfeld01
      FOR UPDATE OF
             Spalte01, 
             Spalte02, 
             ... 
             SpalteNN
    Die SQL-Klausel INTO in der eigenständigen SQL-Anweisung SELECT oder in der Cursoranweisung FETCH sieht ähnlich wie die folgende Klausel aus:
      INTO   :Datensatzfeld01,
             :Datensatzfeld02, 
             ...
             :DatensatzfeldNN

    EGL leitet die SQL-Klausel INTO ab, wenn die SQL-Datensatzvariable von einer eingebetteten SQL-Anweisung SELECT begleitet wird, wenn Sie keine Klausel INTO angegeben haben. Die Felder in der abgeleiteten INTO-Klausel entsprechen denen, die den aufgelisteten Spalten in der SELECT-Klausel der SQL-Anweisung zugeordnet sind. (Die Zuordnungen zwischen Feldern und Spalten befinden sich in Ihrem angepassten SQL-Datensatzabschnitt; siehe Stereotyp 'SQLRecord'.) Eine EGL-Klausel INTO ist erforderlich, wenn eine Spalte keinem Feld zugeordnet ist.

Wenn Sie eine dynamische Feldgruppe aus SQL-Datensatzvariablen als E/A-Objekt für eine Anweisung 'get', aber keine eingebettete SQL-Anweisung angeben, ist die implizite SQL-Anweisung SELECT mit der Anweisung vergleichbar, die für eine einzelne SQL-Datensatzvariable beschrieben wurde. Hierbei gelten jedoch die folgenden Unterschiede:
  • Die Schlüsselwertkomponente der Abfrage besteht aus einer Gruppe von Beziehungen, die auf einer Größer-Gleich-Bedingung basieren:
      Schlüsselspalte01 >= :Schlüsselfeld01 &
      Schlüsselspalte02 >= :Schlüsselfeld02 &
      ...
      SchlüsselspalteNN >= :SchlüsselfeldNN
  • Die Felder in der Klausel 'usingKeys' (bzw. die Hostvariablen im SQL-Datensatz) dürfen nicht in der SQL-Datensatzvariablen vorhanden sein, auf der die dynamische Feldgruppe basiert.

Beispiele

Im folgenden Beispiel verwendet die Anweisung 'get' die SQL-Datensatzvariable 'myCustomer' für den Abruf einer Datenbankzeile, wobei keine nachfolgende Aktualisierung oder Löschung möglich ist:
  try
    get myCustomer singleRow into customerName with
      #sql{
        SELECT customer_name
        FROM Cusomter
        WHERE customer_number = :myCustomer.customerNumber
      };
  onException(sqlEx SQLException)
    myErrorHandler(8);
  end
Das nächste Beispiel verwendet dieselbe SQL-Datensatzvariable, um eine SQL-Zeile zu ersetzen:
  try
    get myCustomer forUpdate into customerName with
      #sql{
        SELECT customer_name
        FROM Cusomter
        WHERE customer_number = :myCustomer.customerNumber
      };

  onException(sqlEx SQLException)
    myErrorHandler(8);  // beendet das Programm
  end

  myCustomer.customerName = newName;   // Benutzer hat Namensänderung eingegeben
 
  try
    replace myCustomer;
  onException(sqlEx SQLException)
    myErrorHandler(12);
  end
Das folgende Beispiel zeigt die Anweisung 'get' für mehrere Zeilen (Multiple-Row-Funktion):
employees Employee[0]{rowsetsize=10};
Open resultset1 scroll with #sql{ 
    select eID, uName, PASSWORD, fName, lName, office, sex, EMail
    from EMPLOYEETEST
} for employees;


Get Next employees;  //Dadurch wird die Feldgruppe 'employees' geleert und 
                     // mit bis zu 10 der nächsten Zeilen aus der Ergebnismenge gefüllt.
or
eIDs INT[0]{};
uNames CHAR(20)[10]{};
Get Next employees into eIDs, uNames; 
or
DynamicEmployee DynamicEmployee;
Get Next employees into DynamicEmployee;
Record DynamicEmployee
   eIDs INT[10];
   uNames CHAR(20)[10];
    end

or
structuredEmployee StructuredEmployee;
Get Next employees into structuredEmployee.eIDs, structuredEmployee.uNames; //
Get Next employees into structuredEmployee;

Record StructuredEmployee
   1 eIDs INT[10];
   1 uNames CHAR(20)[10];
 end

Fehlerbedingungen

Die folgenden Bedingungen führen zu Fehlern, wenn Sie eine Anweisung 'get' verwenden, um Daten aus einer relationalen Datenbank zu lesen:
  • Sie geben eine SQL-Anweisung eines anderen Typs als SELECT an.
  • Sie geben eine SQL-Klausel INTO direkt in einer SQL-Anweisung SELECT an.
  • Außer einer SQL-Klausel INTO geben Sie einige, aber nicht alle der erforderlichen Klauseln einer SQL-Anweisung SELECT an.
  • Sie geben eine SQL-Anweisung SELECT an (oder akzeptieren eine solche Anweisung), die einer Spalte zugeordnet ist, die entweder nicht vorhanden ist oder die mit der zugehörigen Hostvariablen nicht kompatibel ist.
Die folgenden Fehlerbedingungen können auftreten, wenn Sie die Option 'forUpdate' verwenden:
  • Sie geben eine SQL-Anweisung an (oder akzeptieren eine solche Anweisung), aus der hervorgeht, dass mehrere Tabellen aktualisiert werden sollen.
  • Sie verwenden eine SQL-Datensatzvariable, in der alle Datensatzfelder schreibgeschützt sind.
Wenn die beiden folgenden Bedingungen zutreffen, führt dies zu einem Fehler:
  • Sie passen eine EGL-Anweisung 'get' mit der Option 'forUpdate' an, ohne anzugeben, dass eine bestimmte SQL-Tabellenspalte für die Aktualisierung verfügbar ist.
  • Die zu dieser Anweisung get gehörende Anweisung 'replace' versucht, die Spalte zu überarbeiten.
Um die zuvor beschriebene Diskrepanz zu beheben, stehen folgende Möglichkeiten zur Verfügung:
  • Wenn Sie die EGL-Anweisung 'get' anpassen, schließen Sie den Spaltennamen in die Klausel FOR UPTDATE OF der SQL-Anweisung SELECT ein.
  • Wenn Sie die EGL-Anweisung 'replace' anpassen, entfernen Sie alle Verweise auf die Spalte in der SET-Klausel der SQL-Anweisung UPDATE.
  • Übernehmen Sie die Standardeinstellungen sowohl für die Anweisung 'get' als auch für die Anweisung 'replace'.

Kompatibilität

Jedes Managementsystem für relationale Datenbanken (RDBMS) verfügt über eine eigene SQL-Version. Nicht alle SQL-Anweisungen sind in jeder Implementierung verfügbar. Lesen Sie vor dem Codieren von eingebetteten SQL-Anweisungen die Dokumentation für Ihr RDBMS.

Tabelle 1. Hinweise zur Kompatibilität für 'get' und SQL
Plattform Problem
iSeries COBOL Die Option 'absolute' wird nicht unterstützt.

Feedback