SELECT-Ausdrücke

#### Search Results

Search

# SELECT-Ausdrücke

`SELECT` selection table-expression

Ein `select-expression` gibt eine Ergebnistabelle an. Es wird bei den folgenden Statements benutzt: `INSERT` | `SELECT` | `UPDATE`

Dieses Dokument behandelt folgende Themen:

- selection

- table-expression

## selection

| `ALL` `DISTINCT` |  |  |  | scalar-expression [[`AS`] correlation-name] unpack-row |  | , |
| `*` |

`selection` gibt an, welche Spalten der Resultset-Tabellen (Ergebnismengen) ausgewählt werden sollen.

Syntax-Element-Beschreibung:

Syntax-Element | Beschreibung
--- | ---
`ALL | DISTINCT` | Eliminierung doppelt vorkommender Zeilen: Doppelt vorkommende Zeilen werden nicht automatisch aus dem Ergebnis eines `select-expression` entfernt. Wenn Sie dies wünschen, müssen Sie das Schlüsselwort `DISTINCT` angeben. Die Alternative zu `DISTINCT` ist `ALL`. Wenn Sie nichts angeben, gilt `ALL`.
`scalar-expression` | Skalar-Ausdruck: Anstelle einfacher Spaltennamen kann `selection` auch allgemeine `scalar-expressions` enthalten, die Skalar-Operatoren und Skalar-Funktionen enthalten, die berechnete Werte liefern. Siehe Skalar-Ausdrücke. Beispiel:
    SELECT NAME, 65 - AGE
      FROM SQL-PERSONNEL
      ...
`AS` | Das optionale Schlüsselwort `AS` leitet einen Korrelationsnamen (`correlation-name`) für eine Spalte ein.
`correlation-name` | Korrelationsname: Es besteht die Möglichkeit, einem `scalar-expression` einen `correlation-name` als Alias-Namen für eine Ergebnisspalte zuzuweisen. Der `correlation-name` braucht nicht eindeutig sein. Wenn für eine Ergebnisspalte kein `correlation-name` angegeben wird, wird der entsprechende `column-name` genommen (falls sich die Ergebnisspalte von einem Spaltennamen ableitet; andernfalls hat die Ergebnisspalte keinen Namen). Der Name einer Ergebnisspalte kann beispielsweise als Spaltenname in der `ORDER BY`-Klausel eines `SELECT`-Statements angegeben werden.
`unpack-row` | Siehe unpack-row weiter unten.
`*` | Stern-Notation (*) : Alle Spalten der Ergebnistabelle werden ausgewählt. Beispiel:
    SELECT *
      FROM SQL-PERSONNEL, SQL-AUTOMOBILES
      ...

#### unpack-row

`UNPACK` (scalar-expression) `.* AS` ({field-name data-type} , )

Mit `unpack-row` geben Sie eine Spalte nicht entpackter Binärwerte an, die zurückgegeben werden, wenn die `SQL UNPACK`-Funktion aufgerufen wird. Die Anzahl der Feldnamen (field-names) und Datentypen (data-types) muss mit der Anzahl der von der `SQL UNPACK`-Funktion zurückgegeben Felder übereinstimmen.

## table-expression

from-clause [where-clause]
[group-by-clause] [having-clause]
[order-by-clause] [fetch-first-clause]

Ein `table-expression` gibt an, von wo und nach welchen Kriterien Zeilen ausgewählt werden sollen.

Folgende Themen werden behandelt:

- FROM-Klausel

- Table Reference

- WHERE-Klausel

- GROUP BY-Klausel

- HAVING-Klausel

- ORDER BY-Klausel

- INPUT SEQUENCE

- ORDER OF table-designator

- FETCH FIRST-Klausel

- Beispiele für Tabellenausdrücke

### FROM-Klausel

`FROM` table-reference,…

Diese Klausel gibt an, von welchen Tabellen das Resultset (Ergebnismenge) erstellt werden soll.

### Table Reference

