DL/I-Beispiele

In diesen DL/I-Beispielen wird dieselbe Beispiel-DL/I-Datenbank verwendet wie im Kapitel Beispiel-DL/I-Datenbank beschrieben. Im Folgenden werden einige Beispiele für Standardtechniken für die DL/I-Datenbank-Ein-/Ausgabe beschrieben:

Übergeordnete Segmente durchsuchen

Die Standardanweisung GET NEXT beginnt an der derzeitigen Position in der Datenbank und durchsucht die gesamte Datenbank nach dem nächsten Vorkommen des Zielsegments unter übergeordneten Segmenten. Verwenden Sie die Anweisung GET NEXT INPARENT, um den Suchbereich auf die derzeit eingerichtete abhängige Kette einzuschränken.

Berücksichtigen Sie die Situation, in der Sie die Artikel für eine bestimmte Bestellung abrufen möchten. Zum Abrufen der Bestellung können Sie den folgenden Code verwenden:
get myOrder with #dli {
   GU STSCCST (STQCCNO = :myCustomer.customerNo)
      STSCLOC (STQCLNO = :myLocation.locationNo)
      STSOCORD (STQCODN = :myOrder.orderDateno) };
Danach können Sie den folgenden Code zum Abrufen der Zeilensegmente in der Bestellung verwenden:
get next inParent myItem;
  while (myItem not noRecordFound)
  // process the current item
  get next inParent myItem;
end
In EGL wird dann der folgende Pseudo-DL/I-Code für die Anweisung GET NEXT INPARENT erstellt:
GNP  STLCITM 

Mit anderen Nicht-Schlüsselfeldern suchen

Sie können in einem Segment jedes Feld als Suchargument bei einem DL/I-Aufruf verwenden, indem Sie die Suchargumente (SSAs) für den Aufruf ändern. Wenn Sie zum Beispiel die Kundendatenbank durchsuchen und die Segmente für Kunde und Kredit für jeden Kunden mit einem Guthaben über einem bestimmten Betrag abrufen möchten, können Sie die Suchargumente für den DL/I-Aufruf wie folgt definieren:
  1. Sie möchten das Feld 'creditBalance' (STFCSBL) im Segment für den Kredit (STSCSTA) durchsuchen. Definieren Sie dazu eine Variable vom Typ 'decimal(12,2)' (zum Beispiel 'targetBalance'), die den angegebenen Betrag enthält, nach dem Sie suchen möchten. Die Definition für 'targetBalance' muss mit der Definition für das Feld 'creditBalance' im Segment für den Kredit übereinstimmen.
  2. Schreiben Sie eine GET NEXT-Anweisung für den Datensatz 'myCrStatus'.
  3. Fügen Sie der Zeile eine #dli-Direktive hinzu, mit der der Standardcode geändert wird. Fügen Sie einen qualifizierten SSA hinzu, mit dem nach Segmenten gesucht wird, in denen der Betrag im Feld 'creditBalance' höher ist als der im Feld 'targetBalance'.
  4. Fügen Sie einen Pfadbefehlscode (*D) zum Abrufen des Segments für den Kunden (STSCCST) hinzu, das dem Segment für den Kredit entspricht.
Dieser Prozess wird mithilfe des folgenden Beispielcodes veranschaulicht:
	targetBalance decimal(12,2);
	targetBalance = 10,000.00;

	get next myCustomer,myCrStatus with #dli{
		GU STSCCST*D STSCSTA (STFCSBL >= :targetBalance) };

Anhand von Informationen in anderen Datensätzen Suchen durchführen

Möglicherweise möchten Sie eine Suche anhand von Informationen in anderen Datensätzen durchführen. Berücksichtigen Sie die Situation, in der die Kundennummer wie folgt an das Programm in einem Parametersatz übergeben wird:
Record CustomerData type basicRecord 
  10 customerNo char(6) 
  ... 
end

Program myProgram 
  (customerParm  CustomerData)
  { @DLI{ psb = "myCustomerPSB" }} 
  //declare variables 
  myCustomerPSB     CustomerPSBRecordPart; 
  myCustomer        CustomerRecordPart;
