Datenbereiche (Data Areas)

#### Search Results

Search

# Datenbereiche (Data Areas)

Wie im Abschnitt Felder definieren erläutert, müssen alle Felder, die in einem Programm verwendet werden sollen, mit einem `DEFINE DATA`-Statement definiert werden.

Die Felder können entweder innerhalb des `DEFINE DATA`-Statements selbst definiert werden oder sie können außerhalb des Programms in einem separaten Datenbereich (Data Area) definiert werden, der dann vom `DEFINE DATA`-Statement referenziert wird.

Eine solche separate Data Area ist ein Natural-Objekt, das von mehreren Natural-Programmen, -Subprogrammen, -Subroutinen, Helproutinen oder Klassen benutzt werden kann. Eine Data Area enthält Datenelement-Definitionen, wie z.B. benutzerdefinierte Variablen, Konstanten und Datenbankfelder aus einem Datendefinitionsmodul (DDM).

Alle Data Areas werden mit dem Data Area Editor erstellt und editiert.

Mit Natural können Sie folgende Arten von Data Areas anlegen und referenzieren:

- Local Data Area

- Global Data Area

- Parameter Data Area

## Local Data Area (LDA)

Als "lokal" definierte Variablen können nur von einem einzigen Natural-Objekt benutzt werden.

Sie haben zwei Möglichkeiten, lokale Daten zu definieren:

- Sie können die Daten innerhalb des Programms definieren.

- Sie können die Daten außerhalb des Programms in einem separaten Natural-Objekt, einer Local Data Area (LDA), definieren.

Um eine übersichtlich strukturierte und einheitliche Anwendung zu erhalten, ist es in der Regel besser, Felder in Data Areas außerhalb der Programme zu definieren.

#### Beispiel 1 — Felddefinitionen innerhalb des DEFINE DATA-Statements:

Im folgenden Beispiel sind die Felder direkt innerhalb des `DEFINE DATA`-Statements des Programms definiert.

    DEFINE DATA LOCAL
    1 VIEWEMP VIEW OF EMPLOYEES
      2 NAME
      2 FIRST-NAME
      2 PERSONNEL-ID
    1 #VARI-A (A20)
    1 #VARI-B (N3.2)
    1 #VARI-C (I4)
    END-DEFINE
    ...

#### Beispiel 2 — Felddefinitionen in einer separaten Data Area:

Im diesem Beispiel sind dieselben Felder nicht im `DEFINE DATA`-Statement des Programms, sondern in einer LDA mit dem Namen `LDA39` definiert, und das `DEFINE DATA`-Statement enthält lediglich eine Referenz auf diese Data Area.

Programm:

Das Programm selbst enthält keine Felddefinitionen, sondern referenziert die in der `LDA39` enthaltenen Felddefinitionen.

    DEFINE DATA LOCAL
           USING LDA39
    END-DEFINE
      ...

Referenzierte Local Data Area `LDA39`:

    I T L  Name                             F Length     Miscellaneous
    All -- -------------------------------- - ---------- ------------------------->
      V  1 VIEWEMP                                       EMPLOYEES
         2 PERSONNEL-ID                     A          8
         2 FIRST-NAME                       A         20
         2 NAME                             A         20
         1 #VARI-A                          A         20
         1 #VARI-B                          N        3.2
         1 #VARI-C                          I          4

## Global Data Area (GDA)

Wenn Sie die Datenelemente in einem separaten Bereich definieren möchten, der von mehreren Natural-Objekten genutzt werden kann, verwenden Sie eine Globa Data Area.

Folgende Themen werden behandelt:

- GDA anlegen und referenzieren

- GDA-Instanzen anlegen und löschen

- Datenblöcke

### GDA anlegen und referenzieren

GDAs werden mit dem Natural Data Area Editor angelegt und geändert. Weitere Informationen entnehmen Sie dem Abschnitt Datenbereich-Editor (Data Area Editor) in der Editoren-Dokumentation.

Eine GDA, die von einem Natural-Objekt referenziert wird, muss in derselben Natural-Library (oder in einer für diese Library definierten Steplib) gespeichert werden, in der auch das diese GDA referenzierende Objekt gespeichert ist.

