SORT

#### Search Results

Search

# SORT

#### Structured Mode-Syntax

`END-ALL` |  |  |  |  |  |  |  |  |  |
[`AND`] |  |  |  |  |  |  |  |  |  |
`SORT` |  | `THEM` |  | [`BY`] |  | operand1 |  | `ASCENDING` |  | 10
`RECORDS` | `DESCENDING`
|  | USING-clause |  |  |  |  |  |  |  |
|  | [GIVE-clause] |  |  |  |  |  |  |  |
|  | statement |  |  |  |  |  |  |  |
`END-SORT` |  |  |  |  |  |  |  |  |  |

* Wenn ein Statement-Label angegeben wird, muss es vor dem Schlüsselwort `SORT`, aber nach `END−ALL` (und `AND`) stehen.

#### Reporting Mode-Syntax

`SORT` |  | `THEM` |  | [`BY`] |  | operand1 |  | `ASCENDING` |  | 10
`RECORDS` | `DESCENDING`
|  | [USING-clause] |  |  |  |  |  |  |  |
|  | [GIVE-clause] |  |  |  |  |  |  |  |
|  | statement |  |  |  |  |  |  |  |
`LOOP` |  |  |  |  |  |  |  |  |

Dieses Dokument behandelt folgende Themen:

- Funktion

- Einschränkungen

- Syntax-Beschreibung

- Phasen der SORT-Verarbeitung

- Beispiel

- Benutzung externer Sortierprogramme

Eine Erläuterung der in dem Syntax-Diagramm verwendeten Symbole entnehmen Sie dem Abschnitt Syntax-Symbole.

Verwandtes Statement: `FIND` mit `SORTED BY`-Option

Gehört zur Funktionsgruppe: Schleifenverarbeitung

## Funktion

Das Statement `SORT` dient dazu, eine Sortieroperation durchzuführen und die Datensätze aus allen Verarbeitungsschleifen, die zum Zeitpunkt der `SORT`-Ausführung aktiv sind, zu sortieren.

Für die Sortieroperation wird Naturals internes Sortierprogramm verwendet. Es kann stattdessen auch ein anderes, externes Sortierprogramm verwendet werden.

## Einschränkungen

- Das `SORT`-Statement muss im selben Objekt stehen wie die Verarbeitungsschleifen, deren Datensätze es sortiert.

- Geschachtelte `SORT`-Statements sind nicht erlaubt.

- Die Gesamtlänge eines zu sortierenden Datensatzes darf 10240 Bytes nicht überschreiten.

- Die Anzahl der Sortierkriterien darf 10 nicht überschreiten.

## Syntax-Beschreibung

Operanden-Definitionstabelle:

Operand | Mögliche Struktur | Mögliche Formate | Referenzierung erlaubt | Dynam. Definition
--- | --- | --- | --- | ---
operand1 |  | S |  |  |  | A | N | P | I | F | B | D | T |  |  |  |  | nein | nein

Syntax-Element-Beschreibung:

Syntax-Element | Beschreibung
--- | ---
`END-ALL` | Schließen aller zurzeit aktiven Schleifen: Im Structured Mode müssen Sie vor dem `SORT`-Statement das Statement `END−ALL` angeben; damit werden alle noch aktiven Verarbeitungsschleifen beendet. Das `SORT`-Statement initiiert seinerseits eine neue Verarbeitungsschleife, welche mit `END−SORT` geschlossen werden muss. Anmerkung Im Reporting Mode beendet das `SORT`-Statement alle noch aktiven Verarbeitungsschleifen und initiiert eine neue Verarbeitungsschleife.
`operand1` | Sortierkriterien: operand1 sind die Felder/Variablen, die als Sortierkriterium dienen. 1 bis 10 Felder dürfen angegeben werden. Hierbei kann es sich um Datenbankfelder (Deskriptoren oder Nicht-Deskriptoren) und/oder Benutzervariablen handeln. Multiple Felder oder Felder aus einer Periodengruppe können ebenfalls verwendet werden; eine Feldgruppe oder ein Array kann nicht verwendet werden. Anmerkung Ein in den Sortierkriterien angegebenes Feld wird benutzt, um in der Auswahlphase (erste Phase) einen Wert in den Sortier-Datensatz zu stellen und um in der Verarbeitungsphase (dritte Phase) den sortierten Wert zu empfangen. Bitte beachten Sie, dass dies Adressierungsfehler verursachen kann, wenn indizierte Array-Felder benutzt werden, die einen korrekten Indexwert in der ersten Phase, aber einen ausserhalb des Bereichs liegenden Wert in der dritten Phase haben. Deshalb sind indizierte Array-Felder mit Vorsicht zu verwenden. Besser ist es, diese durch nicht-indizierte Felder (Skalar) zu ersetzen.
`ASCENDING` | Sortierreihenfolge: Wird nichts anderes angegeben, so gilt `ASCENDING`, d.h. die Werte werden in aufsteigender Reihenfolge sortiert. Möchten Sie die Werte in absteigender Reihenfolge sortiert haben, geben Sie das Schlüsselwort `DESCENDING` an. Das Schlüsselwort `ASCENDING` bzw. `DESCENDING` kann für jedes Sortierfeld getrennt angegeben werden.
`DESCENDING`
`USING` | USING-Klausel: Siehe USING-Klausel weiter unten. Anmerkung Die unter `operand1` vorhandene Anmerkung gilt auch bei der `USING`-Klausel.
`GIVE` | GIVE-Klausel: Siehe GIVE-Klausel weiter unten.
`END-SORT` | Ende des SORT-Statements: Im Structured Mode muss das für Natural reservierte Wort `END−SORT` zum Beenden des `SORT`-Startements benutzt werden. Im Reporting Mode wird das Natural-Statement `LOOP` zum Beenden des `SORT`-Statements benutzt.
`LOOP`

### USING-Klausel

In der `USING`-Klausel geben Sie die Felder an, die in den Sortier-Zwischenspeicher geschrieben werden sollen. Die `USING`-Klausel ist im Structured Mode unbedingt erforderlich, im Reporting Mode nicht; allerdings wird dringend empfohlen, sie auch im Reporting Mode zu verwenden, um Speicherplatz zu sparen.

| `USING` {operand2}... |
`USING KEYS`

Operanden-Definitionstabelle:

Operand | Mögliche Struktur | Mögliche Formate | Referenzierung erlaubt | Dynam. Definition
--- | --- | --- | --- | ---
operand2 |  | S | A |  |  | A | N | P | I | F | B | D | T | L | C |  |  | nein | nein

Syntax-Element-Beschreibung:

Syntax-Element | Beschreibung
--- | ---
`USING operand2` | Mit `USING operand2` können Sie weitere Felder angeben, die — zusätzlich zu den (als operand1 angegebenen) Sortierfeldern — in den Sortier-Zwischenspeicher geschrieben werden sollen.
`USING KEYS` | Wenn Sie `USING KEYS` angeben, werden nur die als operand1 angegebenen Sortierfelder in den Sortier-Zwischenspeicher geschrieben.

#### Im Reporting Mode:

Verwenden Sie keine `USING`-Klausel, so werden alle Datenbankfelder aus vor dem `SORT`-Statement initiierten Verarbeitungsschleifen sowie alle vor dem `SORT`-Statement definierten Benutzervariablen in den Sortier-Zwischenspeicher geschrieben.

Wird nach Ausführung des `SORT`-Statements ein Feld referenziert, das nicht in den Sortier-Zwischenspeicher geschrieben wurde, so ist der Wert des Feldes der, den es vor der SORT-Operation hatte.

### GIVE-Klausel

Die `GIVE`-Klausel dient dazu, Natural-Systemfunktionen (`MAX`, `MIN` usw.) anzugeben, die in der ersten Phase des Sortiervorgangs ausgewertet werden und dann in der dritten Phase referenziert werden können (siehe Abschnitt Phasen der SORT-Verarbeitung). Wird nach dem `SORT`-Statement eine Systemfunktion referenziert, muss ihrem Namen ein Stern vorangestellt werden; Beispiel: `*AVER(SALARY)`.