Sie möchten das Segment für den Kunden anhand des Wertes in customerParm.customerNo abrufen. Es gibt drei Möglichkeiten, dies zu codieren:
  • Weisen Sie den Wert von customerParm.customerNo an myCustomer.customerNo zu und verwenden Sie die implizite DL/I-Ein-/Ausgabe wie folgt:
    myCustomer.customerNo = CustomerParm.customerNo;
    get myCustomer;
    In diesem Fall werden in EGL die normalen Standard-SSAs erstellt, woraus sich der folgende Pseudo-DL/I-Code ergibt:
    GU STSCCST (STQCCNO = :myCustomer.customerNo)
    Der Vorteil dieses Verfahrens ist, dass es sehr einfach ist. Der Nachteil liegt in sehr geringen Leistungseinbußen beim Verschieben der Kundennummer in den Segmentdatensatz.
  • Verwenden Sie die #dli-Direktive und die explizite DL/I-Ein-/Ausgabe, um das Feld 'customerParm.customerNo' wie folgt als Hostvariable zu verwenden:
    get myCustomer with #dli {
       GU  STSCCST (STQCCNO = :customerParm.customerNo) } ;
    Mit diesem Verfahren werden die Leistungseinbußen beim Verschieben der Kundennummer vermieden. Es dauert jedoch ein wenig länger, Daten in die Standard-#dli-Direktive einzufügen und den Code dann zu ändern, um den korrekten Variablennamen des Datensatzes für den Parameterdatensatz zu verwenden.
  • Fügen Sie die Eigenschaft 'hostVarQualifier' in den Datensatz 'DLISegment' ein, um das Qualifikationsmerkmal wie folgt für die Hostvariable anzugeben:
    Record CustomerRecordPart type DLISegment 
      {segmentName="STSCCST", keyItem="customerNo", 
       hostVarQualifier="customerParm" }
      10 customerNo char(6) { dliFieldName = "STQCCNO" }; //key field 
      ... 
    end
    Danach können Sie die implizite DL/I-Ein-/Ausgabe verwenden, ohne zuerst wie folgt customerParm.customerNo an myCustomer.customerNo zuweisen zu müssen:
    get myCustomer;
    Der Pseudo-DL/I-Code, der in diesem Fall in EGL erstellt wird, lautet:
    GU STSCCST (STQCCNO = :customerParm.customerNo)

    Der Vorteil dieses Verfahrens besteht darin, dass es zum selben Pseudo-DL/I-Code führt, den Sie für die #dli-Direktive geschrieben haben, jedoch ohne dass Sie den Code für die #dli-Direktive tatsächlich schreiben müssen. Der Nachteil ist, dass in EGL nun customerParm als Qualifikationsmerkmal für alle impliziten E/A-Anweisungen für die DL/I-Datenbank verwendet wird, für die 'CustomerRecordPart' verwendet wird.

Nach Nicht-Stammsegmenten suchen

Sie können die implizite DL/I-Datenbank-Ein-/Ausgabe zum Abrufen von Nicht-Stammsegmenten verwenden. In EGL wird die gesamte Kette von SSAs anhand der hierarchischen Position des Zielsegments im PCB erstellt. Für Segmente höherer Ebene in der Hierarchie kann in EGL jedoch nicht automatisch der Name der Programmvariable für die Verwendung als Qualifikationsmerkmal für das Segment bestimmt werden.

Berücksichtigen Sie die Situation, in der das Segment für den Kunden (STSCCST) das übergeordnete Segment des Segments für den Standort (STSCLOC) ist und Sie nur die Daten für das Segment für den Standort abrufen möchten. In Ihrem Programm sind die folgenden Datensatzvariablen definiert:
myCustomer CustomerRecordPart; 
myLocation LocationRecordPart;
Verwenden Sie die folgende GET-Anweisung:
get myLocation;
In EGL wird dann der folgende Pseudo-DL/I-Code erstellt:
GU STSCCST (STQCCNO = :CustomerRecordPart.customerNo) 
  STSCLOC (STQCLNO = :myLocation.locationNo)

Beachten Sie, dass die Variable myCustomer, die auf 'CustomerRecordPart' basiert, in EGL nicht gefunden werden konnte, während die Variable myLocation dem Segment STSCLOC ordnungsgemäß zugeordnet werden konnte. In EGL ist nur bekannt, dass myLocation vom Typ 'LocationRecordPart' ist, dessen übergeordnetes Segment 'CustomerRecordPart' ist, und dass 'keyItem' für 'CustomerRecordPart' customerNo ist.