Anmerkung
Verwendung einer GDA namens `COMMON` beim Start:
Wenn eine GDA mit Namen `COMMON` in einer Library vorhanden ist, wird das Programm mit Namen `ACOMMON` automatisch aufgerufen, wenn Sie sich per `LOGON` in dieser Library anmelden.

Wichtig
Wenn Sie eine Anwendung erstellen, bei der mehrere Natural-Objekte eine GDA referenzieren, denken Sie bitte daran, dass Änderungen an den Datenelement-Definitionen in der GDA alle Natural-Objekte betreffen, die diese Data Area referenzieren. Deshalb müssen diese Objekte mittels des Kommandos `CATALOG` oder `STOW` neu kompiliert werden, nachdem die GDA geändert worden ist.

Um eine GDA zu benutzen, muss ein Natural-Objekt sie mit der `GLOBAL`-Klausel des `DEFINE DATA`-Statements referenzieren. Jedes Natural-Objekt kann nur eine GDA referenzieren; d.h. ein `DEFINE DATA`-Statement darf nicht mehr als eine `GLOBAL`-Klausel enthalten.

### GDA-Instanzen anlegen und löschen

Die erste Instanz einer GDA wird angelegt und zur Laufzeit initialisiert, wenn das erste, sie referenzierende Natural-Objekt ausgeführt wird.

Sobald eine GDA-Instanz angelegt worden ist, können die Datenwerte, die sie enthält, von allen Natural-Objekten gemeinsam benutzt werden, die diese GDA referenzieren (`DEFINE DATA GLOBAL`-Statement) und die von einem `PERFORM`-, `INPUT`- oder `FETCH`-Statement aufgerufen werden. Alle Objekte, die eine GDA-Instanz gemeinsam benutzen, arbeiten mit dieselben Datenelementen.

Eine neue GDA-Instanz wird angelegt, wenn Folgendes gilt:

- Ein Subprogramm, das eine GDA (eine beliebige GDA) referenziert, wird mit einem `CALLNAT`-Statement aufgerufen.

- Ein Subprogramm, das keine GDA referenziert, ruft ein Objekt auf, das eine GDA (eine beliebige GDA) referenziert.

Beim Anlegen einer neuen Instanz einer GDA wird die aktuelle GDA-Instanz zeitweilig unterbrochen, und die Datenwerte, die sie enthält, werden auf einem Stack abgelegt. Das Subprogramm referenziert dann die Datenwerte in der neu erstellten GDA-Instanz. Auf die Datenwerte in der/den zeitweilig unterbrochenen GDA-Instanz/Instanzen ist kein Zugriff möglich. Ein Objekt bezieht sich nur auf eine GDA-Instanz und kann nicht auf vorherige GDA-Instanzen zugreifen. Ein GDA-Datenelement kann nur an ein Subprogramm übergeben werden, wenn das Element als ein Parameter im `CALLNAT`-Statement definiert wird.

Wenn das Subprogramm zum aufrufenden Objekt zurückkehrt, wird die von ihm referenzierte GDA-Instanz gelöscht, und die vorher zeitweilig unterbrochene GDA-Instanz wird mit ihren Datenwerten wieder aufgenommen.

Eine GDA-Instanz und ihr Inhalt wird gelöscht, wenn einer der folgenden Punkte gilt:

- Das nächste `LOGON` wird ausgeführt.

- Eine andere GDA wird auf derselben Stufe referenziert (Stufen werden später in diesem Abschnitt beschrieben).

- Ein `RELEASE VARIABLES`-Statement wird ausgeführt.

  In diesem Fall werden die Datenwerte in einer GDA-Instanz zurückgesetzt, und zwar entweder wenn ein Programm auf der Stufe 1 seine Ausführung beendet, oder wenn das Programm ein anderes Programm über ein `FETCH`- oder `RUN`-Statement aufruft.

  Die folgende Grafik zeigt, wie Objekte GDAs referenzieren und Datenelemente in GDA-Instanzen gemeinsam nutzen.

#### Gemeinsame Nutzung von GDA-Instanzen

