Erste Schritte

Grundlegende Methoden und Konzepte anwenden

Mit lokalen Klassen arbeiten

Daten aus der Datenbank lesen

Mit strukturierten Datenobjekten arbeiten

Mit komplexen internen Tabellen arbeiten

Datenbankänderungen mit Business Objects implementieren

Das ABAP-RESTful-Anwendungsprogrammiermodell beschreiben

Eine komplexe interne Tabelle deklarieren

Objective

After completing this lesson, you will be able to deklarieren Sie eine komplexe interne Tabelle.

Eigenschaften komplexer interner Tabellen

Die bisher verwendeten internen Tabellen hatten einen skalaren Datentyp als Zeilentyp. In dem hier in den Abbildungen gezeigten Beispiel ist der Zeilentyp der internen Tabelle numbers der eingebaute ABAP-Typ I.

Solche internen Tabellen werden als „einfache interne Tabellen" bezeichnet.

Wir sprechen von einer komplexen internen Tabelle, wenn der Zeilentyp ein strukturierter Datentyp ist.

Während eine einfache interne Tabelle nur eine namenlose Spalte hat, besteht eine komplexe interne Tabelle aus mehreren Spalten. Jede davon weist dabei jeweils den Namen und den Typ der entsprechenden Komponente des strukturierten Zeilentyps auf. Im Beispiel ist der Zeilentyp der internen Tabelle connections ein strukturierter Typ mit fünf Komponenten: carrier_id, connection_id, airport_from_id, airport_to_id und carrier_name. Folglich hat die interne Tabelle connections fünf Spalten mit diesen Namen.

Notiz

Die Spalten in den Beispielen in der Abbildung „Erinnerung: Einfache interne Tabellen" und „Interne Tabellen mit strukturiertem Zeilentyp" haben alle skalare Typen. Generell könnte eine Spalte einer internen Tabelle auch vom strukturierten Typ sein oder sogar einen Tabellentyp haben. Im letzteren Fall spricht man von einer geschachtelten internen Tabelle.

Bisher wurden die Zeilen einer internen Tabelle durch ihre Position adressiert. Dies wird als „Indexzugriff" bezeichnet.

Mit den benannten Spalten einer komplexen internen Tabelle wird der Schlüsselzugriff wichtiger. Bei einem Schlüsselzugriff wird eine Zeile der internen Tabelle über die Suche nach bestimmten Werten in bestimmten Spalten adressiert. Die Spalten, in denen Sie suchen, können beliebige Spalten der internen Tabelle sein.

Der Indexzugriff auf eine interne Tabelle erfolgt immer sehr schnell, auch wenn die interne Tabelle viele Zeilen enthält. Der Schlüsselzugriff kann jedoch sehr langsam werden, wenn die Tabelle viele Zeilen enthält. Die Auswahl der richtigen Zugriffsart für die interne Tabelle kann die Performance eines Schlüsselzugriffs verbessern.

Jede interne Tabelle besitzt eine der folgenden drei Zugriffsarten. Die Zugriffsart legt fest, auf welche Weise Daten in der Tabelle gespeichert werden und, je nachdem, wie das System die Tabelle beim Lesen der Daten durchsucht.

Es gibt folgende Tabellentypen:

Standardtabelle: Bei einer Standardtabelle erfolgt das Speichern der Inhalte in keiner bestimmten Reihenfolge. Neue Einträge werden standardmäßig am Tabellenende hinzugefügt. Um Daten nach Schlüsseln abzurufen, muss das System die Tabelle sequentiell durchsuchen. Bei großen Tabellen kann dies zu langen Antwortzeiten führen. Die bisher verwendeten einfachen internen Tabellen waren Standardtabellen.
Sortierte Tabellen: In einer sortierten Tabelle werden die Inhalte entsprechend den Schlüsselfeldern stets in aufsteigender Reihenfolge sortiert. Wenn Sie einen neuen Datensatz in die Tabelle einfügen, stellt das System sicher, dass dies an der richtigen Position erfolgt. Da die Daten immer sortiert sind, erfolgt das Abrufen von Datensätzen durch das System effizienter als bei Standardtabellen (sofern Sie bestimmte Regeln einhalten).
Hash-Tabelle: Hash-Tabellen werden durch einen speziellen Hash-Algorithmus verwaltet. Auf diese Weise ist sichergestellt, dass das System Datensätze selbst bei extrem großen Tabellen sehr schnell abrufen kann. Diese Performancesteigerung funktioniert jedoch nur in ganz bestimmten Fällen.

Jede interne Tabelle besitzt einen Schlüssel. Bei Standardtabellen spielt der Schlüssel keine besonders große Rolle. Bei sortierten Tabellen und Hash-Tabellen ist der Schlüssel dagegen sehr wichtig, da er bestimmt, auf welche Weise die Daten in der Tabelle verwaltet werden. Grundsätzlich sind sortierte Tabellen und Hash-Tabellen nur für Schlüsselzugriffe schneller, die alle oder zumindest eine Teilmenge der Schlüsselfelder adressieren.