Dieses Problem kann auf die folgenden Arten behoben werden:
  • Sie können Ihre Datensatzvariablen genauso wie die Datensatzabschnitte benennen, auf denen sie basieren. Ändern Sie zum Beispiel die Variablendeklaration für 'myCustomer' in 'CustomerRecordPart'.
    CustomerRecordPart CustomerRecordPart;
    In EGL wird dann derselbe Pseudo-DL/I-Code erstellt:
    GU STSCCST (STQCCNO = :CustomerRecordPart.customerNo) 
      STSCLOC (STQCLNO = :myLocation.locationNo)

    Da die Standard-SSAs in EGL aus den PCB-Hierarchieinformationen erstellt werden, ist dies eine einfache Möglichkeit, um sicherzustellen, dass die in EGL verwendeten Variablennamen mit den Datensatzvariablendeklarationen Ihres Programms übereinstimmen. Der Nachteil ist, dass dieses Verfahren nicht der allgemeinen Praxis, unterschiedliche Namen für Abschnitte und Variablen zu verwenden, entspricht.

  • Verwenden Sie die #dli-Direktive und die explizite DL/I-Datenbank-Ein-/Ausgabe wie folgt:
    get myLocation with #dli {
      GU STSCCST (STQCCNO = :myCustomer.customerNo)
        STSCLOC (STQCLNO = :myLocation.locationNo)

    Der Vorteil dieses Verfahrens ist, dass sehr deutlich ist, welche Hostvariablen verwendet werden. Dieses Verfahren ist einfach anzuwenden, wenn das Qualifikationsmerkmal oder der Feldname der Hostvariable sich von der Datensatzvariable unterschiedet, die auf dem DL/I-Segmentdatensatz basiert. Der Nachteil ist derselbe wie für alle expliziten Ein-/Ausgaben: Wenn die Hierarchie oder die Schlüsselfelder geändert werden, wird die explizite E/A-Anweisung der DL/I-Datenbank nicht automatisch geändert.

  • Ändern Sie die Definition für 'CustomerRecordPart', um die Eigenschaft 'hostVarQualifier' wie folgt aufzunehmen:
    Record CustomerRecordPart type DLISegment 
      { segmentName="STSCCST", keyItem="customerNo",
        hostVarQualifier = "myCustomer" } 
      10 customerNo char(6) { dliFieldName = "STQCCNO" }; //key field 
      ... 
    end
    Verwenden Sie nun die folgende GET-Anweisung:
    get myLocation;
    In EGL wird dann der korrekte Pseudo-DL/I-Code erstellt:
    GU STSCCST (STQCCNO = :myCustomer.customerNo) 
      STSCLOC (STQCLNO = :myLocation.locationNo)

    Der Vorteil dieses Verfahrens ist, dass Sie die implizite Ein-/Ausgabe der DL/I-Datenbank und unterschiedliche Namen für die Datensatzvariablen und die DL/I-Segmentdatensätze verwenden können. Der Nachteil ist, dass in EGL nun myCustomer als Qualifikationsmerkmal für alle impliziten E/A-Anweisungen für die DL/I-Datenbank verwendet wird, für die 'CustomerRecordPart' verwendet wird.

Mit einem Sekundärindex suchen

Manchmal zeigt der DL/I-PSB an, dass auf eine Datenbankstruktur mithilfe eines Sekundärindexes zugegriffen werden muss. Wenn dieser Fall eintritt, muss der Datenbankadministrator neben dem Stammsegment einen Indexschlüsselnamen in der PCB-Laufzeitdefinition eingeben. Sie benachrichtigen EGL über die Verwendung eines Sekundärindexes, indem Sie die Eigenschaft 'secondaryIndex' in den PCB-Datensatz in 'PSBRecord' aufnehmen. Wenn Sie zum Beispiel eine andere Sicht der Kundendatenbank haben, in der customerName der Sekundärindex ist, können Sie dem PSB-Datensatzabschnitt wie folgt einen zusätzlichen PCB-Datensatz hinzufügen:
// database PCB for customer by Name
customerNamePCB DB_PCBRecord 
  { @PCB { pcbType = DB, pcbName = "STDCNAM", 
    secondaryIndex = "STUCCNM",
    hierarchy = [ @relationship { segmentRecord = "CustomerRecordPart" },
    ... ] }
  }