Die folgende Grafik veranschaulicht, dass ein eine GDA referenzierendes Subprogramm die Datenwerte nicht gemeinsam in einer GDA-Instanz benutzen kann, die von dem aufrufenden Programm referenziert wird. Ein Subprogram, das dieselbe GDA referenziert wie das aufrufende Programm, legt eine neue Instanz dieser GDA an. Die Datenelemente, die in einer GDA definiert sind, die von einem Subprogramm referenziert wird, können aber von einer vom Subprogramm aufgerufenen Subroutine oder Helproutine gemeinsam benutzt werden.

Die folgende Grafik zeigt drei GDA-Instanzen von `GDA1` und die Endwerte, die jeder GDA-Instanz vom Datenelement `#GLOB1` zugewiesen werden. Die Zahlen (1) bis (7) verweisen auf die hierarchischen Stufen der Objekte.

#### Benutzung von FETCH oder FETCH RETURN

Die folgende Grafik veranschaulicht, dass Programme, die dieselbe GDA referenzieren und sich gegenseitig mit dem `FETCH`- oder `FETCH RETURN`-Statement aufrufen, die in dieser GDA definierten Datenelemente gemeinsam benutzen. Wenn eines dieser Programme keine GDA referenziert, bleibt die Instanz der vorher referenzierten GDA aktiv, und die Werte der Datenelemente werden zurückbehalten.

Die Zahlen (1) und (2) verweisen auf die hierarchischen Stufen der Objekte.

#### Benutzung von FETCH mit verschiedenen GDAs

Die folgende Grafik veranschaulicht Folgendes: Wenn ein Programm das `FETCH`-Statement benutzt, um ein anderes Programm aufzurufen, das eine unterschiedliche GDA referenziert, wird die aktuelle, vom aufrufenden Programm referenzierte Instanz der GDA (hier: `GDA1`) gelöscht. Wenn diese GDA dann erneut von einem anderen Programm referenziert wird, dann wird eine neue Instanz dieser GDA angelegt, bei der alle Datenelemente ihre Anfangswerte haben.

Sie können das `FETCH RETURN`-Statement nicht benutzen, um ein anderes Programm aufzurufen, das eine unterschiedliche GDA referenziert.

Die Zahl (1) verweist auf die hierarchische Stufe der Objekte.

Die aufrufenden Programme `PROG3` und `PROG4` beeinflussen die GDA-Instanzen wie folgt:

- Das Statement `GLOBAL USING GDA2` in `PROG3` legt eine Instanz von `GDA2` an und löscht die aktuelle Instanz von `GDA1`.

- Das Statement `GLOBAL USING GDA1` in `PROG4` löscht die aktuelle Instanz von `GDA2` und legt eine neue Instanz von `GDA1` an. Als Ergebnis davon zeigt das `WRITE`-Statement den Wert Null (0) an.

### Datenblöcke

Um Datenspeicherplatz zu sparen, können Sie eine GDA mit Datenblöcken erstellen.

Folgende Themen werden in diesem Abschnitt behandelt:

- Beispiel für die Benutzung von Datenblöcken
- Datenblöcke definieren
- Block-Hierarchien

#### Beispiel für die Benutzung von Datenblöcken

Datenblöcke können sich bei der Programmausführung gegenseitig überlagern, wodurch Speicherplatz eingespart wird.

Gehen wir beispielsweise davon aus, dass bei der folgenden vorgegebenen Hierarchie den Blöcken B und C derselbe Speicherbereich zugewiesen würde. Somit ist es nicht möglich, dass die Blöcke B und C gleichzeitig in Benutzung sind. Eine Änderung an Block B würde zur Zerstörung des Inhalts von Block C führen.

#### Datenblöcke definieren

Datenblöcke werden im Data-Area-Editor definiert. Sie bauen die Block-Hierarchie auf, indem Sie angeben, welcher Block welchem anderen untergeordnet ist: geben Sie dazu den Namen des übergeordneten "Parent"-Blocks in das Kommentarfeld der Block-Definition ein.