Anmerkung
Anstelle des Schlüsselworts `GIVE` können Sie auch das Schlüsselwort `GIVING` verwenden.

|  |  | `MAX` |  |  |  |  |  |  |
| `MIN` |  |  |  |  |
| `NMIN` |  |  |  |  |
| `COUNT` |  |  |  |  |
`GIVE` | `NCOUNT` | [`OF`] |  | (operand3 ) |  | [(`NL=`nn)]
`OLD` | operand3
| `AVER` |  |  |  |  |
| `NAVER` |  |  |  |  |
| `SUM` |  |  |  |  |
| `TOTAL` |  |  |  |  |

Operanden-Definitionstabelle:

Operand | Mögliche Struktur | Mögliche Formate | Referenzierung erlaubt | Dynam. Definition
--- | --- | --- | --- | ---
operand3 |  | S | A |  |  | * |  |  |  |  |  |  |  |  |  |  |  | ja | nein

* je nach Funktion

Syntax-Element-Beschreibung:

Syntax-Element | Beschreibung
--- | ---
`MAX` | `MIN` | `NMIN` | `COUNT` | `NCOUNT` | `OLD` | `AVER` | `NAVER` | `SUM` | `TOTAL` | Näheres zu den einzelnen Systemfunktionen finden Sie in der Systemfunktionen-Dokumentation.
`operand3` | operand3 ist der Feldname.
`(NL=nn.m)` | Diese Option gilt nur für `AVER`, `NAVER`, `SUM` und `TOTAL`; für alle anderen Systemfunktionen wird sie ignoriert. Siehe auch Session-Parameter `NL` in der Parameter Reference-Dokumentation. Diese Option kann dazu verwendet werden, einen arithmetischen Überlauf bei der Auswertung von Systemfunktionen zu vermeiden; sie ist unter Arithmetischer Überlauf bei AVER, NAVER, SUM oder TOTAL in der Systemfunktionen-Dokumentation beschrieben.

## Phasen der SORT-Verarbeitung

Ein Programm, das ein `SORT`-Statement enthält, wird in drei Phasen ausgeführt:

#### 1. Phase — Auswählen der zu sortierenden Datensätze

Die Statements vor dem `SORT`-Statement werden ausgeführt. Die in der `USING`-Klausel angegebenen Daten werden in den Sortier-Zwischenspeicher geschrieben.

Im Reporting Mode dürfen Variablen, die nach dem Sortieren als Akkumulatoren verwendet werden, nicht vor dem SORT-Statement definiert werden.

Im Structured Mode dürfen sie nicht in der `USING`-Klausel angegeben werden.

In den Sortier-Zwischenspeicher geschriebene Felder können als Akkumulatoren nicht verwendet werden, weil sie in der dritten Phase mit jedem einzelnen Datensatz zurückgeschrieben werden. Folglich hätte die Akkumulationsfunktion nicht das gewünschte Ergebnis, da das Feld bei jedem Datensatz mit dem Wert des jeweiligen Datensatzes überschrieben würde.

Die Anzahl der in den Sortier-Zwischenspeicher geschriebenen Datensätze ergibt sich aus der Anzahl der Verarbeitungsschleifen und der Anzahl der verarbeiteten Datensätze pro Schleife. Jedesmal wenn das `SORT`-Statement in einer Verarbeitungsschleife ausgeführt wird, wird im internen Sortier-Zwischenspeicher ein Datensatz angelegt.

Bei geschachtelten Schleifen wird ein Datensatz nur in den Sortier-Zwischenspeicher geschrieben, wenn die innere Schleife ausgeführt wird. Sollen im folgenden Beispiel Datensätze in den Sortier-Zwischenspeicher geschrieben werden, auch wenn in der inneren (`FIND`-)Schleife keine gefunden werden, so muss das `FIND`-Statement eine `IF NO RECORDS FOUND`-Klausel enthalten.

    READ ...
      ...
      FIND ...
    ...
    END-ALL
    SORT ...
      DISPLAY ...
    END-SORT
    ...