Die Eigenschaft 'pcbName' muss mit einem tatsächlichen DL/I-Datenbank-PCB im Laufzeit-PSB übereinstimmen. Mit der Eigenschaft 'secondaryIndex' muss derselbe Feldname bereitgestellt werden, den der Datenbankadministrator in der XDFLD-Anweisung des Laufzeit-PCBs angegeben hat. Es gibt nun zwei PCB-Datensätze im PSB-Datensatz, in deren Hierarchie 'CustomerRecordPart' vorhanden ist.

Verwenden Sie wie im folgenden Beispiel eine GET-Anweisung zum Suchen eines Kunden:
myCustomer CustomerRecordPart;
get myCustomer;
In EGL wird dann basierend auf dem ersten PCB-Datensatz im PSB-Datensatz der Pseudo-DL/I-Code erstellt, der den Abschnitt 'CustomerRecord' enthält.
Wenn die Sekundärindexdatenbank der zweite PCB-Datensatz im PSB-Datensatz ist, müssen Sie wie im folgenden Beispiel das Schlüsselwort 'usingPCB' aufnehmen, damit in EGL der korrekte PCB verwendet wird:
get myCustomer usingPCB customerNamePCB;
In EGL dann wird der folgende Pseudo-DL/I-Code erstellt:
GU STSCCST (STUCCNM = :myCustomer.customerName)
Beachten Sie, dass in EGL der Name der Datensatzvariable aus der GET-Anweisung (myCustomer) und der PCB verwendet wurden, der vom Schlüsselwort 'usingPCB' (customerNamePCB) zum Suchen der folgenden Informationen angegeben wurde:
  • Der DL/I-Name des Segments (Eigenschaft segmentName = "STSCCST").
  • Der DL/I-Name des Feldes für den Sekundärindex (Eigenschaft secondaryIndex = "STUCCNM").
  • Der Name des EGL-Feldes für den Vergleichswert (Eigenschaft dliFieldName = "STUCCNM" und dann der entsprechende Name für das Feld 'customerName').
In einigen Fällen kann ein Sekundärindex auf einem Segment auf niedrigerer Ebene in der physischen Datenbank vorhanden sein. In diesem Fall wird die Datenbankstruktur invertiert. Wenn zum Beispiel ein Sekundärindex für das Feld 'orderReference' im Segment für die Bestellung vorhanden ist, muss die Datenbankhierarchie, wie sie von Ihrem Programm angezeigt wird, wie folgt im entsprechenden PCB-Datensatz dargestellt werden:
// orders view of customer database 
ordersByReferencePCB DB_PCBRecord 
  { @PCB { pcbType = DB, pcbName = "STDCDBL", 
    secondaryIndex = "STFCORF",   //use DL/I name 
    hierarchy = [ 
        @relationship { segmentRecord = "OrderRecordPart" }, 
        @relationship { segmentRecord = "LocationRecordPart", 
                                    parentRecord = "OrderRecordPart" }, 
        @relationship { segmentRecord = "CustomerRecordPart", 
                                    parentRecord = "LocationRecordPart" }, 
        @relationship { segmentRecord = "ItemRecordPart", 
                                    parentRecord = "OrderRecordPart" }
        ]}
  }; 
end 
Angenommen, die Referenznummer der Bestellung ist für jeden Kunden und für jede Bestellung eindeutig, müssen keine Schlüssel für die Segmente für den Standort und den Kunden verwendet werden. Angenommen, 'ordersByReferencePCB' ist nun Ihr Standard-PCB, können Sie sowohl die Bestellung als auch den Kunden abrufen, indem Sie den SSA wie folgt so ändern, dass der Vergleich für die Segmente für den Standort und den Kunden gelöscht wird:
get myOrder, myCustomer with #dli{ 
  GU STPCORD*D (STQCODN = :myOrder.orderReference) 
    STSCLOC 
    STSCCST };

Pfadaufrufe zum Zugreifen auf mehrere Segmente verwenden

Wenn Sie eine EGL-E/A-Anweisung mit einem abhängigen Segmentdatensatzobjekt aufrufen, können Sie gleichzeitig alle Segmente auf dem Pfad vom Stammverzeichnis zum Objekt lesen. Dies ist möglich, indem Sie einfach die Datensätze für den Pfadaufruf zur Anweisung hinzufügen. Wenn zum Beispiel ein Segment für die Bestellung von der Beispielkundendatenbank abgerufen wird, können Sie beim selben Aufruf die Segmente für den Kunden, den Standort und die Bestellung auslesen.
get myCustomer, myLocation, myOrder;
Mit dieser Anweisung wird der folgende DL/I-Pseudocode generiert.
GU STSCCST*D (STQCCNO = :myCustomer.customerNo) 
   STSCLOC*D (STQCLNO = :myLocation.locationNo)
   STPCORD   (STQCDDN = :myOrder.orderDateNo)