Ein weiteres Attribut des Tabellenschlüssels ist seine Eindeutigkeit. Manchmal kann es erforderlich sein, doppelte Einträge in einer internen Tabelle zuzulassen. In anderen Fällen müssen Sie sicherstellen, dass der Schlüssel eindeutig ist. Hier gelten folgende Regeln:

In Standardtabellen sind Dubletten immer zulässig.
In Hash-Tabellen sind Dubletten niemals zulässig.
Bei sortierten Tabellen legen Sie in der Definition fest, ob der Schlüssel eindeutig sein soll oder nicht.

Notiz

Interne Tabellen können auch Sekundärschlüssel haben. Mit Sekundärschlüsseln kann die Performance von Schlüsselzugriffen auf interne Tabellen, die unterschiedliche Feldkombinationen verwenden, verbessert werden. Weitere Informationen finden Sie in der Dokumentation zur ABAP-Syntax.

Komplexe Tabellentypen

In diesem Video sehen Sie einige Beispiele für die Deklaration komplexer interner Tabellen.

Des Weiteren empfiehlt es sich für einen guten Programmierstil, erst den Datentyp festzulegen und dann eine Variable anzulegen, die auf den Typ verweist.

Anstelle der Angabe von Zugriffsart und Schlüssel einer internen Tabelle in der DATA-Anweisung sollte ein benannter Tabellentyp verwendet werden. Wenn Sie den Tabellentyp nur lokal in einer Methode oder in Verbindung mit einer bestimmten Klasse benötigen, können Sie ihn mit der TYPES-Anweisung definieren.

Im Beispiel wird zuerst ein Strukturtyp st_connection definiert. Mit diesem Strukturtyp als Zeilentyp wird dann der Tabellentyp tt_connections definiert. Abschließend bezieht sich die Deklaration der internen Tabelle connections_5 auf den Tabellentyp.

Wenn Sie den Tabellentyp global benötigen, können Sie einen globalen Tabellentyp verwenden.

Ein globaler Tabellentyp ist ein Repository-Objekt, das an beliebiger Stelle im System als Datentyp verwendet werden kann. ADT stellt einen gesonderten Editor für diese Art von Repository-Objekt bereit. Das Werkzeug besteht aus den folgenden Bereichen:

Im folgenden Video ist zu sehen, wie Tabellentypen lokal definiert werden.

Probieren Sie es aus: Komplexe Tabellentypen

Legen Sie wie in der ersten Übung dieser Schulung eine neue globale Klasse an, die das Interface IF_OO_ADT_CLASSRUN implementiert.

Kopieren Sie das folgende Code-Snippet in den Implementierungsteil der Methode if_oo_adt_classrun~main( ):

Code Snippet

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364

    TYPES: BEGIN OF st_connection,
             carrier_id      TYPE /dmo/carrier_id,
             connection_id   TYPE /dmo/connection_id,
             airport_from_id TYPE /dmo/airport_from_id,
             airport_to_id   TYPE /dmo/airport_to_id,
             carrier_name    TYPE /dmo/carrier_name,
           END OF st_connection.


* Example 1 : Simple and Complex Internal Table
**********************************************************************

    " simple table (scalar row type)
    DATA numbers TYPE TABLE OF i.
    " complex table (structured row type)
    DATA connections TYPE TABLE OF st_connection.

    out->write(  `--------------------------------------------` ).
    out->write(  `Example 1: Simple and Complex Internal Table` ).
    out->write( data = numbers
                name = `Simple Table NUMBERS:`).
    out->write( data = connections
                name = `Complex Table CONNECTIONS:`).

* Example 2 : Complex Internal Tables
**********************************************************************

    " standard table with non-unique standard key (short form)
    DATA connections_1 TYPE TABLE OF st_connection.

    " standard table with non-unique standard key (explicit form)
    DATA connections_2 TYPE STANDARD TABLE OF st_connection
                            WITH NON-UNIQUE DEFAULT KEY.

    " sorted table with non-unique explicit key
    DATA connections_3  TYPE SORTED TABLE OF st_connection
                             WITH NON-UNIQUE KEY airport_from_id
                                                 airport_to_id.

    " sorted hashed with unique explicit key
    DATA connections_4  TYPE HASHED TABLE OF st_connection
                             WITH UNIQUE KEY carrier_id
                                             connection_id.

* Example 3 : Local Table Type
**********************************************************************

    TYPES tt_connections TYPE SORTED TABLE OF st_connection
                              WITH UNIQUE KEY carrier_id
                                              connection_id.

    DATA connections_5 TYPE tt_connections.

* Example 4 : Global Table Type
**********************************************************************

    DATA flights  TYPE /dmo/t_flight.

    out->write(  `------------------------------------------` ).
    out->write(  `Example 4: Global Table TYpe /DMO/T_FLIGHT` ).
    out->write(  data = flights
                 name = `Internal Table FLIGHTS:` ).

Drücken Sie STRG + F3 auf Ihrer Tastatur, um die Klasse zu aktivieren, und F9, um die Konsolen-App auszuführen.
Analysieren Sie die Konsolenausgabe. Debuggen Sie das Programm, und probieren Sie mit dem Quelltext Verschiedenes aus, um sich mit den Konzepten vertraut zu machen.

Next lesson