| table-name [period-specification] [correlation-clause] [`TABLE`] subquery correlation-clause joined-table `TABLE` (function-name (scalar-expression,...)) correlation-clause data-change-table-reference [correlation-clause] xmltable-function correlation-clause |

Die in der `FROM`-Klausel angegebenen Tabellen müssen die in der Auswahlliste verwendeten Spaltenfelder enthalten.

Sie können entweder eine einzelne Tabelle angeben oder eine Zwischentabelle erzeugen, die das Ergebnis einer `subquery` oder einer Join-Operation ist (siehe unten).

Da in einer `FROM`-Klausel mehrere Tabellen (d.h. DDMs) angesprochen werden können und eine `table-expression` mehrere `FROM`-Klauseln enthalten kann, wenn `subqueries` angegeben sind, bestimmt die Datenbanknummer (DBID) des ersten DDMs in der ersten FROM-Klausel die zugrunde liegende Datenbank.

#### TABLE function-name-Klausel

Die `TABLE function-name`-Klausel gehört zum SQL Extended Set und erfordert eine `correlation-clause` mit einer `column-name`-Liste.

#### period-specification

Die period-specification-Klausel gehört zum SQL Extended Set.

`FOR` |  | `SYSTEM_TIME` `BUSINESS_TIME` |  |  | `AS OF` expr `FROM` expr1 `TO` expr2 `BETWEEN` expr1 `AND` expr2 |  |

Mit der optionalen Angabe einer `period-specification` geben Sie an, dass für die Zeittabelle (`table-name`) eine Zeitraumangabe gilt. Derselbe Zeitraumname (`SYSTEM_TIME` oder `BUSINESS_TIME`) darf nicht mehr als einmal für dieselbe Tabelle angegeben werden.

Syntax-Element-Beschreibung:

Syntax-Element | Beschreibung
--- | ---
`FOR SYSTEM_TIME` | Gibt an, dass der `SYSTEM_TIME`-Zeitraum für die Zeitraumangabe benutzt wird. `SYSTEM_TIME` muss ein Zeitraum sein, der in der Tabelle definiert ist, und die die Tabelle muss eine vom System verwaltete Zeittabelle sein, die bei der Systemdatenversionierung definiert wird.
`FOR BUSINESS_TIME` | Gibt an, dass der `BUSINESS_TIME`-Zeitraum für die Zeitraumangabe benutzt wird. `BUSINESS_TIME` muss ein Zeitraum sein, der in der Tabelle definiert ist
`expr`, `expr1`, `expr2` | Geben Sie Audrücke an, die einen Wert eines eingebauten Datentyps zurückgeben, der mit dem Datentyp der Spalten des angegebenen Zeitraums vergleichbar sein und der keine `TIME ZONE` enthalten darf.
`AS OF expr` | Gibt an, dass die Tabelle jede Zeile enthält, für die der Startwert für den angegebenen Zeitraum kleiner als der oder gleich dem Ausdruck `expr` und der Endewert für den angebenen Zeitraum größer als der Ausdruck `expr` ist.
`FROM expr1 TO expr2` | Gibt an, dass die Tabelle Zeilen enthält, die für den mit `expr1` bis `expr2` angegebenen Zeitraum vorhanden sind. Eine Zeile wird in die Tabelle aufgenommen, wenn der Startwert für den Zeitraum in der Zeile kleiner als `expr2` und der Endewert für den Zeitraum in der Zeile größer als `expr1` ist.
`BETWEEN expr1 AND expr2` | Gibt an, dass die Tabelle eine Zeile enthält, in welcher sich der angegebene Zeitraum zu einem beliebigen Zeitpunkt zwischen `expr1` und `expr2` überlappt. Eine Zeile wird in die Tabelle aufgenommen, wenn der Startwert für den Zeitraum in der Zeile kleiner als oder gleich `expr2` und der Endewert für den Zeitraum in der Zeile größer als `expr1` ist.

Optional kann eine `correlation-clause` zu einem `table-name` zugeordnet werden. Bei einer `subquery` muss eine `correlation-clause` zugeordnet werden.

#### correlation-clause