Wenn Sie den Befehlscode D in der Anweisung GET...FORUPDATE verwenden, betrifft die folgende REPLACE-Anweisung alle abgerufenen Segmente. Sie können das Ersetzen eines ausgewählten Segments durch Angeben eines expliziten Befehlscodes N im SSA für das Schlüsselwort 'replace' verhindern, mit dem, wie im folgenden Beispiel beschrieben, nur die Segmente für den Standort und die Bestellung ersetzt werden:
get myCustomer, myLocation, myOrder forUpdate;
replace myOrder with #dli{
	REPL STSCCST*N
	     STSCLOC*N
       STPCORD };
Mit dem Standard-DL/I-Aufruf, der in EGL für eine DELETE-Funktion durchgeführt wird, die auf eine GET FORUPDATE-Anweisung mit Befehlscodes D folgt, werden nicht alle abgerufenen Segmente gelöscht. Es wird nur das in der DELETE-Anweisung angegebene Zielsegment gelöscht.

Alle Segmente mit einer einzigen E/A-Anweisung auslesen

Sie können eine einzige E/A-Anweisung zum Auslesen aller Segmente in einer Datenbank verwenden. Wenn Sie eine GET NEXT-DL/I-Anweisung ohne SSAs verwenden, wird in DL/I das nächste Segment in der Datenbank unabhängig von dessen Typ ausgegeben. Führen Sie die folgenden Schritte durch, um dieses Verfahren anzuwenden:
  1. Schreiben Sie eine GET NEXT-Anweisung für den Datensatz, der das größte Segment in der Datenbank darstellt. Dadurch wird sichergestellt, dass keines der ausgelesenen Segmente den reservierten Hauptspeicher überschreitet.
  2. Fügen Sie Ihrem Code den DL/I-Standardaufruf hinzu. Bearbeiten Sie die #dli-Direktive, um den einzelnen SSA zu löschen.
  3. Erstellen Sie Datensätze, die mit den übrigen Segmenten in der Datenbank übereinstimmen. Deklarieren Sie die Datensätze im Programm und geben Sie an, dass mit jedem der Datensätze der in Schritt 1 verwendete Datensatz neu definiert wird, sodass alle Datensätze denselben Speicherbereich belegen.
  4. Prüfen Sie 'dliVar.segmentName' nach der GET NEXT-Anweisung, um den Typ des abgerufenen Segments zu bestimmen.
  5. Greifen Sie von der entsprechenden Datensatzstruktur aus auf das abgerufene Segment zu.
Im Folgenden ist ein Codebeispiel aufgeführt, mit dem alles aus der Kundendatenbank ausgegeben wird. In diesem Beispiel ist 'HistoryRecordPart' der größte DLISegment-Datensatz:
myHistory HistoryRecordPart
redefCustomer CustomerRecordPart {redefines=myHistory};
redefLocation LocationRecordPart {redefines=myHistory};
...


//read next segment, whatever type it is, into history record
while (myHistory not EOF)
	get next myHistory with #dli{
		GN };

	//so what type was it?
	case (dliVar.segmentName)
		when "STSCCST"                   // it was a customer
			printCustomer();
		when "STSCLOC"                   // it was a location
			printLocation();
		...
	end
end

Dynamische Feldgruppen verwenden

Sie können die Anweisungen GET und GET NEXT zum Abrufen von DL/I-Segmenten in eine dynamische Feldgruppe verwenden. Da für die Feldgruppe selbst kein Schlüsselfeld vorhanden ist (nur für Elemente der Feldgruppe), müssen Sie einige besondere Verfahren anwenden, damit in EGL der korrekte Code verwendet wird.