#### 2. Phase — Sortieren der Datensätze

Die Datensätze werden sortiert.

#### 3. Phase — Weiterverarbeitung der sortierten Datensätze

Die Datensätze aus dem Sortier-Zwischenspeicher werden in der angegebenen Sortierfolge mit den auf das `SORT`-Statement folgenden Statements weiterverarbeitet. Werden Datenbankfelder nach dem `SORT`-Statement referenziert, so muss dies über ein Statement-Label oder durch Angabe der entsprechenden Quellcode-Zeilennummer erfolgen.

## Beispiel

- Beispiel 1 — SORT

- Beispiel 2 — SORT

- Beispiel 3 — SORT

### Beispiel 1 — SORT

    ** Example 'SRTEX1S': SORT (structured mode)
    ************************************************************************
    DEFINE DATA LOCAL
    1 EMPL-VIEW VIEW OF EMPLOYEES
      2 CITY
      2 SALARY      (1:2)
      2 PERSONNEL-ID
      2 CURR-CODE   (1:2)
    *
    1 #AVG          (P11)
    1 #TOTAL-TOTAL  (P11)
    1 #TOTAL-SALARY (P11)
    1 #AVER-PERCENT (N3.2)
    END-DEFINE
    *
    LIMIT 3
    FIND EMPL-VIEW WITH CITY = 'BOSTON'
      COMPUTE #TOTAL-SALARY = SALARY (1) + SALARY (2)
      ACCEPT IF #TOTAL-SALARY GT 0
      /*
    END-ALL
    AND
    SORT BY PERSONNEL-ID USING #TOTAL-SALARY SALARY(*) CURR-CODE(1)
         GIVE AVER(#TOTAL-SALARY)
      /*
      AT START OF DATA
        WRITE NOTITLE '*' (40)
             'AVG CUMULATIVE SALARY:' *AVER (#TOTAL-SALARY) /
        MOVE *AVER (#TOTAL-SALARY) TO #AVG
      END-START
      COMPUTE ROUNDED #AVER-PERCENT = #TOTAL-SALARY / #AVG * 100
      ADD #TOTAL-SALARY TO #TOTAL-TOTAL
      /*
      DISPLAY NOTITLE PERSONNEL-ID SALARY (1) SALARY (2)
              #TOTAL-SALARY CURR-CODE (1)
              'PERCENT/OF/AVER' #AVER-PERCENT
      AT END OF DATA
        WRITE / '*' (40) 'TOTAL SALARIES PAID: ' #TOTAL-TOTAL
      END-ENDDATA
    END-SORT
    *
    END

Ausgabe des Programms `SRTEX1S`:

    PERSONNEL   ANNUAL     ANNUAL   #TOTAL-SALARY CURRENCY PERCENT
         ID       SALARY     SALARY                   CODE     OF
                                                              AVER
      --------- ---------- ---------- ------------- -------- -------

      **************************************** AVG CUMULATIVE SALARY:        41900

      20007000       16000      15200        31200  USD        74.00
      20019200       18000      17100        35100  USD        83.00
      20020000       30500      28900        59400  USD       141.00

      **************************************** TOTAL SALARIES PAID:        125700

Das obige Beispiel wird wie folgt verarbeitet:

#### Phase 1:

- Von der `EMPLOYEES`-Datei werden Datensätze mit `CITY = BOSTON` gelesen.

- Die ersten beiden Ausprägungen des `SALARY`-Feldes werden in der Variablen `#TOTAL−SALARY` addiert.

- Es werden nur Datensätze weiterverarbeitet, bei denen der Wert von `#TOTAL−SALARY` größer als 0 ist.

- Die Sätze werden in den Sortier-Zwischenspeicher geschrieben. Die Datenbank-Arrays `SALARY` (die ersten beiden Ausprägungen) und `CURR−CODE` (erste Ausprägung), das Datenbankfeld `PERSONNEL−ID` und die Benutzervariable `#TOTAL−SALARY` werden in den Zwischenspeicher geschrieben.

- Der Durchschnittswert von `#TOTAL−SALARY` wird errechnet.

#### Phase 2:

- Die Datensätze werden sortiert.

#### Phase 3:

- Der sortierte Zwischenspeicherinhalt wird gelesen.

- Bei der Ausführung des `AT START OF DATA`-Blocks wird der Durchschnittswert von #TOTAL−SALARY angezeigt.

- Der Wert von `#TOTAL−SALARY` wird zu `#TOTAL−TOTAL` hinzuaddiert; es werden die Felder `PERSONNEL−ID`, `SALARY (1)`, `SALARY (2)`, `#AVER−PERCENT` und `#TOTAL−SALARY` angezeigt.

- Bei der Ausführung des `AT END OF DATA`-Blocks wird die Variable `#TOTAL−TOTAL` ausgegeben.

Äquivalentes Reporting-Mode-Beispiel: `SRTEX1R`.

### Beispiel 2 — SORT

    ** Example 'SRTEX2': SORT
    ************************************************************************
    DEFINE DATA LOCAL
    1 VEHIC-VIEW VIEW OF VEHICLES
      2 MAKE
      2 YEAR
    END-DEFINE
    *
    LIMIT 10
    *
    READ VEHIC-VIEW
    END-ALL
    SORT BY MAKE YEAR USING KEY
      DISPLAY NOTITLE (AL=15) MAKE (IS=ON) YEAR
      AT BREAK OF MAKE
        WRITE '-' (20)
      END-BREAK
    END-SORT
    END

Ausgabe des Programms `SRTEX2S`:

         MAKE       YEAR
    --------------- -----

    FIAT             1980
                     1982
                     1984
    --------------------
    PEUGEOT          1980
                     1982
                     1985
    --------------------
    RENAULT          1980
                     1980
                     1982
                     1982
    --------------------

### Beispiel 3 — SORT

    ** Example 'SRTEX3': SORT values in an array
    ***********************************************************************
    DEFINE DATA LOCAL
    1 #I   (I4)
    1 #J   (I4)
    1 #X   (I1)
    1 #TAB (I1/1:6) INIT <2,4,6,5,3,1>
    END-DEFINE
    WRITE   'Array before SORT:' #TAB(*) /
    *
    FOR #I := 1 TO 6
      #X := #TAB(#I)
      WRITE #X '<-- Put into SORT record'
    END-ALL
    SORT #X USING KEYS
      WRITE #X '<-- Get from SORT'
      ADD 1 TO #J
      #TAB(#J) := #X
    END-SORT
    *
    WRITE / 'Array after  SORT:' #TAB(*)
    END

Ausgabe des Programms `SRTEX3`:

    Array before SORT:    2    4    6    5    3    1

       2 <-- Put into SORT record
       4 <-- Put into SORT record
       6 <-- Put into SORT record
       5 <-- Put into SORT record
       3 <-- Put into SORT record
       1 <-- Put into SORT record
       1 <-- Get from SORT
       2 <-- Get from SORT
       3 <-- Get from SORT
       4 <-- Get from SORT
       5 <-- Get from SORT
       6 <-- Get from SORT

    Array after  SORT:    1    2    3    4    5    6

## Benutzung externer Sortierprogramme

In Natural werden Sortiervorgänge standardmäßig von Naturals internem Sortierprogramm verarbeitet, wie oben beschrieben. Allerdings kann auch ein externes Sortierprogramm benutzt werden. Dieses externe Sortierprogramm verarbeitet dann die Sortiervorgänge anstatt das internen Sortierprogramms von Natural.

Das zu benutzende externe Sortierprogramm wird vom Natural-Administrator im Makro `NTSORT` des Natural-Parametermoduls festgelegt. Zur Benutzung eines externen Sortierprogrammes ist zusätzliche JCL erforderlich. Wenn Sie Fragen haben, wenden Sie sich an Ihren Natural-Administrator.

### On this page

- Funktion
- Einschränkungen
- Syntax-Beschreibung
- Phasen der SORT-Verarbeitung
- Beispiel
- Benutzung externer Sortierprogramme