[`AS`] correlation-name [(column-name,...)]

Eine `correlation-clause` besteht aus dem optionalen Schlüsselwort `AS` und einem `correlation-name`. Optional kann danach noch eine einfache Liste mit Spaltennamen angegeben werden. `column-name` gehört zum SQL Extended Set.

#### joined-table

| table-reference |  |  | `INNER` `LEFT [OUTER]` `RIGHT [OUTER]` `FULL [OUTER]` |  |  | `JOIN` table-reference `ON` join-condition |
(joined-table)

Eine `joined-table` gibt eine Zwischentabelle an, die das Ergebnis einer Verbundoperation (Join) ist.

Bei der Verbundoperation kann es sich um einen `INNER`, `LEFT OUTER`, `RIGHT OUTER` oder `FULL OUTER` `JOIN` handeln. Falls Sie nichts angeben, gilt `INNER`.

Es ist möglich, mehrere Joins zu schachteln, d.h. die Tabellen, die die Zwischentabelle bilden, können ihrerseits Zwischentabellen einer Verbundoperation oder einer `subquery` sein, wobei letztere wiederum ebenfalls eine `joined-table` oder eine weitere `subquery` in der `FROM`-Klausel haben kann.

#### join-condition

Bei `INNER`-, `LEFT OUTER`- und `RIGHT OUTER`-Verbundoperationen:

`search-condition`

Bei `FULL OUTER`-Verbundoperationen:

full-join-expression = full-join-expression [`AND` ]

#### full-join-expression

| column-name |
| `VALUE` `COALESCE` |  | (column-name `,` )

Innerhalb eines `join-expression` sind nur `column-names` und die `scalar-function` `VALUE` (oder ihr Synonym `COALESCE`) erlaubt.

Weitere Informationen siehe `column-name`.

#### data-change-table-reference

Die `data-change-table-reference`-Klausel gehört zum SQL Extended Set

| `FINAL TABLE` (INSERT-statement) |
| `FINAL` `OLD` |  | `TABLE` (searched-UPDATE-statement)
`OLD TABLE` (searched-DELETE-statement)
`FINAL TABLE` (MERGE-statement)

Eine `data-change-table-reference` gibt eine Zwischentabelle an, die auf den Zeilen basiert, die durch das in der `FROM`-Klausel angegebene SQL-Datenänderungs-Statement verändert werden. Eine `data-change-table-reference` kann nur als die einzige Tabellenreferenz in der `FROM`-Klausel angegeben werden.

Syntax-Element-Beschreibung:

Syntax-Element | Beschreibung
--- | ---
`FINAL TABLE` | Gibt an, dass die Zeilen der Zwischentabelle den Satz Zeilen, die vom SQL-Datenänderungs-Statement geändert werden, so darstellt wie sie beim Beenden des SQL-Datenänderungs-Statement erscheinen.
`OLD TABLE` | Gibt an, dass die Zeilen der Zwischentabelle den Satz Zeilent, die vom SQL-Datenänderungs-Statement geändert werden, so darstellt, wie sie vor der Anwendung des SQL-Datenänderungs-Statement vorhanden sind.

#### xmltable-function

Die `xmltable-function`-Klausel gehört zum SQL Extended Set

Eine `xmltable-function` gibt den Aufruf der eingebauten `XMLTABLE`-Funktion an.

### WHERE-Klausel

[`WHERE` search-condition]

In der `WHERE`-Klausel geben Sie ein Auswahlkriterium (`search-condition`) an, nach dem die Zeilen ausgewählt werden sollen.

Beispiel:

    DEFINE DATA LOCAL
    01 NAME   (A20)
    01 AGE    (I2)
    END-DEFINE
    ...
    SELECT *
      INTO NAME, AGE
      FROM SQL-PERSONNEL
      WHERE AGE = 32
    END-SELECT
    ...

Weitere Informationen siehe Suchbedingungen.

### GROUP BY-Klausel

| `GROUP BY` |  | grouping-expression grouping-set super-group |  | , |