Berücksichtigen Sie die Situation, in der Sie die Datensatzvariablen und eine dynamische Feldgruppe definiert haben, wie folgt:
myCustomer CustomerRecordPart;
myLocation LocationRecordPart;
myOrder OrderRecordPart;
myOrderArray OrderRecordPart [] {maxsize = 20};  // array of orders
Sie können eine GET-Anweisung zum erstmaligen Füllen der Feldgruppe und eine GET NEXT-Anweisung zum Abrufen der zweiten Gruppe von 20 Bestellungen wie folgt verwenden:
myCustomer.customerNo = "123456";
myLocation.locationNo = "ABCDEF";
myOrderDateNo = "20050730A003";
get myOrderArray;                  // fill the array the first time
... do some processing
get next myOrderArray;          // get the next batch of 20 orders
In EGL wird dann der folgende Pseudo-DL/I-Code für die GET-Anweisung erstellt:
get myOrderArray with #dli{
  GU STSCCST (STQCCNO = :CustomerRecordPart.customerNo)
    STSCLOC (STQCLNO = :LocationRecordPart.locationNo)
    STPCORD (STQCODN = :OrderRecordPart.orderDateNo)
  GN STPCORD };
In EGL dann wird der folgende Pseudo-DL/I-Code für die GET NEXT-Anweisung erstellt:
get next myOrderArray with #dli{
  GN STPCORD };

Zum Füllen der dynamischen Feldgruppe für den ersten Batch von 20 Bestellungen mit einer GET-Anweisung ist ein erstmaliger GU-Aufruf gefolgt von einer Schleife von GN-Aufrufen erforderlich, bis die Feldgruppe voll ist oder für DL/I keine Segmentvorkommen mehr vorhanden sind. Im Pseudo-DL/I-Code, der in EGL erstellt wird, wird durch den GU-Aufruf das erste Segment für die Bestellung abgerufen. In EGL wird der GN-Aufruf als Schleife behandelt und die Logik für die Schleife bereitgestellt, die durchgeführt wird, bis die Feldgruppe voll ist oder für DL/I keine Segmentvorkommen mehr vorhanden sind. Auf ähnliche Weise wird die GET NEXT-Anweisung in EGL als Schleife behandelt und die Schleifensteuerungslogik für Sie bereitgestellt.