In dem folgenden Beispiel sind `SUB-BLOCKB` und `SUB−BLOCKC` dem Block `MASTER−BLOCKA` untergeordnet; `SUB−BLOCKD` ist `SUB−BLOCKB` untergeordnet.

Die maximale Anzahl der Block-Stufen ist 8 (einschießlich des Master-Blocks).

#### Beispiel:

Global Data Area `G-BLOCK`:

      I T L Name                             F Leng Index/Init/EM/Name/Comment
      - - - -------------------------------- - ---- ---------------------------------
        B   MASTER-BLOCKA
          1 MB-DATA01                        A   10
        B   SUB-BLOCKB                              MASTER-BLOCKA
          1 SBB-DATA01                       A   20
        B   SUB-BLOCKC                              MASTER-BLOCKA
          1 SBC-DATA01                       A   40
        B   SUB-BLOCKD                              SUB-BLOCKB
          1 SBD-DATA01                       A   40

Um die spezifischen Blöcke einem Programm zur Verfügung zu stellen, benutzen Sie die folgende Syntax im `DEFINE DATA`-Statement:

Programm 1:

    DEFINE DATA GLOBAL
           USING G-BLOCK
           WITH MASTER-BLOCKA
    END-DEFINE

Programm 2:

    DEFINE DATA GLOBAL
           USING G-BLOCK
           WITH MASTER-BLOCKA.SUB-BLOCKB
    END-DEFINE

Programm 3:

    DEFINE DATA GLOBAL
           USING G-BLOCK
           WITH MASTER-BLOCKA.SUB-BLOCKC
    END-DEFINE

Programm 4:

    DEFINE DATA GLOBAL
           USING G-BLOCK
           WITH MASTER-BLOCKA.SUB-BLOCKB.SUB-BLOCKD
    END-DEFINE

Mit dieser Struktur kann Programm 1 die Daten in `MASTER−BLOCKA` gemeinsam mit Programm 2, Programm 3 oder Programm 4 benutzen. Allerdings können die Programme 2 und 3 nicht dieselben Data Areas von `SUB−BLOCKB` und `SUB−BLOCKC` gemeinsam benutzen, weil diese Datenblöcke auf derselben Struktur-Stufe definiert sind, und folglich denselben Speicherbereich belegen.

#### Block-Hierarchien

Besonders sorgfältig müssen Sie vorgehen, wenn Sie Datenblock-Hierarchien verwenden. Gehen wir von folgendem Szenario mit drei Programmen aus, bei denen eine Datenblock-Hierarchie verwendet wird:

Programm 1:

    DEFINE DATA GLOBAL
           USING G-BLOCK
           WITH MASTER-BLOCKA.SUB-BLOCKB
    END-DEFINE
    *
    MOVE 1234 TO SBB-DATA01
    FETCH 'PROGRAM2'
    END

Programm 2:

    DEFINE DATA GLOBAL
           USING G-BLOCK
           WITH MASTER-BLOCKA
    END-DEFINE
    *
    FETCH 'PROGRAM3'
    END

Programm 3:

    DEFINE DATA GLOBAL
           USING G-BLOCK
           WITH MASTER-BLOCKA.SUB-BLOCKB
    END-DEFINE
    *
    WRITE SBB-DATA01
    END

Erläuterung:

- Programm 1 benutzt die Global Data Area `G−BLOCK` mit `MASTER−BLOCKA` und `SUB−BLOCKB`. Das Programm ändert ein Feld in `SUB−BLOCKB` und ruft Programm 2 mit einem `FETCH`-Statement auf, bei dem nur `MASTER−BLOCKA` in der Datendefinition angegeben ist.

- Programm 2 setzt `SUB−BLOCKB` zurück (löscht den Inhalt von `SUB−BLOCKB`). Der Grund dafür ist, dass ein Programm auf Stufe 1 (zum Beispiel ein mit einem `FETCH`-Statement aufgerufenes Programm) alle Datenblöcke zurücksetzt, die den Blöcken untergeordnet sind, die in seiner eigenen Datendefinition definiert sind.

- Programm 2 ruft jetzt mit einem `FETCH`-Statement Programm 3 auf, welches das in Programm 1 geänderte Feld anzeigen soll, aber es gibt einen leeren Bildschirm zurück.