Die `GROUP BY`-Klausel gibt eine Gruppierung der Ergebnistabelle an. Es ergibt sich eine Menge von Gruppen mit Zeilen. Innerhalb einer Gruppe mit mehr als einer Zeile sind alle Werte, die die Gruppe definieren, gleich.

- grouping-expression
- grouping-set
- super-group

#### grouping-expression

Ein `grouping-expression` ist ein `scalar-expression`, der die Gruppierung eines `result-set` definiert.

#### grouping-set

`GROUPING SETS` | ( |  |  |  | grouping-expression super-group |  |  |  |  | , | )
( |  | grouping-expression super-group |  | , | )

Ein `grouping-set` wird verwendet, um mehrere Gruppierungsklauseln in einem einzigen Statement anzugeben. Ein `grouping-set` kombiniert zwei oder mehr Zeilengruppen zu einem einzigen Resultset (Ergebnismenge). Es ist das gleiche wie eine `UNION`-Verkettung mehrerer `select-expressions` mit einer `GROUP BY`-Klausel, wobei jeder Ausdruck einem `grouping-set` entspricht. Ein `grouping-set` ist ein einzelnes Element oder eine Liste mit Elementen, die durch Klammern voneinander abgegrenzt sind. Ein Element ist entweder ein `grouping–expression` oder eine `super-group`. Ein `grouping-set` hat den Vorteil, dass die Gruppen in einem einzigen Durchgang über die Basistabelle berechnet werden.

#### super-group