Durch die GET NEXT-Anweisung wird der korrekte Pseudo-DL/I-Code zum Abrufen des zweiten Batches von Bestellungen bereitgestellt. Der Pseudo-DL/I-Code für die GET-Anweisung ist jedoch nicht vollständig korrekt; die Namen der Qualifikationsmerkmale für die Hostvariablen sind nicht die Namen der Datensatzvariablen in Ihrem Programm. Dieses Problem kann auf die folgenden Weisen behoben werden:
  • Benennen Sie Ihre DL/I-Segmentdatensätze mit demselben Namen wie die Segmente in der DL/I-Datenbank. Ändern Sie auch die Namen Ihrer Datensatzvariablen so, dass sie mit den Namen der Segmente in der DL/I-Datenbank übereinstimmen. Ändern Sie zum Beispiel die Abschnittsdefinition für den Kundendatensatz von folgendem Text:
    Record CustomerRecordPart type DLISegment 
      { segmentName="STSCCST", keyItem="customerNo" } 
      10 customerNo char(6) { dliFieldName = "STQCCNO" }; //key field 
      ... 
    end
    in den folgenden:
    Record STSCCST type DLISegment 
      { segmentName="STSCCST", keyItem="customerNo" } 
      10 customerNo char(6) { dliFieldName = "STQCCNO" }; //key field 
      ... 
    end
    Nehmen Sie ähnliche Änderungen für das Segment für den Standort (STSCLOC) und das Segment für die Bestellung (STPCORD) vor. Ändern Sie dann wie folgt den PSB-Datensatz, um die neuen Namen zu verwenden:
    Record CustomerPSBRecordPart type PSBRecord { defaultPSBName="STBICLG" } 
      // database PCB 
      customerPCB DB_PCBRecord { @PCB { pcbType = DB, pcbName = "STDCDBL", 
      hierarchy = [ @relationship { segmentRecord = "STSCCST" },
           @relationship {segmentRecord="STSCLOC",
                          parentRecord="STSCCST"},
           @relationship {segmentRecord="STPCORD",
                          parentRecord="STSCLOC"}
           ]}};
    
    end
    Ändern Sie die Deklaration Ihrer Datensatzvariablen und von 'myOrderArray' wie folgt so, dass sie auf die neuen Datensatzabschnitte des DL/I-Segments verweisen:
    STSCCST STSCCST;
    STSCLOC STSCLOC;
    STPCORD STPCORD;
    myOrderArray STPCORD [] {maxsize = 20};  // array of orders
    Verwenden Sie nun die folgende GET-Anweisung:
    get myOrderArray;             // fill the array the first time
    In EGL wird dann für die GET-Anweisung der folgende Pseudo-DL/I-Code erstellt und für die Qualifikationsmerkmale für die Hostvariablen werden die korrekten Namen für die Datensatzvariablen verwendet:
    get myOrderArray with #dli{
      GU STSCCST (STQCCNO = :STSCCST.customerNo)
        STSCLOC (STQCLNO = :STSCLOC.locationNo)
        STPCORD (STQCODN = :STPCORD.orderDateNo)
      GN STPCORD };

    Da die Standard-SSAs in EGL aus den PCB-Hierarchieinformationen erstellt werden, ist dies eine einfache Möglichkeit, um sicherzustellen, dass die in EGL verwendeten Variablennamen mit den Datensatzvariablendeklarationen Ihres Programms übereinstimmen. Der Nachteil ist, dass dieses Verfahren nicht der allgemeinen Praxis, unterschiedliche Namen für Abschnitte und Variablen zu verwenden, entspricht.

  • Verwenden Sie die #dli-Direktive und die explizite DL/I-Datenbank-Ein-/Ausgabe wie folgt:
    get myOrderArray with #dli{
      GU STSCCST (STQCCNO = :myCustomer.customerNo)
        STSCLOC (STQCLNO = :myLocation.locationNo)
        STPCORD (STQCODN = :myOrder.orderDateNo)
      GN STPCORD };
    Der Vorteil dieses Verfahrens ist, dass sehr deutlich ist, welche Hostvariablen verwendet werden. Dieses Verfahren ist besonders nützlich, wenn Sie den Standard-DL/I-Code ändern müssen, zum Beispiel, wenn Sie die erste Bestellnummer für den Kunden nicht kennen und den folgenden DL/I-Code verwenden möchten:
    myOrder.orderDateNo = "";
    get myOrderArray with #dli{
      GU STSCCST (STQCCNO = :myCustomer.customerNo)
        STSCLOC (STQCLNO = :myLocation.locationNo)
        STPCORD (STQCODN >= :myOrder.orderDateNo)   // using >= instead of =
      GN STPCORD };

    Der Nachteil dieses Verfahrens ist derselbe wie für alle expliziten Ein-/Ausgaben: Wenn die Hierarchie oder die Schlüsselfelder geändert werden, wird die explizite E/A-Anweisung der DL/I-Datenbank nicht automatisch geändert.

  • Ändern Sie die Definition für Ihre DL/I-Segmentdatensätze, um die Eigenschaft 'hostVarQualifier' mit dem Namen Ihrer Programmdatensatzvariable aufzunehmen. Ändern Sie zum Beispiel 'CustomerRecordPart' wie folgt:
    Record CustomerRecordPart type DLISegment 
      { segmentName="STSCCST", keyItem="customerNo",
        hostVarQualifier = "myCustomer" } 
      10 customerNo char(6) { dliFieldName = "STQCCNO" }; //key field 
      ... 
    end
    Verwenden Sie nun die folgenden Datensatzdeklarationen und die GET-Anweisung:
    myCustomer CustomerRecodPart;
    myLocation LocationRecordPart;
    myOrder OrderRecordPart;
    myOrderArray OrderRecordPart [] {maxsize = 20};  // array of orders
    get myOrderArray;                  // fill the array the first time
    In EGL wird dann der korrekte Pseudo-DL/I-Code erstellt:
    get myOrderArray with #dli{
      GU STSCCST (STQCCNO = :myCustomer.customerNo)
        STSCLOC (STQCLNO = :myLocation.locationNo)
        STPCORD (STQCODN = :myOrder.orderDateNo)
      GN STPCORD };

    Der Vorteil dieses Verfahrens ist, dass Sie die implizite Ein-/Ausgabe der DL/I-Datenbank und unterschiedliche Namen für die Datensatzvariablen und die DL/I-Segmentdatensätze verwenden können. Der Nachteil ist, dass in EGL nun 'myCustomer' als Qualifikationsmerkmal für alle impliziten E/A-Anweisungen für die DL/I-Datenbank verwendet wird, für die 'CustomerRecordPart', 'LocationRecordPart' und 'OrderRecordPart' verwendet werden.


Feedback