Einzelheiten zu den Programmstufen siehe Abschnitt Mehrere Stufen (Levels) aufgerufener Objekte.

## Parameter Data Area

Ein Subprogramm wird mit einem `CALLNAT`-Statement aufgerufen. Mit dem `CALLNAT`-Statement können Parameter von dem aufrufenden Objekt an das Subprogramm übergeben werden.

Diese Parameter müssen im Subprogramm mit einem `DEFINE DATA PARAMETER`-Statement definiert werden:

- entweder in der `PARAMETER`-Klausel des `DEFINE DATA`-Statements selbst

- oder in einer separaten Parameter Data Area (PDA), die von dem `DEFINE DATA PARAMETER`-Statement referenziert wird.

Folgende Themen werden behandelt:

- Innerhalb des DEFINE DATA PARAMETER-Statements definierte Parameter

- Separat in einer Parameter Data Area definierte Parameter

- Übereinstimmende Formatangaben bei Array-Dimensionen

### Innerhalb des DEFINE DATA PARAMETER-Statements definierte Parameter

### Separat in einer Parameter Data Area definierte Parameter

In der gleichen Weise wie beim `CALLNAT`-Statement müssen Parameter, die mit einem `PERFORM`-Statement an eine externe Subroutine übergeben werden, in der externen Subroutine in einem `DEFINE DATA PARAMETER`-Statement definiert werden.

Im aufrufenden Objekt müssen die an das Subprogramm bzw. die Subroutine übergebenen Parametervariablen nicht in einer Parameter Data Area definiert werden; in der obigen Abbildung sind sie in einer vom aufrufenden Objekt benutzten Local Data Area definiert (man hätte sie aber auch in einer Global Data Area definieren können).

Reihenfolge, Format und Länge der im `CALLNAT`- bzw. `PERFORM`-Statement des aufrufenden Objekts angegebenen Parameter müssen genau mit Reihenfolge, Format und Länge der Felder übereinstimmen, die im `DEFINE DATA PARAMETER`-Statement des aufgerufenen Subprogramms bzw. der aufgerufenen Subroutine definiert sind. Die Namen der Variablen im aufrufenden Objekt und dem aufgerufenen Subprogramm bzw. der aufgerufenen Subroutine brauchen nicht dieselben zu sein (da die Übergabe der Parameter nach Speicheradressen erfolgt und nicht nach Namen).

Um zu garantieren, dass die im aufrufenden Programm benutzten Datenelement-Definitionen mit den im Subprogramm oder der externen Subroutine benutzten Datenelement-Definitionen identisch sind, können Sie eine PDA in einem `DEFINE DATA LOCAL USING`-Statement angeben. Indem Sie eine PDA als LDA verwenden, können Sie sich den zusätzlichen Aufwand der Erstellung einer LDA ersparen, die dieselbe Struktur wie die PDA hat.

### Übereinstimmende Formatangaben bei Array-Dimensionen

Wenn Sie als Parameter ein Array übergeben, müssen Sie darauf achten, dass seine Dimensionen mit den Dimensionen übereinstimmen, die im `DEFINE DATA PARAMETER`-Statement des aufgerufenen Subprogramms bzw. der aufgerufenen Subroutine angegeben sind. Bei nicht übereinstimmenden Dimensionen entsteht selbst dann ein Fehler, wenn die Anzahl der Ausprägungen übereinstimmt.

#### Beispiel:

Aufgerufenes Subprogramm `SUB`:

    DEFINE DATA PARAMETER
    1 B (A5/1:5)
    END-DEFINE
    ...

Aufrufendes Programm mit Compiler-Fehler NAT0937:

    DEFINE DATA LOCAL
    1 A (A5/1:1,1:5)
    END-DEFINE
    CALLNAT 'SUB' A(1,*)
    ...

Aufrufendes Programm ohne Compiler-Fehler:

    DEFINE DATA LOCAL
    1 A (A5/1:5)
    END-DEFINE
    CALLNAT 'SUB' A(*)

### On this page

- Local Data Area (LDA)
- Global Data Area (GDA)
- Parameter Data Area