| `ROLLUP` `CUBE` | (grouping-expression-list) (grouping-expression-list |
| `( )`

Eine `super-group` ist eine komplexerer `grouping-set`.

Eine `grouping-expression-list` definiert die Anzahl der Elemente, die in einer `ROLLUP`- oder `CUBE`-Operation verwendet werden. Elemente mit mehreren `grouping-expressions` werden durch Klammern voneinander abgegerenzt.

| grouping-expression |  | ,
(grouping-expression, )

Gesamtresultat "grand total" `( )`:

`ROLLUP` und `CUBE` liefern eine Zeile, die die Gesamtaggregation (Gesamtresultat) ist. Dies kann durch leere Klammern `( )` in der `GROUPING SETS`-Klausel angegeben werden.

> ROLLUP

>   Eine `ROLLUP`-Gruppierung ist wie eine Reihe von `grouping-sets`. Zusätzlich zu den regulären gruppierten Zeilen erzeugt eine `ROLLUP`-Gruppierung einen Resultset (Ergebnismenge), die Zwischensummenzeilen enthält. Zwischensummenzeilen sind "super-aggregierte" Zeilen, die zusätzliche Gesamtsummen enthalten. Die aggregierten Werte werden mit denselben Spaltenfunktionen abgerufen, die zum Abrufen der regulären gruppierten Zeilen verwendet werden.

>   Allgemein geben Sie eine `ROLLUP`-Gruppierung mit `n` Elementen wie folgt an:

>       GROUP BY ROLLUP (c1, c2, ..., cn-1, cn)

>   Was folgender Angabe entspricht:

>       GROUP BY GROUPING SETS ((c1, c2, ..., cn-1, cn),

>                              (c1, c2, ..., cn-1),

>                              ...

>                              (c1, c2),

>                              (c1),

>                              ( ))

> CUBE

>   Eine `CUBE`-Gruppierung ist wie eine Reihe von `grouping-sets`. Zusätzlich zu den `ROLLUP`-Aggregationszeilen erzeugt `CUBE` einen Resultset (Ergebnismenge), die Kreuztabellierungszeilen enthält. Kreuztabellierungszeilen sind zusätzliche "super-aggregierte" Zeilen. Die `grouping-expression-list` eines `CUBE` berechnet zusammen mit dem Gesamtresultat "grand total" alle Permutationen. Als Ergebnis werden die `n` Elemente eines `CUBE` in 2**n `grouping-sets` umgesetzt. Zum Beispiel:

>       GROUP BY CUBE (a, b, c)

>   Was folgender Angabe entspricht:

>       GROUP BY GROUPING SETS ((a, b, c),

>                              (a, b),

>                              (a, c),

>                              (b, c),

>                              (a),

>                              (b),

>                              (c),

>                              ())

### HAVING-Klausel

[`HAVING` search-condition]

Wenn Sie eine `HAVING`-Klausel verwenden, sollten Sie auch eine `GROUP BY`-Klausel verwenden.

So wie die `WHERE`-Klausel Zeilen aus einer Ergebnistabelle aussortiert, sortiert die `HAVING`-Klausel Gruppen aus, und zwar auf Grundlage einer Suchbedingung (`search-condition`). Skalar-Ausdrücke in einer `HAVING`-Klausel dürfen pro Gruppe nur einen Wert enthalten.

Weitere Informationen siehe Scalar Expressions and Search Conditions.

Beispiel:

    DEFINE DATA LOCAL
    1 #NAME     (A20)
    1 #AVGAGE   (I2)
    1 #NUMBER   (I2)
    END-DEFINE
    ...
    SELECT NAME, AVG(AGE), COUNT(*)
      INTO #NAME, #AVGAGE, #NUMBER
      FROM SQL-PERSONNEL
      GROUP BY NAME
      HAVING COUNT(*) > 1
      ...

### ORDER BY-Klausel

`ORDER BY` |  | sort-key |  | `ASC` `DESC` |  | , |
`INPUT SEQUENCE`
`ORDER OF` table-designator

Die `order-by`-Klausel gibt die Reihenfolge für die Ergebnistabellenzeilen an.

#### sort-key

| column-name |
integer
sort-key-expression

Ein `sort-key-expression` ist ein `expression`, der nicht einfach ein `column-name` oder eine vorzeichenlose ganzzahlige `constant` ist.

### INPUT SEQUENCE

`INPUT SEQUENCE` gehört zum SQL Extended Set.

`INPUT SEQUENCE` gibt an, dass die Ergebnistabelle die Eingabereihenfolge der Zeilen widerspiegelt, die in der `VALUE`-Klausel eines `INSERT`-Statements angegeben sind. `INPUT SEQUENCE` kann nur angegeben werden, wenn in der `from-clause` ein `INSERT`-Statement angegeben ist.

### ORDER OF table-designator

`ORDER OF table-designator` gehört zum SQL Extended Set.

`ORDER OF table-designator` gibt an, dass die Sortierfolge der bezeichneten Tabelle nach der Tabellenkennung (`table-designator`) auf die Ergebnistabelle der Abfrage angewendet werden soll. Der `table-designator` identifiziert eine Basistabelle, eine Datensicht (view) oder einen geschachtelten Tabellenausdruck (`table-expression`) einer Untervorauswahl (`subselect`) eindeutig.

### FETCH FIRST-Klausel

Die `fetch-first`-Klausel gehört zum SQL Extended Set.

| `FETCH FIRST` |  | `1` integer |  |  | `ROWS` `ROW` |  | `ONLY` |

Die `fetch-first`-Klausel begrenzt die Anzahl der Zeilen, die abgerufen werden können. Sie verbessert die Performance von Abfragen, wenn nur eine begrenzte Anzahl an Zeilen benöigt wird.

### Beispiele für Tabellenausdrücke

Beispiel 1:

    DEFINE DATA LOCAL
    01 #NAME      (A20)
    01 #FIRSTNAME (A15)
    01 #AGE       (I2)
    ...
    END-DEFINE
    ...
    SELECT NAME, FIRSTNAME, AGE
      INTO #NAME, #FIRSTNAME, #AGE
      FROM SQL-PERSONNEL
        WHERE NAME IS NOT NULL
          AND AGE > 20
    ...
      DISPLAY #NAME #FIRSTNAME #AGE
    END-SELECT
    ...
    END

Beispiel 2:

    DEFINE DATA LOCAL
    01 #COUNT    (I4)
    ...
    END-DEFINE
    ...
    SELECT SINGLE COUNT(*) INTO #COUNT FROM SQL-PERSONNEL
    ...

### On this page

- selection
- table-expression