1 3 de Dictionary PDF

Einführung in ABAP
- ABAP Dictionary und Datenbanken -
Prof. Dr. Heimo H. Adelsberger

Dipl.-Wirt.-Inf. Pouyan Khatami
Einführung in ABAP
Inhaltsverzeichnis
Inhaltsverzeichnis ....................................................................................................................... 2
Abbildungsverzeichnis ............................................................................................................... 4
Copyright .................................................................................................................................... 7
8 ABAP Dictionary und Datenbanken .................................................................................. 8
8.1 Exkurs: Der Data Browser ........................................................................................... 9
8.1.1 Aufgaben des Data Browsers ............................................................................... 9
8.1.2 Praxis: Übung zur Nutzung des Data Browsers ................................................. 10
8.2 Typen des ABAP Dictionary ..................................................................................... 12
8.2.1 Von lokalen zu globalen Typen.......................................................................... 13
8.2.2 Domänen............................................................................................................. 15
8.2.3 Datenelemente .................................................................................................... 17
8.2.4 Strukturen ........................................................................................................... 19
8.2.5 Tabellentypen ..................................................................................................... 20
8.2.6 Typgruppen und Konstanten .............................................................................. 23
8.2.7 Praxis: Übung zu globalen Typen ...................................................................... 23
8.2.7.1 Domänen anlegen ........................................................................................ 24
8.2.7.2 Datenelemente Anlegen .............................................................................. 25
8.2.7.3 Struktur anlegen .......................................................................................... 28
8.2.7.4 Tabellentyp anlegen .................................................................................... 28
8.2.7.5 Verwendung der globalen Typen ................................................................ 30
8.3 Tabellen ..................................................................................................................... 33
8.3.1 Tabellen als Typen ............................................................................................. 34
8.3.2 Include-Strukturen .............................................................................................. 34
8.3.3 Praxis: Übung Tabellenstruktur.......................................................................... 35
8.3.4 Technische Einstellungen ................................................................................... 37
8.3.4.1 Logische Speicher-Parameter...................................................................... 38
8.3.4.2 Tabellenpufferung ....................................................................................... 39
8.3.4.3 Protokollierung ............................................................................................ 40
8.3.5 Praxis: Übung Technische Einstellungen ........................................................... 40
8.4 Tabellenzugriff aus ABAP-Programmen .................................................................. 42
8.4.1 Native SQL ......................................................................................................... 42
8.4.2 Open SQL ........................................................................................................... 43
8.4.3 Auslesen von Daten ............................................................................................ 43
8.4.3.1 Der Arbeitsbereich für Datenbanktabellen.................................................. 44
8.4.3.2 Lesen eines einzelnen Datensatzes.............................................................. 45
8.4.4 Lesen mehrerer Datensätze................................................................................. 49
8.4.4.1 Lesen in eine interne Tabelle ...................................................................... 49
8.4.4.2 Lesen in einen Arbeitsbereich – SELECT als Schleifenkonstrukt.............. 51
8.4.5 Praxis: Übung zur Ausgabe von Tabelleninhalten ............................................. 52
8.4.6 Die SELECT-Anweisung im Detail ................................................................... 57
8.4.6.1 Der SELECT-Teil ....................................................................................... 58
8.4.6.2 Der FROM-Teil ........................................................................................... 60
8.4.6.3 Der INTO-Teil............................................................................................. 64
8.4.6.4 Praxis: Übung zu SELEC T ......................................................................... 65
8.4.6.5 Der WHERE-Teil ........................................................................................ 66
8.4.6.6 Der GROUP BY- und HAVING-Teil ......................................................... 68
8.4.6.7 Der ORDER BY- Teil .................................................................................. 68
8.4.6.8 Auslesen von Daten über einen Cursor ....................................................... 69
Seite 2
Copyright Prof. Dr. Heimo H. Adelsberger/Dipl.-Wirt.-Inf. Pouyan Khatami
Einführung in ABAP
8.4.7 Praxis: Übung zu Gruppierung und Aggregatfunktionen................................... 70

8.4.8 Neuerungen in OpenSQL ................................................................................... 72
8.4.9 Inline-Deklarationen in OpenSQL ..................................................................... 73
8.4.9.1 Lesen eines einzelnen Wertes ..................................................................... 73
8.4.9.2 Strukturierte Daten auslesen........................................................................ 73
8.4.9.3 Lesen von Tabellen ..................................................................................... 74
8.4.9.4 Vorsicht bei Zuweisungen........................................................................... 74
8.4.10 SQL-Ausdrücke .................................................................................................. 74
8.4.11 Einfügen von Daten ............................................................................................ 75
8.4.12 Bearbeiten von Daten ......................................................................................... 76
8.4.13 Automatisches Einfügen oder Bearbeiten .......................................................... 77
8.4.14 Löschen von Daten ............................................................................................. 78
8.5 Berechtigungsprüfungen ............................................................................................ 79
8.6 Praxis: Übung zur Berechtigungsprüfung ................................................................. 82
8.7 Indizes ........................................................................................................................ 85
8.8 Praxis: Übung zum Anlegen eines Sekundärindex.................................................... 86
8.9 Pufferung ................................................................................................................... 88
8.9.1 Vollständige Pufferung....................................................................................... 88
8.9.2 Generische Pufferung ......................................................................................... 89
8.9.3 Pufferung von Einzelsätzen ................................................................................ 91
8.9.4 Synchronisation von Puffern .............................................................................. 91
8.9.5 Wirksamkeit von Puffern ................................................................................... 97
8.10 Views...................................................................................................................... 97
8.10.1 Praxis: Übung zum Anlegen eines Views .......................................................... 98
8.10.2 Pflegedialoge .................................................................................................... 100
8.10.2.1 Praxis: Übung zu Pflegeviews und Pflegedialogen................................... 101
8.10.2.2 Viewcluster................................................................................................ 105
8.11 Besondere Tabellenarten ...................................................................................... 106
8.11.1 Clustertabellen und Tabellencluster ................................................................. 106
8.11.2 Pooltabellen und Tabellenpools ....................................................................... 107
8.11.3 Bewertung von Pool- und Clustertabellen........................................................ 108
8.12 Änderungen an Dictionary-Objekten ................................................................... 110
8.12.1 Verwendungsnachweise ................................................................................... 110
8.12.2 Aktivieren von Objekten .................................................................................. 111
8.12.3 Praxis: Übung zum Verwendungsnachweis ..................................................... 112
8.12.4 Änderungen an Tabellen................................................................................... 114
8.12.5 Ablauf eines Umsetzprozesses ......................................................................... 116
8.12.6 Praxis: Übung zur Umsetzung .......................................................................... 121
8.12.7 Erweitern von SAP-Standardtabellen ............................................................... 124
8.12.7.1 Append-Strukturen .................................................................................... 124
8.12.7.2 Customizing Includes ................................................................................ 127
8.12.8 Praxis: Übung zu Erweiterungen ...................................................................... 127
8.13 Performance von Anfragen .................................................................................. 129
8.13.1 Lesen Sie nur die Daten, die Sie wirklich benötigen........................................ 129
8.13.2 Geben Sie vollständige Schlüssel an ................................................................ 130
8.13.3 Vermeiden wiederholter, einzelner Zugriffe .................................................... 131
8.13.4 Verwenden Sie Joins statt geschachtelter SELECTs........................................ 131
8.13.5 Abwägungsentscheidungen .............................................................................. 132
8.13.5.1 Beispiel: Sortierung ................................................................................... 132
8.13.5.2 Beispiel: Berechnungen............................................................................. 132
8.14 Kapitelabschluss ................................................................................................... 133
Seite 3
Einführung in ABAP
Abbildungsverzeichnis
Abbildung 1: Funktionen des Dictionary im Überblick ............................................................. 8
Abbildung 2: Ein Selektionsbild des Data Browsers: SAP-System-Screenshot ...................... 10
Abbildung 3: Ergebnisliste des Data Browsers: SAP-System-Screenshot............................... 11
Abbildung 4: Der Einstiegsbildschirm des ABAP Dictionary: SAP-System-Screenshot........ 12
Abbildung 5: Externe Typen des Dictionary: SAP-System-Screenshot .................................. 13
Abbildung 6: Die Typhierarchie von ABAP ............................................................................ 14
Abbildung 7: Dictionary-Typen im Zusammenhang ............................................................... 15
Abbildung 8: Beispiel für eine Domäne im Dictionary: SAP-System-Screenshot .................. 16
Abbildung 9: Die Wertebereichs-Angaben der Domäne: SAP-System-Screenshot ................ 17
Abbildung 10: Pflegedialog eines Datenelements: SAP-System-Screenshot .......................... 18
Abbildung 11: Der Karteireiter zur Festlegung der Feldbezeichner: SAP-System-Screenshot
.................................................................................................................................................. 19
Abbildung 12: Der Strukturtyp str_fahrzeug............................................................................ 19
Abbildung 13: Eine Struktur im ABAP Dictionary: SAP-System-Screenshot ........................ 20
Abbildung 14: Direkte Typangabe bei einer Struktur: SAP-System-Screenshot..................... 20
Abbildung 15: Ein Tabellentyp im ABAP Dictionary: SAP-System-Screenshot.................... 21
Abbildung 16: Einstellungen zu Initialisierung und Zugriff: SAP-System-Screenshot........... 22
Abbildung 17: Einstellung zum Schlüssel: SAP-System-Screenshot ...................................... 22
Abbildung 18: Definition einer Typgruppe im ABAP Dictionary: SAP-System-Screenshot . 23
Abbildung 19: Anlegen einer Domäne aus dem Einstiegsbild des ABAP Dictionary: SAP-
System-Screenshot ................................................................................................................... 24
Abbildung 20: Definition der Domäne im ABAP Dictionary: SAP-System-Screenshot ........ 25
Abbildung 21: Erster Schritt zum Anlegen eines Datenelements: SAP-System-Screenshot... 26
Abbildung 22: Zweiter Schritt zum Anlegen eines Datenelements: SAP-System-Screenshot 26
Abbildung 23: Datentypangaben des Datenelements: SAP-System-Screenshot ..................... 27
Abbildung 24: Pflege der Feldbezeichner: SAP-System-Screenshot....................................... 27
Abbildung 25: Erster Schritt zum Anlegen einer Struktur im ABAP Dictionary: SAP-System-
Screenshot................................................................................................................................. 28
Abbildung 26: Zweiter Schritt zum Anlegen einer Struktur im ABAP Dictionary: SAP-
Abbildung 27: Beispiel für eine Struktur für Studenten: SAP-System-Screenshot ................. 28
Abbildung 28: Erster Schritt zum Anlegen eines Tabellentypen im ABAP Dictionary: SAP-
Abbildung 29: Zweiter Schritt zum Anlegen eines Tabellentypen im ABAP Dictionary: SAP-
Abbildung 30: Zeilentypangabe des Tabellentyps: SAP-System-Screenshot .......................... 29
Abbildung 31: Konfiguration des Schlüssels eines Tabellentyps: SAP-System-Screenshot ... 30
Abbildung 32: Korrigierter Titel: SAP-System-Screenshot ..................................................... 31
Abbildung 33: Oberfläche ohne gepflegten Selektionstext: SAP-System-Screenshot ............ 32
Abbildung 34: Aus dem ABAP Dictionary geladener Text (Beispiel Studiengang): SAP-
Abbildung 35: Oberfläche mit Selektionstext aus dem ABAP Dictionary: SAP-System-
Screenshot................................................................................................................................. 32
Abbildung 36: Schlüsselfelder einer Tabelle ........................................................................... 33
Abbildung 37: Unterschiedliche Felder, unterschiedliche Datenelemente, selbe Domäne...... 34
Abbildung 38: Eine Struktur als Include in unterschiedlichen Tabellen.................................. 35
Abbildung 39: Anlegen einer Datenbanktabelle: SAP-System-Screenshot ............................. 35
Abbildung 40: Felder der Tabelle: SAP-System-Screenshot ................................................... 36
Seite 4
Einführung in ABAP
Abbildung 41: Expandiertes Include: SAP-System-Screenshot............................................... 36

Abbildung 42: Feldliste mit vollständigem Schlüssel .............................................................. 37
Abbildung 43: Technische Einstellungen einer Tabelle: SAP-System-Screenshot ................. 37
Abbildung 44: Beispiel für Fragmentierung............................................................................. 38
Abbildung 45: Größenkategorien: SAP-System-Screenshot.................................................... 39
Abbildung 46: Puffer ................................................................................................................ 40
Abbildung 47: Technische Einstellungen der Studenten-Tabelle: SAP-System-Screenshot ... 41
Abbildung 48: Aufbau einer lesenden Anfrage (Überblick) .................................................... 44
Abbildung 49: Veranschaulichung der Anfrage ....................................................................... 46
Abbildung 50: Explizite Angabe der Zielfelder ....................................................................... 48
Abbildung 51: Beispiel für Namensbasierte Feldzuordnung ................................................... 49
Abbildung 52: Der Array Fetch................................................................................................ 50
Abbildung 53: SELECT als Schleifenkonstrukt....................................................................... 51
Figure 54: SELECT-Schleife: SAP-System-Screenshot .......................................................... 52
Abbildung 55: Programmausgabe: SAP-System-Screenshot................................................... 53
Abbildung 56: Selektionsbildschirm: SAP-System-Screenshot............................................... 54
Abbildung 57: Selektionsbildschirm: SAP-System-Screenshot............................................... 54
Abbildung 58: Anlegen eines Funktionsbausteins: SAP-System-Screenshot.......................... 54
Abbildung 59: Import-Parameter des Funktionsbausteins: SAP-System-Screenshot.............. 55
Abbildung 60: Der Tabellentyp auf Basis von SPFLI: SAP-System-Screenshot .................... 55
Abbildung 61: Verwendung des Tabellentypen für die Typisierung: SAP-System-Screenshot
.................................................................................................................................................. 55
Abbildung 62: Aufruf des Funktionsbausteins : SAP-System-Screenshot .............................. 56
Abbildung 63: Neue Ausnahme: SAP-System-Screenshot ...................................................... 56
Abbildung 64: Ausgabe einer einfachen Fehlermeldung: SAP-System-Screenshot................ 57
Abbildung 65: Beispiel für einen Tabellen-Join ...................................................................... 62
Abbildung 66: Ausgabe des Join-Programms: SAP-System-Screenshot................................. 63
Abbildung 67: Code für das Join-Programm: SAP-System-Screenshot .................................. 63
Abbildung 68: Ausgaben des Statistikprogramms: SAP-System-Screenshot.......................... 71
Abbildung 69: Beispiel für ein Statistik-Programm: SAP-System-Screenshot ....................... 72
Abbildung 70: Überblick über das Berechtigungskonzept....................................................... 80
Abbildung 71: Das Berechtigungsobjekt S_CARRID: SAP-System-Screenshot.................... 82
Abbildung 72: Zulässige Aktivitäten: SAP-System-Screenshot .............................................. 83
Abbildung 73: AUTHORITY-CHECK als Muster einfügen: SAP-System-Screenshot ......... 83
Abbildung 74: Code zur Prüfung der Berechtigung: SAP-System-Screenshot ....................... 84
Abbildung 75: Zugriff mit und ohne Index .............................................................................. 85
Abbildung 76: Anlegen eines Index: SAP-System-Screenshot................................................ 86
Abbildung 77: Pflege der Eigenschaften des Index: SAP-System-Screenshot ........................ 87
Abbildung 78: Status des Index: SAP-System-Screenshot ...................................................... 87
Abbildung 79: Vollständige Pufferung .................................................................................... 89
Abbildung 80: Generische Pufferung ....................................................................................... 90
Abbildung 81: Einzelsatzpufferung.......................................................................................... 91
Abbildung 82: Pufferung in zwei Anwendungsservern ........................................................... 92
Abbildung 83: Synchronisationsbeispiel 1/4 ............................................................................ 93
Abbildung 87: Pflegedialog und Pflegeview.......................................................................... 100
Abbildung 88: Anlegen eines Pflege-Views: SAP-System-Screenshot ................................. 101
Abbildung 89: Beziehungen der Tabelle SBUSPART: SAP-System-Screenshot ................. 102
Abbildung 90: Automatische Joinbedingungen: SAP-System-Screenshot ............................ 102
Seite 5
Einführung in ABAP
Abbildung 91: Auswahl der Felder für den Pflegeview: SAP-System-Screenshot ............... 103
Abbildung 92: Tabellenpflegegenerator: SAP-System-Screenshot ....................................... 104
Abbildung 93: Tabellentyp ändern: SAP-System-Screenshot ............................................... 106
Abbildung 94: Aufbau eines Tabellenclusters ....................................................................... 107
Abbildung 95: Aufbau eines Tabellenpools ........................................................................... 108
Abbildung 96: Verwendungsnachweis ................................................................................... 110
Abbildung 97: Aktive und inaktive Version einer Struktur ................................................... 111
Abbildung 98: Auswahlfenster für den Verwendungsnachweis: SAP-System-Screenshot... 112
Abbildung 99: Ergebnisse der Suche: SAP-System-Screenshot ............................................ 113
Abbildung 100: Starttermin festlegen: SAP-System-Screenshot ........................................... 113
Abbildung 101: Ein Hintergrundjob wurde beendet: SAP-System-Screenshot..................... 114
Abbildung 102: Änderung an verschiedenen Stellen ............................................................. 115
Abbildung 103: Umsetzung 1/5.............................................................................................. 116
Abbildung 108: Direkte Typeingabe: SAP-System-Screenshot............................................. 121
Abbildung 109: Felder der Tabelle ZZ####_UMSETZ: SAP-System-Screenshot ............... 121
Abbildung 110: Daten der Tabelle: SAP-System-Screenshot ................................................ 122
Abbildung 111: Fehlermeldung: SAP-System-Screenshot .................................................... 122
Abbildung 112: Fehler bei der Aktivierung: SAP-System-Screenshot .................................. 122
Abbildung 113: Einstiegsmaske des Datenbank-Utility: SAP-System-Screenshot ............... 123
Abbildung 114: Erfolgsmeldung: SAP-System-Screenshot................................................... 123
Abbildung 115: Geänderte Tabelle: SAP-System-Screenshot ............................................... 123
Abbildung 116: Tabelleninhalt nach der Umsetzung: SAP-System-Screenshot ................... 124
Abbildung 117: Append-Strukturen ....................................................................................... 125
Abbildung 118: Appends und neue Felder von SAP .............................................................. 126
Abbildung 119: Anlegen einer Append-Struktur: SAP-System-Screenshot.......................... 127
Abbildung 120: Pflege der Append-Struktur: SAP-System-Screenshot ................................ 127
Abbildung 121: Append-Struktur in der Feldliste: SAP-System-Screenshot ........................ 128
Seite 6
Einführung in ABAP
Copyright
 Für alle Screenshots im Skriptum, auch wenn diese nur verkürzt oder auszugsweise
gezeigt werden, gilt der Hinweis: Copyright SAP AG
 Die Theorieteile basieren auf der im ersten Skript aufgelisteten Literatur.
 Die Weitergabe und Vervielfältigung dieser Publikation oder von Teilen daraus sind,
zu welchem Zweck und in welcher Form auch immer, ohne die schriftliche
Genehmigung von Prof. Dr. Heimo H. Adelsberger und Dipl.-Wirt.-Inf. Pouyan
Khatami nicht gestattet.
Seite 7
Einführung in ABAP
8 ABAP Dictionary und Datenbanken

Das ABAP Dictionary (ehemals R/3 Data Dictionary) ist ein mächtiges Werkzeug des SAP-
Systems. Die Aufgaben liegen in der Verwaltung von Daten und Metadaten, also Daten über
Daten.
Abbildung 1: Funktionen des Dictionary im Überblick
Die obige Abbildung veranschaulicht die Funktionen des ABAP Dictionary. Diese sind:
 Typdefinitionen
o Datentypen – global verfügbare Datentypen (Gegensatz zu den lokal über
TYPES definierten Typen)
o Typgruppen – Gruppen von Datentypen
o Domänen – beschreiben technische Eigenschaften wie Wertebereiche von
Datenelementen
 Services
o Das Dictionary enthält Suchhilfen für die Erstellung von Oberflächen mit
bequemer Eingabemöglichkeit
o Es können Bezeichnungen und Hilfen zu Datentypen in verschiedenen
Sprachen hinterlegt und somit auch zentral gepflegt werden
 Die Verwaltung von Datenbankobjekten
o Datenbanktabellen (Tabellen des zugrunde liegenden relationalen
Datenbanksystems) werden im Dictionary verwaltet und von diesem auf der
Datenbank angelegt, geändert bzw. gelöscht
o Über das ABAP Dictionary kann der Zugriff auf Datenbanken realisiert
werden, ohne dass dem Programm hierfür bekannt sein muss, um welche
Datenbank es sich genau handelt (z. B. MS SQL-Server)
o Datenbanken können als Entity-Relationship-Modell grafisch angezeigt
werden
o Das Dictionary enthält Views (Sichten auf die Tabellen, die mehrere Tabellen
verknüpfen können oder nur bestimmte Teile von Tabellen enthalten). Hierbei
Seite 8
Einführung in ABAP
kann es sich um Views des zugrundeliegenden DB-Systems handeln, dies ist

aber nicht zwingend erforderlich.
o Das Dictionary enthält Sperrobjekte als Grundlage für Sperren auf
Datenbanktabellen
o Einstellungen zur Pufferung zur Erhöhung der Performance können
vorgenommen werden
o Fremdschlüsselbeziehungen zur Sicherung konsistenter Eingaben in Dynpros
können definiert werden
o Es kann eine Protokollierung von Änderungen an Tabelleneinträgen aktiviert
werden
Das ABAP Dictionary interagiert mit den Werkzeugen der ABAP Workbench, mit dem
Dynpro-Interpreter sowie mit der Datenbankschnittstelle.
Beispiele für diese Interaktion sind:
 Die Nutzung von Datentypen des ABAP Dictionary bei der Erstellung von Quellcode
in der ABAP Workbench
 Die Nutzung einer Suchhilfe in einer Dynpro-Oberfläche, die im ABAP Dictionary
definiert wurde
 Die Definition einer Tabelle im ABAP Dictionary, die durch das Dictionary auf der
Datenbank angelegt wird
8.1 Exkurs: Der Data Browser

In SAP steht zu Übungszwecken ein Flugdatenbeispiel bereit. Anhand dieses Beispiels
können alle Konzepte des ABAP Dictionary geübt werden. Es enthält Daten zu
Fluggesellschaften, Flugverbindungen, Flügen, Buchungen usw.
Einige der Tabellen des Flugdatenbeispiels werden in den Erläuterungen zum Arbeiten mit
dem ABAP Dictionary verwendet. Sie können die Inhalte dieser und anderer
Datenbanktabellen über den Data Browser erreichen.
8.1.1 Aufgaben des Data Browsers
Den Data Browser erreichen Sie über den Menüpfad
Werkzeuge -> ABAP Workbench -> Übersicht -> Data Browser
oder den Transaktionscode SE16.
Hierüber können die Inhalte von Tabellen betrachtet werden. Wenn in den
Tabelleneigenschaften eine unbeschränkte Pflegeerlaubnis erteilt wurde, können von hier aus
auch neue Inhalte angelegt werden. Natürlich gibt es auch eine Funktion zum Bearbeiten von
Einträgen. Auch Einträge aus Prüftabellen können angezeigt werden.
Seite 9
Einführung in ABAP
8.1.2 Praxis: Übung zur Nutzung des Data Browsers
Starten Sie den Data Browser über den o. g. Menüpfad oder den Transaktionscode SE16.
Geben Sie als Tabellenname SPFLI an und bestätigen Sie. Sie gelangen nun zu einer
Eingabemaske, in der die verschiedenen Spalten der Tabelle angezeigt werden. Diese Maske
dient der Eingabe von Filterkriterien. Die Tabelle SPFLI enthält Daten über
Flugverbindungen.
Abbildung 2: Ein Selektionsbild des Data Browsers: SAP-System-Screenshot
Als kleine Übung sollen die Flüge der Linien Delta Airlines und Lufthansa, die zwischen
einer und sechs Stunden dauern, ausgewählt werden.
Geben Sie hierzu in das Eingabefeld neben CARRID (ID der Fluggesellschaft) das Kürzel für
Delta Airlines ein. Verwenden Sie die Werthilfe, um das Kürzel zu erfahren. Da für die
Aufgabe mehrere Fluggesellschaften relevant sind, muss eine Mehrfachauswahl stattfinden.
Klicken Sie daher nun auf die Schaltfläche (Mehrfachselektion) in der gleichen Zeile, in
der sich auch das Eingabefeld CARRID befindet. Im erscheinenden Fenster ist das Kürzel für
Delta Airlines bereits in der ersten Zeile eingetragen. Verwenden Sie die zweite Zeile, um das
Kürzel für die Lufthansa hinzuzufügen. Benutzen Sie ebenfalls die Werthilfe. Bestätigen Sie
mit der Schaltfläche (Übernehmen) oder der Taste F8. Geben Sie nun bei FLTIME 1:00
Seite 10
Einführung in ABAP
ein und im daneben stehenden bis-Eingabefeld 6:00. Hierdurch werden die Flüge gefiltert,
deren Flugdauer zwischen einer und sechs Stunden liegt. Bestätigen Sie die Kriterien mit der
Schaltfläche (Ausführen) oder der Taste F8.
Sie sehen nun drei Flüge, die den zuvor spezifizierten Kriterien genügen. Sollten Sie andere
Daten vorfinden, kann dies daran liegen, dass andere Kursteilnehmer bereits schreibend auf
die Datenbank zugegriffen haben.
Abbildung 3: Ergebnisliste des Data Browsers: SAP-System-Screenshot
Verlassen Sie den Data Browser nun wieder.
Seite 11
Einführung in ABAP
8.2 Typen des ABAP Dictionary

Das ABAP Dictionary verfügt über einige eingebaute, elementare Typen. Diese Typen bauen
auf den bekannten ABAP-Datentypen auf und werden zur Definition von Datentypen im
Dictionary verwendet. Die so definierten Datentypen können auch in gewöhnlichen ABAP-
Programmen verwendet werden, die eingebauten Typen hingegen nicht. Sie werden jedoch
verwendet, um im Screen Painter Eingabefeldern Typen zuzuweisen oder in Open SQL
(hierzu später mehr).
Abbildung 4: Der Einstiegsbildschirm des ABAP Dictionary: SAP-System-Screenshot
Um die eingebauten Typen zu sehen, öffnen Sie das ABAP Dictionary (Transaktion SE11).
Klicken Sie auf das Eingabefeld neben Datentyp und dann auf die Werthilfe des Feldes.
Klicken Sie anschließend auf die Schaltfläche Suche nach Datenelementen. Es erscheint ein
neues Fenster, klicken Sie dort ebenfalls auf das Eingabefeld neben Datentyp und auf dessen
Werthilfe. Es erscheint folgendes Fenster:
Seite 12
Einführung in ABAP
Abbildung 5: Externe Typen des Dictionary: SAP-System-Screenshot
Um detaillierte Informationen zu erhalten, klicken Sie mit der rechten Maustaste auf einen der
externen Typen und wählen Sie Hilfe. Es erscheint ein Fenster mit einer Erläuterung zum
angeklickten Typ. In diesem Fenster finden Sie auch einen Link zur Übersicht der
Datentypen. Dort sind alle externen Typen mit einer kurzen Erklärung aufgelistet.
Schauen Sie sich die Typen an. Einige der Typen werden Ihnen im weiteren Kursverlauf noch
einmal begegnen. An diesen Stellen können Sie die Informationen aus den hier beschriebenen
Hilfetexten verwenden, um die Eigenschaften der Typen nachzuschlagen.
8.2.1 Von lokalen zu globalen Typen
Die folgende Abbildung kennen Sie bereits aus einem früheren Teil des Kurses. Sie zeigt die
Hierarchie der Typen in ABAP:
Seite 13
Einführung in ABAP
Abbildung 6: Die Typhierarchie von ABAP
Sie haben bereits gelernt, wie Sie lokale benutzerdefinierte Typen definieren können:
 Elementare Typen über die einfache TYPES-Definition

 Zeilentypen über die TYPES-Definition mit BEGIN OF / END OF
 Tabellentypen über die TYPES-Definition mit dem Zusatz TABLE OF
Der Nachteil dieser lokal definierten Typen ist, dass sie nur im jeweiligen Programm definiert
sind: Definieren Sie in einem Programm einen Typ (bspw. Ihr Typ für Fahrzeuge aus der
Übung), und in einem anderen Programm eine Variable dieses Typs, führt dies zu einem
Fehler. Ein naheliegender Gedanke wäre, den Typ in beiden Programmen zu definieren.
Hierdurch würde jedoch der Pflegeaufwand größer. Stattdessen verfügt das SAP-System über
das ABAP Dictionary, mit dem globale Typen definiert und daraufhin in allen Programmen
genutzt werden können. Hinzu kommen weitere, bereits zu Beginn dieses Kapitels genannte
Vorteile, die Sie sich zunutze machen können.
Die folgende Abbildung zeigt einen Überblick über die Typen des Dictionary, die im
Folgenden erläutert werden. Die Darstellung ist vereinfacht. So ist es etwa auch möglich,
einen Tabellentypen zu definieren, der nicht auf einem Strukturtyp basiert.
Seite 14
Einführung in ABAP
Abbildung 7: Dictionary-Typen im Zusammenhang
8.2.2 Domänen
Domänen dienen dazu, technische Eigenschaften von Datentypen zu definieren. Datentypen

lassen sich auch ohne Domäne durch direkte Angabe aller benötigter Eigenschaften
definieren, dies gilt jedoch nicht als guter Stil. Aus diesem Grund sollten Sie möglichst auf
Domänen zurückgreifen.
Domänen können nicht dazu verwendet werden, Datenobjekte in ABAP-Programmen zu

typisieren. Hierfür sind mindestens Datentypen notwendig.
Seite 15
Einführung in ABAP
Abbildung 8: Beispiel für eine Domäne im Dictionary: SAP-System-Screenshot
Der Screenshot zeigt die Definition einer Domäne. Hier können Einstellungen zum Format
und zu den Ausgabeeigenschaften vorgenommen werden.
Zunächst ist der Datentyp festzulegen, in diesem Fall ist dies CHAR. Hier können alle
eingebauten Typen des Dictionary ausgewählt werden, die Sie in Abschnitt 8.2 gesehen
haben. Für entsprechende Typen kann die Anzahl der zu speichernden Stellen bzw.
Dezimalstellen festgelegt werden. Im Beispiel ist das Dezimalstellen-Feld deaktiviert, da der
CHAR-Typ eine solche Angabe nicht zulässt.
Beachten Sie, dass Felder des Typ CHAR in Tabellen nur die maximale Länge von 255 haben
dürfen. Für längere Texte ist die Verwendung des Typ LCHR erforderlich. Diese
Einschränkung gilt nicht für Strukturen.
Bei den Ausgabeeigenschaften kann die Ausgabelänge festgelegt werden, die die Feldlänge
für die Ein- und Ausgabe bestimmt. Das Feld Konvert.-Routine dient der Angabe einer
Konvertierungsroutine. Diese sind dann vonnöten, wenn zwischen Eingabe und Speicherung
bzw. bei der Ausgabe Umwandlungen zwischen der Darstellung und der internen
Repräsentation vorgenommen werden sollen. Das Vorzeichen-Feld gibt an, ob negative Werte
zulässig sind oder nicht, während das Kleinbuchstaben-Feld die Unterscheidung zwischen
Seite 16
Einführung in ABAP
Groß- und Kleinbuchstaben ein- bzw. ausschaltet. Bei Nichtunterscheidung werden

Kleinbuchstaben nach der Eingabe automatisch in Großbuchstaben umgewandelt.
Abbildung 9: Die Wertebereichs-Angaben der Domäne: SAP-System-Screenshot
Im Karteireiter Wertebereich können bei Bedarf nur bestimmte Festwerte oder Intervalle von
Werten für die Domäne zugelassen werden. Eine solche Festlegung ist nur möglich, wenn die
Domäne auf einem der eingebauten Typen CHAR, NUMC, DEC, INT1, INT2 oder INT4
basiert.
Die Angabe einer Wertetabelle hat nur dokumentarischen Wert, eine Angabe dient hier
lediglich der Generierung von Vorschlägen bei Fremdschlüsseln von Tabellen.
8.2.3 Datenelemente
Sie kennen bereits lokale Typen, die Sie mit der TYPES-Anweisung definieren. Die globalen
Datentypen (Datenelemente) des ABAP Dictionary können genau wie die lokalen Typen in
ABAP-Programmen verwendet werden. Zu den Vorteilen von globalen Typen zählen:
 Zentrale Wartbarkeit
Seite 17
Einführung in ABAP
 Wiederverwendbarkeit
 Hinterlegen von Zusatzeigenschaften und Feldbezeichnern
Abbildung 10: Pflegedialog eines Datenelements: SAP-System-Screenshot
Die Abbildung zeigt, wie ein Datenelement für den Herstellernamen aus dem
Fahrzeugbeispiel definiert werden kann. Hier werden die Technischen Eigenschaften aus der
soeben definierten Domäne bezogen. Alternativ wäre es auch möglich, diese durch direkte
Angabe des eingebauten Typs und der Länge zu definieren. So können jedoch technische
Eigenschaften unterschiedlicher Datenelemente, die technisch gleiche Eigenschaften haben
sollen, nicht mehr zentral gepflegt werden.
Einen Spezialfall stellt die Angabe eines Referenztyps dar. Hier können Referenzen auf
andere Datenelemente, aber auch generische Referenzen auf ANY, OBJECT oder DATA
festgelegt werden. Referenzen des Typs ANY können sowohl auf Objekte als auch auf Daten
zeigen. Referenztypen werden Ihnen im Rahmen von ABAP Objects begegnen.
Datenelemente beschreiben im Gegensatz zu Domänen auch semantische Eigenschaften des

Typs. So werden auf dem Tab Feldbezeichner Beschriftungen für entsprechend typisierte
Felder gepflegt:
Seite 18
Einführung in ABAP
Abbildung 11: Der Karteireiter zur Festlegung der Feldbezeichner: SAP-System-Screenshot
Die hier hinterlegten Bezeichner können, z. B. bei der Gestaltung von Oberflächen
wiederverwendet werden: Die Selektionstexte zu einem Eingabefeld können automatisch über
das dem Feld zugrundeliegenden Datenelement aus dem Dictionary bezogen werden. Hierbei
wird auch Mehrsprachigkeit unterstützt, so dass dem Anwender automatisch Texte in seiner
Sprache angezeigt werden. Diese Übersetzungen können im Dictionary vorgenommen
werden, indem der Menüpfad Springen -> Übersetzung gewählt wird. Die angegebenen
Längen sind als Maximallängen zu verstehen, die für alle Sprachen gelten. Sie sollten diese
deshalb großzügig wählen.
Der Karteireiter Zusatzeigenschaften ermöglicht einige weitere Einstellungen zum

Datenelement. So können Suchhilfen konfiguriert werden, die später im Kurs noch näher
Thematisiert werden. Außerdem kann eine Parameter-ID vergeben werden. Dies dient der
Nutzung von GET/SET-Parametern. Dabei geht es darum, häufig bei der Nutzung des
Systems durch den Anwender verwendete Felder, in die in der Regel immer der gleiche Wert
eingetragen werden muss, nach der ersten Eingabe im weiteren Sitzungsverlauf automatisch
vorzubefüllen.
Beachten Sie, dass Datenelemente wie auch andere Typen im Dictionary aktiviert werden
müssen!
8.2.4 Strukturen
Bislang haben wir Feldleistentypen im Code definiert wie den Typ str_fahrzeug:
TYPES: BEGIN OF str_fahrzeug,

herstellername(30) TYPE c,
modellname(30) TYPE c,
farbe(10) TYPE c,
motorleistung TYPE i,
END OF str_fahrzeug.
So wurde ein Typ definiert, der den Aufbau von Datenobjekten des Typs str_fahrzeug
festlegt.
Abbildung 12: Der Strukturtyp str_fahrzeug
Seite 19
Einführung in ABAP
Wie bei der TYPES-Anweisung können auch im Dictionary Strukturen angelegt werden. Die
folgende Abbildung zeigt eine Struktur im Dictionary, die dem lokalen Typ nachempfunden
wurde:
Abbildung 13: Eine Struktur im ABAP Dictionary: SAP-System-Screenshot
In der Spalte Komponententyp ist für jedes Feld der Struktur ein Datenelement des ABAP
Dictionary angegeben. Der Inhalt der Spalte Kurzbeschreibung wird von diesen
Datenelementen bezogen. Ebenfalls werden über das Datenelement die technischen
Eigenschaften bezogen: Entweder aus der im Datenelement angegebenen Domäne oder aus
der etwas weniger eleganten Angabe direkt im Datenelement.
Durch Anklicken der Schaltfläche kann die Definition der Komponenten
der Struktur auch ohne Datenelement vorgenommen werden:
Abbildung 14: Direkte Typangabe bei einer Struktur: SAP-System-Screenshot
Hierdurch werden die Spalten ab Datentyp eingabebereit, die Spalte Komponententyp

hingegen deaktiviert. Hier könnten nun direkte Typeinstellungen unter Rückgriff auf die
eingebauten Typen des Dictionary vorgenommen werden. Dieser Weg ist jedoch wenig
elegant.
Die global definierte Struktur kann nach Aktivierung in beliebigen ABAP-Programmen zur
Typisierung von Datenobjekten verwendet werden. Ein einfaches Beispiel zeigt die folgende
Zeile:
DATA meinfirmenwagen TYPE zz0000_fahrzeug.
Eine Struktur wird als tiefe Struktur bezeichnet, wenn sie mindestens eine Komponente
besitzt, deren Typ ein Tabellentyp (oder Referenztyp oder String) ist. Globale Tabellentypen
werden im folgenden Abschnitt erläutert.
8.2.5 Tabellentypen
Analog zu den lokalen Tabellentypen können im Dictionary globale Tabellentypen hinterlegt

werden. Diese können in Programmen wie lokale Tabellentypen zur Definition von internen
Tabellen verwendet werden.
Seite 20
Einführung in ABAP
Ein Tabellentyp für Fahrzeuge könnte wie folgt aussehen:
Abbildung 15: Ein Tabellentyp im ABAP Dictionary: SAP-System-Screenshot
Analog zur lokalen Definition von Tabellentypen wird auch hier ein Typ für die Zeilen des
Tabellentypen festgelegt. In der Regel ist dies eine Struktur, so wie hier
ZZ####_FAHRZEUG. Dass es sich um eine Struktur handelt, können Sie an dem Symbol
neben dem Eingabefeld für den Typ erkennen.
Würde nur ein Datenelement angegeben, wäre das Symbol und jeder Eintrag der Tabelle
bestünde nur aus einem solchen einfachen Element. Würde ein Tabellentyp angegeben, wäre
das Symbol . In diesem Fall entspricht jeder Eintrag der Tabelle selbst einer Tabelle. Wie
bei den lokalen Tabellentypen ist dies in den meisten Fällen nicht das erwünschte Ergebnis.
Im Karteireiter Initialisierung und Zugriff können die Einstellungen zur initialen
Zeilenanzahl gemacht werden (entspricht INITIAL SIZE bei lokalen Typen) sowie der
Tabellentyp festgelegt werden.
Seite 21
Einführung in ABAP
Abbildung 16: Einstellungen zu Initialisierung und Zugriff: SAP-System-Screenshot
Hier stehen auch die generischen Einstellungen Index-Tabelle und nicht spezifiziert zur
Auswahl. Hierdurch entstünden generische Typen, die Sie zur Typisierung von
Formalparametern von Modularisierungseinheiten einsetzen können.
Im Karteireiter Schlüssel können Einstellungen zum Schlüssel des Tabellentyps gemacht

werden.
Abbildung 17: Einstellung zum Schlüssel: SAP-System-Screenshot
Die Schlüsselart entspricht der Angabe UNIQUE / NON UNIQUE bei lokalen Tabellentypen.
Im Bereich Schlüsseldefinition kann, ggf. über die darunter befindliche Liste, bestimmt
werden, aus welchen Komponenten der Tabellenschlüssel bestehen soll. Die Einstellung
Standardschlüssel verwendet bei einer Struktur als Zeilentyp deren zeichenartige
Seite 22
Einführung in ABAP
Komponenten, bei einfachen oder Referenztypen die gesamte Zeile, bei Tabellentypen als
Zeilentyp ist der Schlüssel leer. Die Einstellung Zeilentyp verwendet den Zeilentyp als
Schlüssel. Diese Einstellung wird bei strukturlosen Tabellen verwendet. Es kann dann über
die Pseudokomponente TABLE_KEY auf den Schlüssel zugegriffen werden.
Beachten Sie auch hier, dass Datenobjekte die den Tabellentyp besitzen sollen, nicht mit
TABLE OF definiert werden dürfen, da dies stattdessen eine Tabelle von Tabellen des Typs
erzeugen würde (technisch ist dies möglich, aber in der Regel nicht erwünscht).
8.2.6 Typgruppen und Konstanten
Um im Dictionary Konstanten definieren zu können, muss eine Typgruppe (Type Pool)

angelegt werden. Namen von Typgruppen dürfen höchstens 5 Zeichen enthalten. Es handelt
sich dabei um ein Stück ABAP-Code, in dem Sie die Konstanten wie lokale Konstanten über
den CONSTANTS-Befehl definieren können. Auch die Definition von Typen ist dort erlaubt.
Das Konzept Typen in Typgruppen zu definieren ist ein Vorläufer globaler Typen1 .
Abbildung 18: Definition einer Typgruppe im ABAP Dictionary: SAP-System-Screenshot
Der Bezeichner der Konstanten und Typen muss hierbei mit dem Namen der Typgruppe
gefolgt von einem Unterstrich beginnen.
Um die Typgruppe in einem ABAP-Programm verwenden zu können, muss sie dort über den
Befehl TYPE-POOLS eingebunden werden:
TYPE-POOLS ZZ000.
Daraufhin können die Konstanten und Typen der Typgruppe im ABAP-Programm verwendet
werden.
8.2.7 Praxis: Übung zu globalen Typen
In dieser Übung soll ein Programm erstellt werden, das mit den persönlichen Daten von
Studenten arbeitet. Im Gegensatz zur Fahrzeugübung im letzten Kursteil werden jedoch
globale Typen des ABAP Dictionary genutzt.
1
Keller (2012, S. 87)
Seite 23
Einführung in ABAP
Ein Student soll in einer Struktur über eine Matrikelnummer, seinen Namen, seinen
Vornamen und drei weitere Eigenschaften Ihrer Wahl beschrieben werden.
Im Interesse eines guten Programmierstils werden Sie zunächst Domänen anlegen, diese
anschließend zur Definition von Datentypen verwenden, und daraus einen Strukturtyp
zusammensetzen, der schließlich Grundlage für einen Tabellentyp sein wird.
8.2.7.1 Domänen anlegen
Öffnen Sie das ABAP Dictionary über den Pfad Werkzeuge -> ABAP Workbench ->
Entwicklung -> Dictionary aus dem Easy Access-Menü oder den Transaktionscode SE11.
Es ist empfehlenswert, diese Transaktion auch in Ihre Favoriten aufzunehmen.
Um eine Domäne anzulegen, wählen Sie zunächst den Auswahlknopf Domäne aus und geben
Sie in das Textfeld daneben ZZ_####_CHAR20 ein. Klicken Sie dann auf
(siehe folgende Abbildung).
Abbildung 19: Anlegen einer Domäne aus dem Einstiegsbild des ABAP Dictionary: SAP-System-
Screenshot
Pflegen Sie eine passende Kurzbeschreibung. Die Domäne soll später Grundlage für die
Datenelemente für Name, Vorname und Studienfach werden. Hierfür wird ein 20-stelliger
Zeichenkettentyp benötigt. Geben Sie daher als zugrundeliegenden Datentyp CHAR an, und
als Zahl der Stellen genau wie für die Ausgabelänge 20 an. Lassen Sie außerdem
Kleinbuchstaben zu.
Seite 24
Einführung in ABAP
Abbildung 20: Definition der Domäne im ABAP Dictionary: SAP-System-Screenshot
Speichern, prüfen und aktivieren Sie die Domäne anschließend.
Erstellen Sie als nächstes eine Domäne ZZ_####_N10. Diese soll später für die
Matrikelnummern verwendet werden. Als Datentyp verwenden Sie hier den eingebauten Typ
NUMC, für die Stellenzahl und Ausgabelänge den Wert 10. Speichern, prüfen und aktivieren
Sie auch diese Domäne.
Legen Sie anschließend für die weiteren Komponenten, die Sie für die Abbildung eines
Studenten ausgewählt haben, ebenfalls geeignete Domänen an, sofern die technischen
Eigenschaften dieser Felder nicht bereits durch die soeben angelegten Domänen abgebildet
werden. Achten Sie darauf, dass Ihre Domänen mit ZZ_####_ beginnen.
8.2.7.2 Datenelemente Anlegen
Nachdem durch die Domänen die technischen Eigenschaften spezifiziert wurden, sollen als
nächstes Datenelemente für die semantischen Eigenschaften definiert werden.
Wählen Sie auf dem Einstiegsbildschirm des ABAP Dictionary den Eintrag Datentyp und
geben Sie als Name ZZ_####_ST_NAME an. Klicken Sie anschließend auf die Schaltfläche
Anlegen.
Seite 25
Einführung in ABAP
Abbildung 21: Erster Schritt zum Anlegen eines Datenelements: SAP-System-Screenshot
Nach dem Klick auf Anlegen fragt das SAP-System, welche Art von Datentyp Sie anlegen
möchten. Zur Auswahl stehen Datenelement, Struktur und Tabellentyp. Wählen Sie
Datenelement und bestätigen Sie.
Abbildung 22: Zweiter Schritt zum Anlegen eines Datenelements: SAP-System-Screenshot
Pflegen Sie nun eine passende Kurzbeschreibung und wählen Sie als Domäne die zuvor
angelegte Domäne ZZ_####_CHAR20. Bei Bestätigung mit Enter sehen Sie die
Eigenschaften der Domäne.
Seite 26
Einführung in ABAP
Abbildung 23: Datentypangaben des Datenelements: SAP-System-Screenshot
Wechseln Sie anschließend zum Karteireiter Feldbezeichner und pflegen Sie die
entsprechenden Angaben.
Abbildung 24: Pflege der Feldbezeichner: SAP-System-Screenshot
Speichern, prüfen und aktivieren Sie das Datenelement.
Wiederholen Sie diese Schritte, indem Sie ein Datenelement ZZ_####_ST_VORNAME und
ein Datenelement ZZ_####_ST_MATRIKEL für Vornamen und Matrikelnummern anlegen.
Für die Matrikelnummer soll die Domäne ZZ_####_N10 verwendet werden.
Legen Sie des Weiteren passende Datenelemente für die weiteren Komponenten Ihrer
Struktur an. Die Namen dieser Datenelemente sollen mit ZZ_####_ST_ beginnen.
Seite 27
Einführung in ABAP
8.2.7.3 Struktur anlegen
Als nächstes soll im ABAP Dictionary die Struktur für Studenten angelegt werden.
Verwenden Sie zum Anlegen wie bei den Datenelementen Datenelement im Einstiegsbild
des Dictionary, und geben Sie als Namen ZZ####_STUD an (Achtung: Diesmal steht kein
Unterstrich zwischen ZZ und ####, da dieser hier nicht zulässig ist). Im danach erscheinen
Fenster wählen Sie diesmal nicht Datenelement sondern Struktur.
Abbildung 25: Erster Schritt zum Anlegen einer Struktur im ABAP Dictionary: SAP-System-Screenshot
Abbildung 26: Zweiter Schritt zum Anlegen einer Struktur im ABAP Dictionary: SAP-System-Screenshot
Pflegen Sie nun eine passende Kurzbeschreibung und geben Sie die Komponenten der
Struktur an. Geben Sie hierfür in der Spalte Komponente den Namen (NAME, VORNAME,
MATRIKEL usw.) an und in der Spalte Komponententyp das zugehörige Datenelement. Das
Ergebnis sollte mit der folgenden Abbildung vergleichbar sein, wobei die über Name,
Vorname und Matrikelnummer hinausgehenden Komponenten natürlich bei Ihnen anders
aussehen können:
Abbildung 27: Beispiel für eine Struktur für Studenten: SAP-System-Screenshot
Speichern, prüfen und aktivieren Sie die Struktur.
Ignorieren Sie die Warnungen zu den Erweiterungskategorien.
8.2.7.4 Tabellentyp anlegen
Als nächstes werden Sie einen Tabellentyp anlegen, mit dem eine interne Tabelle von
Studenten später typisiert werden kann. Geben Sie dafür wie zuvor bei den Datenelementen
Seite 28
Einführung in ABAP
und bei der Struktur den Namen bei Datentyp in der Einstiegsmaske des Dictionary ein.
Dieser soll ZZ_####_STUD_TAB lauten. Legen Sie den Typ über die Anlegen-Schaltfläche
an und wählen Sie im erscheinenden Fenster diesmal Tabellentyp aus:
Abbildung 28: Erster Schritt zum Anlegen eines Tabellentypen im ABAP Dictionary: SAP-System-
Screenshot
Abbildung 29: Zweiter Schritt zum Anlegen eines Tabellentypen im ABAP Dictionary: SAP-System-
Screenshot
Pflegen Sie eine entsprechende Kurzbeschreibung und geben Sie als Zeilentyp die soeben
angelegte Struktur ZZ####_STUD an:
Abbildung 30: Zeilentypangabe des Tabellentyps: SAP-System-Screenshot
Stellen Sie anschließend sicher, dass im Karteireiter Initialisierung und Zugriff der
Auswahlpunkt Sortierte Tabelle ausgewählt ist. Wechseln Sie dann zum Karteireiter
Seite 29
Einführung in ABAP
Schlüssel und legen Sie fest, dass die Komponente MATRIKEL für den Schlüssel verwendet
werden soll, und dieser Schlüssel eindeutig ist:
Abbildung 31: Konfiguration des Schlüssels eines Tabellentyps: SAP-System-Screenshot
Speichern, prüfen und aktivieren Sie den Tabellentyp und verlassen Sie das ABAP
Dictionary.
8.2.7.5 Verwendung der globalen Typen
Die global definierten Typen sollen nun für ein einfaches Programm zur Studentenverwaltung
genutzt werden. Legen Sie hierfür ein neues Programm ZZ_####_STUDENTEN_GLOBAL
an.
Ähnlich Ihrem CARS-Programm aus dem letzten Kursteil sollen auch hier Daten über eine
Struktur eingegeben und in eine interne Tabelle eingefügt werden. Im Gegensatz zu diesem
bisherigen Programm benötigen Sie hier aber keine TYPES-Anweisungen. Stattdessen
werden Sie Ihre globalen Typen benutzen.
Erstellen Sie daher nun einen Arbeitsbereich, bei dem Sie als Typ ZZ####_STUD angeben,
und eine interne Tabelle, bei der Sie als Typ ZZ_####_STUD_TAB verwenden.
Achtung: Sie benötigen für die Typisierung kein TABLE OF. Der Typ
ZZ_####_STUD_TAB ist selbst bereits ein Tabellentyp. Theoretisch wäre es möglich, statt
des Tabellentyps mit TABLE OF ZZ####_STUD zu typisieren. Hierdurch würde jedoch
der globale Tabellentyp nicht mehr benutzt. Dies hätte zur Folge, dass die zusätzlichen
Einstellungen, wie etwa die Art der Tabelle, nicht mehr zentral im Dictionary gewartet
werden könnten. Umgekehrt wäre es auch möglich, den Arbeitsbeteich statt über den
Strukturtyp über LINE OF ZZ_####_STUD_TAB zu typisieren. Dies wäre aber schlechter
lesbar.
Erstellen Sie nun mithilfe des Arbeitsbereiches fünf Studenten und fügen Sie diese in die
interne Tabelle ein. Beachten Sie den Unterschied zwischen INSERT und APPEND, da es
sich um eine sortierte Tabelle handelt. Geben Sie anschließend in einer Schleife den Inhalt der
Tabelle aus. Achten Sie bitte auf eine lesbare Ausgabe.
Seite 30
Einführung in ABAP
Tipp: Sollten Sie eine Fehlermeldung erhalten, dass zur Tabelle kein gültiger Cursor existiert,
haben sie wahrscheinlich beim INSERT-Befehl INTO statt INTO TABLE geschrieben.
Speichern, prüfen und aktivieren Sie Ihr Programm. Wenn Sie es nun testen, sollte die
Ausgabe ähnlich der folgenden Abbildung sein:
Abbildung 32: Korrigierter Titel: SAP-System-Screenshot
Um die Nutzbarkeit der semantischen Informationen des Datentyps zu demonstrieren, soll

nun eine Komponente der Studenten über einen Parameter gesetzt werden, dessen
Selektionstext aus dem ABAP Dictionary bezogen wird.
Wählen Sie für diese Übung eine ihrer zusätzlichen Komponenten aus. Als Beispiel wird hier
die Komponente Studienfach verwendet, verwenden Sie an den entsprechenden Stellen
stattdessen die von ihnen gewählte Komponente.
Fügen Sie einen Parameter am Beginn der Anwendung (d. h. nach der REPORT-Anweisung)
ein. Dieser soll mit dem Datenelement typisiert werden, mit dem die von Ihnen gewählte
Komponente typisiert ist. Der Name des Datenelements beginnt (wenn die Anweisungen in
dieser Übung befolgt wurden) mit ZZ_####_ST_. Der Parametername kann von Ihnen frei
gewählt werden. Am Beispiel Studienfach könnte die Zeile wie folgt aussehen, wenn es für
das Studienfach ein Datenelement ZZ_####_ST_FACH gibt:
PARAMETERS pa_fach TYPE ZZ_####_ST_FACH.
Ändern Sie das Programm so, dass alle in die interne Tabelle eingefügten Studenten bei der
gewählten Komponente den durch den Parameter gegebenen Wert erhalten. Beim Beispiel
Studienfach würde dies bedeuten, dass alle Studenten das Studienfach erhalten, das durch den
Parameter eingegeben wird. Speichern, prüfen, aktivieren und testen Sie das Programm.
Bisher hat es keinen Selektionstext, so dass der Parametername angezeigt wird:
Seite 31
Einführung in ABAP
Abbildung 33: Oberfläche ohne gepflegten Selektionstext: SAP-System-Screenshot
Um dies zu ändern, beenden Sie das Programm und wählen Sie aus dem Menü den Pfad
Springen -> Textelemente -> Selektionstexte. Geben Sie in diesem Fall aber keinen
Selektionstext ein, sondern lassen Sie diesen aus dem Dictionary laden, indem Sie das
Häkchen in der Spalte Dictionary Referenz setzen. Wenn Sie nun speichern und die
Selektionstexte aktivieren, sehen Sie den aus dem Dictionary geladenen Text:
Abbildung 34: Aus dem ABAP Dictionary geladener Text (Beispiel Studiengang): SAP-System-Screenshot
Kehren Sie nun zu Ihrem Programm zurück und testen Sie das Programm erneut. Sie sehen
nun den aus dem Dictionary geladenen Selektionstext:
Abbildung 35: Oberfläche mit Selektionstext aus dem ABAP Dictionary: SAP-System-Screenshot
Seite 32
Einführung in ABAP
8.3 Tabellen
In einer datenbankorientierten Anwendung nehmen Tabellen eine zentrale Rolle ein. Die
Daten des Systems werden in Tabellen abgelegt, die in ein relationales Datenbanksystem
abgebildet werden. Diese Tabellen sind nicht zu verwechseln mit internen Tabellen: Interne
Tabellen sind lediglich lokale Datenstrukturen auf Anwendungsebene. Die vom
Datenbanksystem unabhängige Beschreibung einer Tabelle im Dictionary wird auch als
transparente Tabelle bezeichnet2 .
Tabellen setzen sich aus Datensätzen (Zeilen) zusammen, die wiederum aus einzelnen Feldern
bestehen. Tabellen sind durch Spalten strukturiert, die einen eindeutigen Namen haben. Ein
oder mehrere Felder einer Tabelle identifizieren die Datensätze eindeutig und werden als
Schlüsselfelder (Primärschlüssel) definiert. Nicht-Schlüsselfelder werden auch
Funktionsfelder genannt:
Abbildung 36: Schlüsselfelder einer Tabelle
Währungsfelder und Felder mit Mengenangaben benötigen eine Einheit. Diese Einheit wird
durch ein sog. Referenzfeld definiert. Die Zuordnung erfolgt zur Laufzeit.
Die Typisierung von Tabellenfeldern kann wie bei Strukturen über Datenelemente
vorgenommen werden, die wiederum für die technischen Eigenschaften auf Domänen
zurückgreifen. Alternativ ist eine direkte Typisierung über die eingebauten Typen möglich.
Verschiedene Felder, die unterschiedliche Datenelemente verwenden, können auf derselben
Domäne basieren, wie dies auch bei den Strukturen der Fall war:
2
Gupta (2011, S.77)
Seite 33
Einführung in ABAP
Abbildung 37: Unterschiedliche Felder, unterschiedliche Datenelemente, selbe Domäne
Ein Beispiel für einen solchen Fall ist die Tabelle SPFLI. Diese ist Teil eines von SAP
vordefinierten Übungsbeispiels mit Flugdaten und enthält Flugverbindungen. Für jede
Flugverbindung sind ein Abflug- und ein Zielflughafen hinterlegt. Technisch sind diese
Angaben gleich, daher verwenden Sie dieselbe Domäne. Semantisch besteht jedoch ein
Unterschied, da z. B. unterschiedliche Selektionstexte benötigt werden. Daher verwenden
beide Felder unterschiedliche Datenelemente.
Hinweis: Die Reihenfolge der Felder im ABAP Dictionary muss nicht immer der im
Datenbanksystem entsprechen. Hierdurch werden aufwändige Umsetzungen (Neuerstellungen
bei Änderungen) von Tabellen vermieden.
8.3.1 Tabellen als Typen
Tabellen des ABAP Dictionary stehen auch selbst, z. B. in ABAP-Programmen zur

Typisierung von Datenobjekten zur Verfügung. Sie sind dabei als Struktur zu verstehen. Das
bedeutet, dass die Deklaration
DATA meinDatenobjekt TYPE SPFLI.
nicht, wie man es erwarten könnte, eine interne Tabelle definiert, sondern einen
Arbeitsbereich, also ein strukturiertes Datenobjekt, dessen Struktur einer Zeile der
Datenbanktabelle SPFLI entspricht.
Soll hingegen eine interne Tabelle mit dem gleichen Aufbau wie die (Datenbank-) Tabelle
SPFLI definiert werden, muss ein Konstrukt mit TABLE OF gewählt werden:
DATA meineInterneTabelle TYPE TABLE OF SPFLI.
8.3.2 Include-Strukturen
Es kann vorkommen, dass der Aufbau einer bestimmten Struktur in mehreren Tabellen oder
auch anderen Strukturen vorkommt. Um in diesen Fällen eine zentrale Wartbarkeit zu
gewährleisten, bietet SAP das Konzept der Include-Strukturen. Hierbei werden die
Komponenten einer Struktur in eine andere Struktur oder in eine Tabelle übernommen.
Seite 34
Einführung in ABAP
Abbildung 38: Eine Struktur als Include in unterschiedlichen Tabellen
In einer Include-Kette darf nur eine Datenbanktabelle vorkommen, das bedeutet, dass eine
Tabelle keine andere Tabelle inkludieren kann. Für Strukturen gelten diese Beschränkungen
nicht, jedoch darf eine Kette (Verschachtelung) von Includes maximal 9 Stufen umfassen3 .
Es ist möglich, Includes Gruppennamen und Suffixes zuzuordnen. Durch einen

Gruppennamen ist die Gruppe als Ganzes über den Gruppennamen erreichbar. Enthält etwa
ein Student eine Adress-Struktur unter der Gruppe ADR, so könnte in einem ABAP-
Programm, in dem ein Student STUD definiert ist, über STUD-ADR die Adresse und über
STUD-ADR-STRASSE z. B. die Straße abgerufen werden. Suffixes ermöglichen es
hingegen, beim mehrfachen Einfügen eines Includes die Eindeutigkeit der
Komponentennamen sicherzustellen, indem der Suffix an die Namen angehängt wird.
8.3.3 Praxis: Übung Tabellenstruktur
Als Beispiel für eine Tabelle soll nun eine Tabelle für Studenten angelegt werden. Rufen Sie
hierzu die Einstiegsmaske des ABAP Dictionary auf und verwenden Sie das Feld
Datenbanktabelle analog zum Vorgehen bei den anderen Dictionary-Elementen zum
Anlegen einer Tabelle mit dem Namen ZZ####_STUDIS.
Abbildung 39: Anlegen einer Datenbanktabelle: SAP-System-Screenshot
Pflegen Sie eine entsprechende Kurzbeschreibung und geben Sie als Auslieferungsklasse A
(Anwendungstab. (Stamm- und Bewegungsdaten)) und für Data
Browser/Tabellenansicht-Pflege den Wert Anzeige/Pflege Erlaubt an. Diese Einstellung ist
wichtig, damit über die entsprechenden Hilfsmittel der ABAP Workbench Daten in die
Tabelle eingefügt werden können. Sollten diese Hilfsmittel im weiteren Kursverlauf einmal
3
Gupta (2011, S. 89)
Seite 35
Einführung in ABAP
bei einer Tabelle ausgegraut sein, sollten Sie daher die hier vorgenommene Pflegeeinstellung
überprüfen.
Wechseln Sie dann zum Karteireiter Felder. Fügen Sie zunächst ein Feld mit dem Namen
MANDT auf Basis des Datenelements MANDT an. Dieses Feld repräsentiert die
Mandantennummer und wird vom System automatisch behandelt. Wählen Sie nun aus dem
Menü den Pfad Bearbeiten -> Include -> Einfügen. Wählen Sie dort die Struktur
ZZ####_STUD und lassen Sie die anderen beiden Felder leer. Die Feldliste sollte nun
folgendermaßen aussehen:
Abbildung 40: Felder der Tabelle: SAP-System-Screenshot
Um den Inhalt des Includes sehen zu können, klicken Sie auf (Include Expandieren). Sie
sehen nun die Komponenten des Includes:
Abbildung 41: Expandiertes Include: SAP-System-Screenshot
Die Tabelle soll in unserem Beispiel aber kein Include sondern gewöhnliche Felder besitzen.
Das Include war nur ein bequemer Weg, diese aus der Struktur zu übernehmen. Um das
Include selbst loszuwerden, klicken Sie es an und wählen Sie im Menü den Pfad
Bearbeiten -> Include -> Komponenten übernehmen. Daraufhin sind die Include-
Komponenten direkt in der Tabelle enthalten.
Die Matrikelnummer wird für den Schlüssel benötigt, da die Mandantennummer allein den
Studenten nicht eindeutig identifizieren kann. Markieren Sie die Zeile mit der
Matrikelnummer, indem Sie auf die Schaltfläche links von der Feldbezeichnung
MATRIKEL klicken. Schneiden Sie die Zeile aus, indem Sie auf die Schaltfläche
(Ausschneiden) klicken. Markieren Sie dann die Zeile Name und klicken Sie auf die
Schaltfläche (Einsetzen). Nun sollte die Zeile mit der Matrikelnummer zwischen der
Mandantennummer-Zeile und der Namens-Zeile stehen. Falls dies nicht funktioniert hat,
wiederholen Sie die Schritte oder löschen Sie im Notfall die Zeilen über wieder und fügen
Sie das Include erneut ein.
Seite 36
Einführung in ABAP
Selektieren Sie auch in der Zeile mit der Matrikelnummer das Häkchen in der Spalte Key, um
dieses Feld dem Schlüssel hinzuzufügen. Die Liste der Felder sollte nun etwa wie folgt
aussehen:
Abbildung 42: Feldliste mit vollständigem Schlüssel
Speichern und prüfen Sie die Tabelle. Eine Aktivierung ist an dieser Stelle noch nicht
möglich, da die technischen Einstellungen fehlen.
8.3.4 Technische Einstellungen
Bei der Definition einer Tabelle sind einige technische Einstellungen vorzunehmen, die für
Optimierungen verwendet werden. Diese Einstellungen erreichen Sie unter
Springen->Technische Einstellungen.
Abbildung 43: Technische Einstellungen einer Tabelle: SAP-System-Screenshot
Seite 37
Einführung in ABAP
8.3.4.1 Logische Speicher-Parameter

8.3.4.1.1 Datenart
Die Angabe der Datenart wirkt sich nur bei Oracle- und Informix-Datenbanken aus. Hier
bestimmt sie, in welchem physischen Bereich der Datenbank die Tabelle abgelegt wird.
Hierbei stehen einige Ausprägungen zur Auswahl, die Sie sich mithilfe der F4-Hilfe anzeigen
lassen können. Die wichtigsten Datenarten sind4 :
 APPL0: Stammdaten, also selten geänderte Daten, etwa Adressen von Kunden.
 APPL1: Bewegungsdaten, also Daten, die häufigen Änderungen unterliegen, etwa
Lagerbestände von Produkten.
 APPL2: Organisationsdaten, die im Rahmen des Customizing bei der
Systemeinstellung angegeben werden und sich danach selten ändern, z. B. die
Mandantentabelle.
 USER: Daten für Entwicklungen des Kunden.
8.3.4.1.2 Größenkategorie
Die Größenkategorie gibt an, wie viele Datensätze für die Tabelle erwartet werden. Diese
Angabe ist wichtig, um Fragmentierung zu verringern. Fragmentierung entsteht, wenn der
Speicherbereich, der beim Anlegen einer Tabelle für diese reserviert wird (Initial Extent),
nicht mehr ausreicht und ein zusätzlicher Speicherbereich zugeordnet werden muss, so dass
verschiedene über den Speicher verteilte Fragmente entstehen:
Abbildung 44: Beispiel für Fragmentierung
Fragmentierung entsteht besonders häufig bei Bewegungsdaten und Tabellen mit schnellem
Wachstum oder häufigen Änderungen. Das Ergebnis sind Performanceprobleme.
Der beim Anlegen einer Tabelle zugewiesene Speicherbereich wird als Initial Extent
bezeichnet, die folgenden Speicherbereiche als First Extent, Second Extent usw.
4
Gupta (2011, S. 114)
Seite 38
Einführung in ABAP
Die Größe des Initial Extent ist bei allen Größenkategorien gleich. Die Größe der weiteren
Extents ist hingegen für jede der Größenkategorien unterschiedlich und hängt auch vom
verwendeten Datenbanksystem ab.
Fragmentierte Indizes können durch Löschen und neu Anlegen defragmentiert werden.
Fragmentierte Tabellen müssen hingegen umgesetzt werden. Umsetzen bedeutet, dass die
Tabelle gelöscht und neu angelegt wird (das Löschen geschieht nach dem neu Anlegen).
Sowohl das Umsetzen von Tabellen als auch das Wiederanlegen gelöschter Indizes stellt
einen hohen Aufwand dar und sollte daher nicht zu Zeiten durchgeführt werden, in denen
viele Zugriffe auf das System erfolgen. Während des Umsetzvorgangs kann auf eine Tabelle
nicht zugegriffen werden.
Zu große Extents führen zu einer Verschwendung von Speicherplatz, so dass Sie die
Größenkategorie gewissenhaft wählen sollten. Es stehen neun Kategorien zur Auswahl, wie
die Werthilfe zeigt:
Abbildung 45: Größenkategorien: SAP-System-Screenshot
8.3.4.2 Tabellenpufferung
Die Tabellenpufferung ist eine Zwischenspeicherung im Anwendungsserver, die die

Kommunikation mit der Datenbank entlasten soll. Die Pufferung kann nicht für alle
Datenbankzugriffe genutzt werden, z. B. nicht für Anfragen mit Aggregatfunktionen (siehe
Abschnitt 8.4.3). Der Zugriff auf den Puffer erfolgt vom Anwender unbemerkt über die
Datenbankschnittstelle. Dieser Puffer des SAP-Systems im Anwendungsserver arbeitet
unabhängig von etwaigen Puffern des Datenbanksystems auf DB-Ebene. Administratoren mit
entsprechender Berechtigung können über das Kommando /$TAB die Puffer zurücksetzen,
wenn es zu Inkonsistenzen gekommen ist. Eine solche Rücksetzung kann mehrere Stunden
dauern und wirkt sich während dieser Zeit sehr negativ auf die Systemperformance aus.
Seite 39
Einführung in ABAP
Abbildung 46: Puffer
Es werden drei Arten der Pufferung unterschieden. Diese werden in Abschnitt 8.9 erläutert, da
Sie für das Verständnis zunächst Zugriffe auf Datensätze erlernen müssen.
8.3.4.3 Protokollierung
Die Protokollierung wird eingesetzt, um Änderungen an Datenbanktabellen aufzuzeichnen.

Voraussetzung ist außer dem Setzen der Eigenschaft in den Tabelleneigenschaften das Setzen
des Profilparameters „rec/client“.
Mögliche Einstellungen sind5 :
 rec/client = ALL, um alle Mandanten zu protokollieren

 rec/client = 000, [], []… um nur bestimmte Mandanten zu protokollieren
 rec/client = OFF, um die Protokollierung vollständig zu deaktivieren
Die Protokollierung sollte nur eingeschaltet werden, wenn sie unbedingt benötigt wird, da sie
sehr viel Last auf der Datenbank erzeugt. Zum einen muss für jede Schreiboperation ein
Datensatz in der Protokolltabelle angelegt werden, zum anderen greifen auf die
Protokolltabelle viele Nutzer zu, so dass es durch die erforderlichen Sperren zu Wartezeiten
kommen kann, unabhängig davon auf welche konkreten Tabellen die Benutzer zugreifen.
Hinweis: Das Thema Sperren wird in einem späteren Kursteil noch ausführlich behandelt.
8.3.5 Praxis: Übung Technische Einstellungen
In dieser Übung sollen die technischen Einstellungen der Tabelle ZZ####_STUDIS

vorgenommen werden. Wählen Sie hierzu von der Tabelle aus den Menüpfad Springen ->
Technische Einstellungen. Geben Sie dort als Datenart APPL0 (Stammdaten) aus, sowie die
5
Gupta (2011, S. 120)
Seite 40
Einführung in ABAP
Größenkategorie 0. Die Daten sollen nicht gepuffert und Änderungen nicht protokolliert
werden.
Abbildung 47: Technische Einstellungen der Studenten-Tabelle: SAP-System-Screenshot
Speichern Sie die technischen Einstellungen und kehren Sie zur Tabelle zurück. Aktivieren
Sie nun die Tabelle. Ignorieren Sie wie üblich die Warnung zur Erweiterungskategorie (dieses
Thema wird später aufgegriffen).
Seite 41
Einführung in ABAP
8.4 Tabellenzugriff aus ABAP-Programmen

Der Zugriff auf die Tabellen erfolgt aber in aller Regel nicht direkt, sondern über das ABAP
Dictionary als Schnittstelle. Es sind aber auch direkte Zugriffe möglich. Es wird hier
zwischen Open SQL und Native SQL unterschieden.
Native SQL ermöglicht die Nutzung spezifischer Befehle des zugrundeliegenden

Datenbanksystems. Der Sprachumfang ist also vom verwendeten Datenbanksystem abhängig.
Ein Wechsel des Datenbanksystems zieht ggf. Anpassungen des Codes nach sich. Der Vorteil
liegt darin, dass datenbankspezifische Features genutzt werden können.
Open SQL ist hingegen ein vom konkreten Datenbanksystem unabhängiger Standard. Es
können damit nicht alle spezifischen Features einzelner Datenbanksysteme genutzt werden –
möglicherweise werden Sie das ein oder andere Feature vermissen. Die
Datenbankschnittstelle übersetzt die Open SQL-Befehle in das native SQL des jeweiligen
Datenbanksystems.
Im Folgenden wird ihnen auch Native SQL kurz vorgestellt, der Schwerpunkt liegt aber auf
Open SQL, da diese Zugriffsart für den Rest des Kurses verwendet wird und auch für die
Praxis wesentlich relevanter ist. Benutzen Sie in Ihren Programmen nur Open SQL.
8.4.1 Native SQL
Um auf spezifische Funktionalitäten des verwendeten Datenbankmanagementsystems

zugreifen zu können, kann die Native SQL-Schnittstelle des ABAP-Systems verwendet
werden. Diese stellt im Programmcode ein Gerüst bereit, innerhalb dessen die spezifischen
Befehle des Datenbankmanagementsystems verwendet werden können, diese stellen aber
keine Sprachelemente von ABAP dar. ABAP bietet aber einige Sprachelemente innerhalb von
Native SQL, um die Verbindung zwischen SQL und dem umgebenden Code zu ermöglichen.
Die verwendeten Tabellen müssen nicht im ABAP Dictionary deklariert werden. Es genügt,
wenn diese im Datenbanksystem existieren.
Die Syntax zur Einbindung von Native SQL lautet:

EXEC SQL.
...
ENDEXEC.
Im durch die drei Punkte gekennzeichneten Bereich können nun Native SQL-Anweisungen
verwendet werden. Dieser Bereich wird nicht vollständig von der Syntaxprüfung untersucht,
da er der Syntax des jeweiligen Datenbankmanagementsystems unterliegt.
Die SQL-Anweisungen werden größtenteils unverändert an das Datenbanksystem übermittelt.

Eine Ausnahme stellen Hostvariablen dar. Dies sind Variablen des umgebenden ABAP-
Codes, die innerhalb der SQL-Anweisungen verwendet werden, um Daten an die Datenbank
zu übergeben oder Ergebnisse einer Anfrage aufzunehmen. Sie werden im Native SQL-Code
gekennzeichnet, indem ihnen ein Doppelpunkt vorangestellt wird.
Seite 42
Einführung in ABAP
Ein Beispiel ist der folgende Code:
PARAMETERS p_carrid TYPE s_carr_id.

DATA carrname TYPE s_carrname.
EXEC SQL.
SELECT carrname FROM scarr INTO :carrname WHERE carrid = :p_carrid
ENDEXEC.
WRITE carrname.
Hier wird eine Variable (carrname) und ein Parameter (p_carrid) des umgebenden ABAP-
Programms innerhalb von Native SQL verwendet. Das Programm gibt zu einem Kürzel den
vollen Namen einer Fluggesellschaft aus.
8.4.2 Open SQL
Open SQL ist die Teilmenge der ABAP-Befehle, die den Zugriff auf die zentrale Datenbank
des ABAP-Systems ermöglicht. Das ABAP-System wandelt die Befehle in
datenbankspezifische Befehle um. Der Vorteil ist, dass die Anwendungen, die auf die
Datenbank zugreifen, nicht geändert werden müssen, wenn das im System verwendete
Datenbankmanagementsystem gewechselt wird. Der Nachteil ist, dass datenbankspezifische
Erweiterungen nicht nutzbar sind, so dass nicht alle Anfragen, die Sie ggf. aus anderen
Systemen gewohnt sind, möglich sind. Es können aber auch Views verwendet werden, die im
ABAP Dictionary definiert wurden.
Zu Open SQL gehören die folgenden Operationen:
 SELECT
 OPEN CURSOR, FETCH, CLOSE CURSOR
 INSERT
 UPDATE
 MODIFY
 DELETE
Hinzu kommen Operationen zur Konsistenzsicherung, die Ihnen später separat vorgestellt
werden.
Die Operationen werden im Folgenden vorgestellt. Kursteilnehmer, die bereits über

Kenntnisse in herkömmlichem SQL verfügen, werden zahlreiche Konzepte wiedererkennen.
Derartige Vorkenntnisse sind für diesen Kurs aber nicht zwingend erforderlich, außerdem gibt
es verschiedene Unterschiede zwischen herkömmlichem SQL und Open SQL.
8.4.3 Auslesen von Daten
Durch die SELECT-Anweisung werden Daten aus einer Tabelle bzw. mehreren Tabellen
und/oder Views ausgelesen.
Die folgende Darstellung veranschaulicht, wie ein lesender Zugriff allgemein aufgebaut ist:
Seite 43
Einführung in ABAP
Abbildung 48: Aufbau einer lesenden Anfrage (Überblick)
 Im SELECT-Teil werden vor allem die Spalten angegeben, die im Ergebnis enthalten
sein sollen. Weiterhin sind hier Aggregatfunktionen möglich.
 Im FROM-Teil wird angegeben, woher diese Daten stammen. Hier können entweder
eine oder mehrere über Joins verbundene Tabellen oder Views angegeben werden.
 Im INTO-Teil wird angegeben, wohin die Daten transportiert werden sollen. Hier
stehen also Datenobjekte des ABAP-Programms, die die Ergebnisse aufnehmen
sollen.
 Im WHERE-Teil werden logische Bedingungen angegeben, um die Menge der

Datensätze einzuschränken.
 Es sind weitere Bestandteile einer Anfrage möglich, diese werden Ihnen im Weiteren
noch näher gebracht. Die hier dargestellte Form soll lediglich einen ersten Überblick
vermitteln, insbesondere falls Sie keine SQL-Vorkenntnisse besitzen.
Die syntaktischen Varianten der SELECT-Anweisung sind vielfältig, weshalb Ihnen die
Anwendung der Anweisung zunächst anhand von Beispielen vermittelt wird.
8.4.3.1 Der Arbeitsbereich für Datenbanktabellen
Dass Tabellen als Typen benutzt werden können, haben Sie bereits in Abschnitt 8.3.1
erfahren. Diese Eigenschaft ist sehr nützlich bei der Arbeit mit Open SQL, da so sehr bequem
ein Arbeitsbereich definiert werden kann. Dieser kann dann einen einzelnen Eintrag der
Datenbanktabelle aufnehmen, so wie Sie es bereits von der Arbeit mit internen Tabellen
kennen. Es gibt hier jedoch ein paar Einschränkungen. Der Datentyp des Arbeitsbereichs darf
nicht tief sein (Strings sind aber erlaubt) und muss mindestens so lang sein wie die Struktur
der Datenbanktabelle. Wie zuvor erläutert wird ein Typ als tief bezeichnet, wenn der Inhalt
seiner Datenobjekte Referenzen sind, die auf den tatsächlichen Inhalt verweisen. Darunter
fallen Strings, Referenzvariablen und interne Tabellen sowie Strukturen, die mindestens eine
tiefe Komponente enthalten.
Im einfachsten Fall hat der Arbeitsbereich die gleiche Struktur wie die Datenbanktabelle.
Durch die Verwendung der Tabelle für die Typdefinition müssen nicht alle Komponenten
explizit angegeben werden, und der Arbeitsbereich ist robust gegen Erweiterungen der
Datenbankstruktur (hier zeigt sich erneut der Vorteil der zentralen Typpflege im Dictionary).
Ein Beispiel könnte wie folgt aussehen:

DATA wa TYPE spfli.
Hier ist spfli der Name einer Datenbanktabelle. Mit wa wird keine interne Tabelle
definiert, sondern ein zeilenartiges Datenobjekt. Jede Datenbanktabelle stellt also durch ihre
Spaltendefinitionen auch einen Zeilentyp dar, so dass wie hier ein Arbeitsbereich definiert
Seite 44
Einführung in ABAP
werden kann, in den später eine Zeile der Datenbanktabelle, hier spfli, gelesen werden
kann.
Wäre spfli hingegen ein tabellenartiger Typ (entweder lokal über TYPES … TYPE
TABLE OF … oder durch Definition eines globalen Typen im Dictionary), würde es sich bei
wa um eine interne Tabelle handeln. In diesem Fall wäre der Name wa allerdings sehr
unglücklich gewählt. Mit der LINE OF tabellentyp-Syntax könnte aber ein Zeilentyp
gebildet werden.
In den folgenden Beispielen wird angenommen, dass wie oben ein Arbeitsbereich mit dem
Namen wa definiert wurde, der zur im FROM-Teil angegebenen Tabelle passt.
8.4.3.2 Lesen eines einzelnen Datensatzes
Durch folgenden Code wird ein einzelner Datensatz ausgelesen:
SELECT SINGLE *
FROM spfli
INTO wa
WHERE carrid = 'LH' AND connid = '0400'.
Die Angabe von SELECT SINGLE dient dazu, nur einen Datensatz aus der Tabelle zu lesen.
Um den Datensatz zu identifizieren, muss der vollständige Schlüssel im WHERE-Teil
angegeben werden. Dies ist syntaktisch allerdings nicht zwingend nötig, so würde bei einem
unvollständigen Schlüssel schlicht ein beliebiger Datensatz gefunden, der zur angegebenen
Bedingung passt. Eine Ausnahme stellt lediglich das Mandantenfeld dar: Aufgrund der
Vielzahl von Tabellen, die das Mandantenfeld enthalten, muss dieses nicht angegeben
werden. Es wird stattdessen automatisch mit dem aktuellen Mandanten belegt wenn es
existiert. Soll es hingegen explizit angegeben werden, muss der SELECT-Befehl den Zusatz
CLIENT SPECIFIED erhalten.
Der INTO-Teil dient der Angabe des Datenobjekts, in das das Ergebnis abgelegt werden soll.
Dieser muss linksbündig so strukturiert sein wie die Tabelle oder die Feldermenge im
SELECT-Teil.
Das erfolgreiche Lesen eines Datensatzes können Sie anhand des Systemfelds sy-subrc
abfragen: Bei erfolgreichem Lesen hat dieses den Wert 0.
Sowohl die Spalten im SELECT-Teil als auch die Felder im INTO-Teil können Explizit
angegeben werden, wie die folgenden Beispiele zeigen. Hier wurde hingegen darauf
verzichtet und durch den Stern alle Spalten der Ergebnismenge übernommen. Da die Daten in
diesem Fall nur aus einer Tabelle stammen, enthält das Ergebnis also alle Spalten dieser
Tabelle. Da der Arbeitsbereich mit der Tabelle typisiert ist, ist die Bedingung der linksbündig
gleichen Struktur also auf jeden Fall erfüllt.
Seite 45
Einführung in ABAP
8.4.3.2.1 Explizite Angabe der Spalten
DATA: BEGIN OF wa,
carrier TYPE spfli-carrid,
connection TYPE spfli-connid,
from TYPE spfli-cityfrom,
to TYPE spfli-cityto,
END OF wa.
SELECT SINGLE carrid connid cityfrom cityto
FROM spfli
INTO wa
In diesem Beispiel wird ein Arbeitsbereich aufgebaut, der nicht genau dem Aufbau der
Datenbanktabelle entspricht. Seine einzelnen Felder haben andere Namen als die Felder in der
Datenbank, sind aber passend typisiert. In der Anfrage werden nur vier Spalten der Datenbank
angegeben und auch nur diese vier übertragen. Die Reihenfolge muss hierbei übereinstimmen.
Die folgende Abbildung veranschaulicht die obige Anfrage grafisch:
Abbildung 49: Veranschaulichung der Anfrage
Seite 46
Einführung in ABAP
8.4.3.2.2 Explizite Angabe der Zielfelder
Im vorangegangenen Beispiel stimmte die Reihenfolge der Zielfelder und der Felder der
Ergebnismenge überein. Es ist jedoch auch möglich, hier eine manuelle Zuordnung
vorzunehmen. Der folgende Code zeigt ein Beispiel:
DATA: BEGIN OF wa,
connection TYPE spfli-connid,
carrier TYPE spfli-carrid,
from TYPE spfli-cityfrom,
to TYPE spfli-cityto,
END OF wa.
SELECT SINGLE carrid connid cityfrom cityto
FROM spfli
INTO (wa-carrier, wa-connection, wa-from, wa-to)
Im Gegensatz zum vorangegangenen Code sind die ersten beiden Felder in umgekehrter
Reihenfolge. Die einzelnen Spalten werden hier getrennt an die explizit angegebenen
Variablen übergeben. In diesem Fall sind alle Variablen Felder des Arbeitsbereiches. Es wäre
aber auch möglich hier andere Variablen anzugeben, die einzelne Felder aufnehmen sollen.
Die folgende Abbildung veranschaulicht diese Anfrage:
Seite 47
Einführung in ABAP
Abbildung 50: Explizite Angabe der Zielfelder
8.4.3.2.3 Automatische Zuordnung zu Feldern der Zielstruktur
In vielen Situationen werden Sie einen Arbeitsbereich haben, in dem die Felder nicht wie im
vorausgegangenen Beispiel andere Namen besitzen als die entsprechenden Felder der
Datenbank. In diesem Fall können Sie sich die explizite Feldzuordnung sparen. Das System
kann die Felder automatisch den Namensgleichen zuordnen, indem Sie den Zusatz INTO
CORRESPONDING FIELDS OF verwenden. Der folgende Code zeigt ein Beispiel:
DATA wa TYPE spfli.
SELECT SINGLE cityfrom cityto
FROM spfli
INTO CORRESPONDING FIELDS OF wa
Hier werden die gelesenen Spalten den namensgleichen Feldern des Arbeitsbereiches
zugewiesen. Die Reihenfolge spielt daher in diesem Fall keine Rolle, die Typen sollten aber
übereinstimmen. Der Vorteil dieser Variante ist die Robustheit gegen Änderungen: Eine
Erweiterung oder Reihenfolgeänderung der Zielstruktur erfordert keine Änderung des Open
SQL-Codes. Die Abbildung veranschaulicht die Anfrage:
Seite 48
Einführung in ABAP
Abbildung 51: Beispiel für Namensbasierte Feldzuordnung
8.4.4 Lesen mehrerer Datensätze
In vielen Fällen soll nicht wie in den bisherigen Beispielen nur ein Datensatz, sondern
potentiell mehrere Datensätze aus der Tabelle ausgelesen werden. Dazu gibt es grundsätzlich
zwei Varianten: Zum einen können die Datensätze in eine interne Tabelle geladen werden,
zum anderen können sie nacheinander in den Arbeitsbereich geladen und verarbeitet werden.
Diese beiden Varianten unterscheiden sich deutlich, da in einem Fall aus SELECT ein
Schleifenkonstrukt wird. Beide Varianten werden Ihnen im Folgenden vorgestellt:
8.4.4.1 Lesen in eine interne Tabelle
Die Möglichkeit, mehrere Datensätze über eine einzelne SELECT-Anweisung in eine interne
Tabelle zu laden, wird auch als Array Fetch bezeichnet.
Seite 49
Einführung in ABAP
Abbildung 52: Der Array Fetch
Für den Array Fetch muss das Ziel per INTO TABLE angegeben werden, wie in folgendem
Beispiel:
DATA itab TYPE TABLE OF spfli.
SELECT *
FROM spfli
INTO TABLE itab
WHERE carrid = 'LH'.
In diesem Beispiel werden alle Flugverbindungen der Lufthansa in die interne Tabelle
gelesen. Beachten Sie, dass hier der Schlüssel unvollständig ist.
Der Array Fetch wird als Zugriffstechnik empfohlen, da er effizient ist. Datensätze können
hier blockweise aus der Datenbank geladen werden. Die Struktur der internen Tabelle muss
wie die des Arbeitsbereichs bei den Einzelsatzabfragen zur Datenbanktabelle passen, d. h.
linksbündig wie die Spaltenliste aufgebaut sein. Andernfalls kann das Konstrukt INTO
CORRESPONDING FIELDS OF TABLE verwendet werden, das analog zu INTO
CORRESPONDING FIELDS arbeitet. Die gleichnamigen Spalten sollten auch hier den
gleichen Typ haben, da ansonsten aufwändige Konvertierungen erforderlich sind.
Durch die Angabe von APPENDING statt INTO wird verhindert, dass bereits vorhandene
Daten der Tabelle gelöscht werden.
Seite 50
Einführung in ABAP
8.4.4.2 Lesen in einen Arbeitsbereich – SELECT als Schleifenkonstrukt
Wird kein Array Fetch eingesetzt, funktioniert SELECT wie eine Schleife, die nacheinander
die Datensätze aus der Datenbanktabelle in den Arbeitsbereich (oder die explizit angegebenen
Felder) lädt.
Abbildung 53: SELECT als Schleifenkonstrukt
Den Kopf der Schleife stellt die SELECT-Anweisung selbst dar. Das Ende der Schleife wird
hierbei durch die Anweisung ENDSELECT markiert. Der folgende Code stellt ein Beispiel
dar:
DATA wa TYPE spfli.
SELECT *
FROM spfli
INTO wa
WHERE carrid = 'LH'.
" Hier würden Anweisungen stehen, die etwas mit dem
" jeweiligen eintrag tun
ENDSELECT.
Vorsicht: Beachten Sie, dass die ENDSELECT-Anweisung nur für diesen speziellen Fall des
schleifenartigen Auslesens der Daten benötigt wird. Insbesondere der Array Fetch benötigt
Seite 51
Einführung in ABAP
kein ENDSELECT. Wenn Sie also Daten in eine interne Tabelle lesen möchten, aber einen
Syntaxfehler erhalten, der besagt, dass ENDSELECT fehlt, haben Sie wahrscheinlich den Teil
INTO TABLE vergessen.
Die Datensätze werden von der Datenbankschnittstelle paketweise gelesen, aber einzeln dem
Arbeitsbereich zugewiesen. Nach dem letzten Datensatz wird die Schleife verlassen und die
Anzahl gelesener Datensätze kann über das Systemfeld sy-dbcnt ermittelt werden. sy-
subrc hat den Wert 0, sofern mindestens ein Datensatz gelesen wurde. Diese beiden
Systemfelder stehen auch beim Array Fetch zur Verfügung.
8.4.5 Praxis: Übung zur Ausgabe von Tabelleninhalten
Die Tabelle SPFLI kennen Sie bereits aus der Übung zum Data Browser und zu den Views.
Wenn Sie noch nicht ganz vertraut mit allen Spalten der Tabelle sind, schauen Sie sich die
Tabellenstruktur im ABAP Dictionary an.
In dieser Übung soll ein Programm entstehen, das die Inhalte dieser Tabelle ausgibt.
Wechseln Sie nun in den Object Navigator und legen Sie in Ihrem Paket ZZ_#### das neue
Programm ZZ_####_FLUEGE an. Der Status dieses Programms soll erneut Testprogramm
sein. Verwenden Sie wie üblich ihren Transportauftrag.
Erstellen Sie in Ihrem Programm einen passenden Arbeitsbereich wa. Als Typ können Sie
spfli verwenden. Hier macht sich das ABAP Dictionary bezahlt, da Sie so in ihren
Datenfeldern die Struktur der Tabelle übernehmen können. Beachten Sie dass hier keine
interne Tabelle, sondern eine Struktur entsteht.
Als nächstes müssen die Daten aus der Datenbanktabelle SPFLI ausgelesen werden.
Verwenden Sie hierzu den SELECT-Befehl. Da es sich um mehrere Flüge handelt, benötigen
Sie hier die Schleifenform des Befehls mit ENDSELECT. Im Körper der Schleife geben Sie
das Kürzel der Fluggesellschaft, die Flugnummer sowie für Abflug und Ziel Land und Stadt
aus.
Ihr Code könnte in diesem Bereich nun etwa wie folgt aussehen. Beachten Sie, dass der
Schrägstrich eine neue Zeile beginnt:
Figure 54: SELECT-Schleife: SAP-System-Screenshot
Speichern, prüfen und aktivieren Sie ihr Programm. Die Ausgabe sollte wie folgt aussehen:
Seite 52
Einführung in ABAP
Abbildung 55: Programmausgabe: SAP-System-Screenshot
Es zeigt sich auch hier der Vorteil, dass Feldlängen nicht nur als Begrenzung für die
gespeicherten Werte verwendet werden, sondern auch bei der Anzeige berücksichtigt werden.
Hierdurch stehen die Daten in der Ausgabe sauber untereinander.
Wie Sie zuvor im Rahmen des Open SQL-Abschnitts erfahren haben, ist es möglich, Inhalte
von Datenbanktabellen blockweise oder komplett in interne Tabellen zu laden (Array Fetch).
Ein Grund für dieses Verfahren ist die unterschiedliche Zugriffsgeschwindigkeit. Auf die
Zeilen der internen Tabelle kann erheblich schneller zugegriffen werden als auf die
Datenbank. Daher werden Sie Ihr Programm nun so ändern, dass die Daten zunächst in eine
interne Tabelle geladen werden und später über eine LOOP-Schleife ausgegeben werden.
Erstellen Sie in Ihrem Programm dazu eine interne Tabelle itab vom Typ TABLE OF
spfli.
Kommentieren Sie die vorhandene SELECT-Schleife vollständig aus, indem Sie doppelte
Anführungszeichen ( " ) an den Beginn der Zeilen setzen.
Ergänzen Sie stattdessen eine SELECT-Anfrage als array fetch, die alle Einträge auf einmal in
Ihre interne Tabelle lädt. Diese SELECT-Anfrage besitzt kein ENDSELECT, da hier keine
einzelnen Sätze verarbeitet werden. Wenn Sie über die Syntax unsicher sind, blättern Sie bitte
entsprechend zurück.
Da die Ausgabe nun nicht mehr innerhalb des Selects geschieht, benötigen Sie eine eigene
Schleife. Erstellen Sie hierzu eine LOOP-Schleife, die in jeder Iteration eine Zeile der internen
Tabelle in den Arbeitsbereich wa speichert. Geben Sie diesen mit den WRITE-Befehlen, die
Sie zuvor in der Selectschleife benutzt haben, im Körper der neuen Schleife aus.
Speichern, prüfen und aktivieren Sie Ihr Programm nun und testen Sie es. Die Ausgabe sollte
noch immer wie zuvor aussehen.
Als nächstes soll Ihr Programm so überarbeitet werden, dass nicht alle Flüge, sondern nur die
Flüge einer bestimmten Fluggesellschaft ausgegeben werden. Diese Auswahl soll durch den
Benutzer auf einem entsprechenden Selektionsbildschirm vorgenommen werden können.
Fügen Sie hierfür einen Parameter pa_carr in Ihr Programm ein. Als Typ verwenden Sie
spfli-carrid.
Verwenden Sie den Parameter dann in einem WHERE-Teil Ihres SELECT-Befehls.
Speichern, prüfen und aktivieren Sie Ihr Programm. Es hat nun einen Selektionsbildschirm:
Seite 53
Einführung in ABAP
Abbildung 56: Selektionsbildschirm: SAP-System-Screenshot
Für den Selektionsbildschirm sollte der Selektionstext des Parameters angepasst werden.
Verwenden Sie hierfür den Menüpfad Springen -> Textelemente -> Selektionstexte. Sie
haben erneut den Vorteil, dass der Typ des Parameters aus dem ABAP Dictionary stammt.
Hierdurch können Sie den dort vorgegebenen Selektionstext einfach übernehmen, indem Sie
den Haken in der Spalte Dictionary setzen und mit Enter bestätigen.
Speichern, prüfen und aktivieren Sie nun das Programm und aktivieren Sie hierbei auch den
geänderten Selektionstext.
Abbildung 57: Selektionsbildschirm: SAP-System-Screenshot
SAP empfiehlt, Datenbankaufrufe in Reuse-Komponenten (wiederverwendbaren

Modularisierungseinheiten) zu kapseln. Dies soll nun anhand eines Funktionsbausteins
durchgeführt werden.
Legen Sie in Ihrer Funktionsgruppe ZZ_####_FGR einen neuen Funktionsbaustein

Z_####_GET_FLUEGE an.
Abbildung 58: Anlegen eines Funktionsbausteins: SAP-System-Screenshot
Fügen Sie einen Importparameter ein, der das Kürzel der Fluggesellschaft entgegennimmt:
Seite 54
Einführung in ABAP
Abbildung 59: Import-Parameter des Funktionsbausteins: SAP-System-Screenshot
Für die Rückgabe der Flüge fehlt Ihnen noch ein geeigneter Tabellentyp. Öffnen Sie das Data
Dictionary in einem neuen Modus (über oder das Voranstellen von „/o“ im
Kommandofeld links oben. Hinweis: Durch F1 im Kommandofeld können Sie sich weitere
Eingabemöglichkeiten für dieses Feld anzeigen lassen, etwa zum Beenden von Modi). Legen
Sie dort einen neuen Tabellentypen ZZ_####_FLISTE an. Pflegen Sie eine passende
Kurzbeschreibung, geben Sie als Zeilentyp SPFLI an und speichern Sie.
Abbildung 60: Der Tabellentyp auf Basis von SPFLI: SAP-System-Screenshot
Prüfen und aktivieren Sie den Tabellentyp und wechseln Sie dann wieder zum Modus mit
Ihrem Funktionsbaustein. Geben Sie den Tabellentypen dort als Typ für einen
Exportparameter mit dem Namen EX_LISTE an:
Abbildung 61: Verwendung des Tabellentypen für die Typisierung: SAP-System-Screenshot
Speichern Sie und fügen Sie im Karteireiter Quelltext die SELECT-Anweisung aus Ihrem
Programm ZZ_####_FLUEGE ein. Passen Sie die Namen im INTO- und WHERE-Teil an
die Namen der Parameter des Funktionsbausteins an. Speichern, prüfen und aktivieren Sie
diesen.
Öffnen Sie dann wieder Ihr Programm ZZ_####_FLUEGE. Entfernen Sie dort die SELECT-
Anweisung und ersetzen Sie sie durch den Aufruf des Funktionsbausteins. Am einfachsten
geht dies, indem Sie den Funktionsbaustein aus dem Navigationsbaum des Object Navigators
durch Klicken und Ziehen in den Quelltext Ihres Programms einfügen, oder mithilfe des
Muster-Buttons.
Seite 55
Einführung in ABAP
Ergänzen Sie dort die rechte Seite der Parameterzuordnung durch die Namen des Selektions-
Parameters und der lokalen internen Tabelle und vergessen Sie nicht die auskommentierten
Zeilen für den Export-Parameter wieder einzukommentieren, also die Sterne am Zeilenanfang
zu entfernen. Achten Sie ferner darauf, den Punkt, der den Funktionsbaustein-Aufruf
abschließt, nicht versehentlich zu löschen.
Abbildung 62: Aufruf des Funktionsbausteins : SAP-System-Screenshot
Speichern, prüfen, aktivieren und testen Sie das Programm. Die Ausgabe sollte sich nicht von
der vor der Verwendung des Funktionsbausteins unterscheiden.
Das Programm hat in dieser Form noch einen Nachteil. Wenn eine ungültige Fluggesellschaft
eingegeben wird, oder es zu einer Fluggesellschaft gar keine Flüge gibt, erscheint keine
Ausgabe. Sie sollten daher eine entsprechende Fehlerbehandlung einbauen. Wie Sie wissen,
setzt die SELECT-Anweisung bei Fehlern die Systemvariable sy-subrc auf einen Wert
ungleich 0. Dies lässt sich abfangen, so dass bei einer nicht erfolgreichen Ausführung statt der
Ausführung der Ausgabeschleife eine Fehlermeldung ausgegeben wird.
Öffnen Sie Ihren Funktionsbaustein und definieren Sie im Tab Ausnahmen eine Ausnahme
SQL_ERROR.
Abbildung 63: Neue Ausnahme: SAP-System-Screenshot
Öffnen Sie dann den Quelltext des Funktionsbausteins. Ergänzen Sie nach der
Datenbankanfrage eine IF-Verzweigung (siehe Abschnitt Kontrollstrukturen). Wenn sy-subrc
einen Wert ungleich 0 besitzt, soll die Ausnahme ausgelöst werden. Wie man Ausnahmen
auslöst, haben Sie im vorangegangenen Kursteil gelernt.
Speichern, prüfen und aktivieren Sie den Funktionsbausein. Öffnen Sie dann erneut Ihr
Hauptprogramm. Sie müssen nun noch die Ausnahmebehandlung implementieren. Ergänzen
Sie den EXCEPTIONS-Teil des Funktionsbausteinaufrufs und ordnen Sie der von Ihnen
definierten Ausnahme einen Wert zu, z. B. 5.
Ergänzen Sie dann ein IF-ELSE-Konstukt um die Ausgabe: Wenn sy-subrc den Wert 0
besitzt, soll die LOOP-Schleife ausgeführt werden, andernfalls (wenn es den Wert den Sie
ihrer Ausnahme zugeordnet haben besitzt) soll mit dem WRITE-Befehl eine passende
Fehlermeldung Ihrer Wahl ausgegeben werden.
Seite 56
Einführung in ABAP
Speichern, prüfen und aktivieren Sie Ihr Programm. Wenn Sie in Ihrem Programm auch den
Teil mit der Fehlermeldung testen wollen, geben Sie im Selektionsbildschirm ein Kürzel ein,
das es nicht gibt. In diesem Fall sollte Ihre Fehlermeldung erscheinen. In späteren Kursteilen
erfahren Sie, wie „echte“ Fehlermeldungen des Systems erzeugt werden können. Die direkte
Ausgabe ist hier nur zur Vereinfachung verwendet worden.
Abbildung 64: Ausgabe einer einfachen Fehlermeldung: SAP-System-Screenshot
Sie haben jetzt ein Programm geschrieben, das Daten aus einer Datenbank über einen
Funktionsbaustein ausliest und diese ausgibt. Sie haben dabei vorgegebene Datenelemente
genutzt, um automatisch den Selektionstext zu bestimmen, und die vorgegebene Suchhilfe
genutzt. Sie haben auf sy-subrc zugegriffen, um festzustellen, ob eine Datenbankanfrage
erfolgreich war. Außerdem wurden Ausnahmen erneut verwendet.
8.4.6 Die SELECT-Anweisung im Detail
Die Syntax der SELECT-Anweisung ist insgesamt recht komplex und lässt sich wie folgt (und
in den Unterkapiteln näher ausgeführt) angeben6 , wobei einige Teile der Syntax noch einer
näheren Beschreibung bedürfen:
SELECT result
FROM source
INTO|APPENDING target
[[FOR ALL ENTRIES IN itab] WHERE cond]
[GROUP BY cols] [HAVING group_cond]
[ORDER BY sort_args].
...
[ENDSELECT.]
Die Ergebnismenge wird aus den in source angegebenen Tabellen entsprechend der in
result angegebenen Struktur ausgelesen und in target gespeichert. GROUP BY cols
verdichtet mehrere Zeilen anhand gleicher Werte der angegebenen Spalten. HAVING
group_cond schränkt verdichtete Zeilen ein. WHERE cond schränkt die Ergebnismenge
ein. ORDER BY sort_args sorgt für die Sortierung der Ergebnisse.
6
Keller (2012, S. 1064)
Seite 57
Einführung in ABAP
8.4.6.1 Der SELECT-Teil
Die Syntax von result besteht aus lines und columns.
Die Syntax von lines lautet:
... { SINGLE [FOR UPDATE] }

| [DISTINCT] ...
Durch SINGLE wird festgelegt, dass die Ergebnismenge nur eine Zeile enthalten soll. Wenn
der restliche Teil der Anfrage mehr als eine Zeile liefert, wird nur die erste dieser Zeilen
geliefert. Es wird in diesem Fall kein ENDSELECT mehr benötigt, da keine Iteration über
mehrere Ergebniseinträge stattfindet.
FOR UPDATE dient dem Setzen einer Schreibsperre für die betrachtete Zeile in der
Datenbank.
Beim Lesen mehrerer Zeilen können mit DISTINCT doppelte Zeilen aus dem Ergebnis
entfernt werden.
Die Sytax von columns lautet7 :
... *
| {
[ src1~* ] [ src2~* ] …
{ col1 | agg( [DISTINCT] col1) } [AS a1]
{ col2 | agg( [DISTINCT] col2) } [AS a2] ...
}
| (column_syntax) ...
Statische Spaltenangabe
Bei Angabe des Sterns werden alle Spalten in das Ergebnis übernommen. Werden mehrere
Tabellen in der FROM-Klausel verwendet (s. u.), entstehen hierdurch mehrere gleichnamige
Spalten in der Ergebnismenge. Um dies zu verhindern, kann seit Release 7.40 SP08 auch
src1~* angegeben werden. Hierbei steht src1 für eine bestimmte der Tabellen oder Views,
die im FROM-Teil verwendet werden, und deren Spalten alle eingebunden werden sollen.
Alternativ dazu können einzelne Spalten (col1, col2, ...) angegeben werden. Dies
kann entweder direkt geschehen oder unter Verwendung einer Aggregatfunktion, die in obiger
Syntax als agg dargestellt ist. Durch den Zusatz AS kann bei dieser statischen Spaltenangabe
ein alternativer Name angegeben werden, den die Spalte in der Ergebnismenge erhalten soll.
Die Umbenennung der Spalten wirkt sich auch auf die Zusätze INTO / APPENDING
CORRESPONDING FIELDS und ORDER BY aus. Der neue Name a1 darf maximal 14
Stellen besitzen.
Die Bezeichnung der Spalte muss eindeutig sein. Kommt der gleiche Spaltenname in
mehreren der in FROM verwendeten Tabellen vor, muss der Tabellenname mit angegeben
werden. Als Trennzeichen wird die Tilde (~) verwendet.
7
Keller (2012, S. 1068)
Seite 58
Einführung in ABAP
Beispiel: dtab1~col1 bezeichnet die Spalte col1 aus der Tabelle dtab1.
Kommt die Tabelle mehrfach in der FROM-Klausel vor, so muss der zugehörige Aliasname
der Tabelle angegeben werden.
Aggregatfunktionen
Der Zusatz DISTINCT bewirkt, dass Duplikate von den Aggregatfunktionen nicht
berücksichtigt werden.
Die folgenden Aggregatfunktionen sind in Open SQL verfügbar:
 AVG( [DISTINCT] col1 ) bestimmt den Durchschnittswert der Werte der

angegebenen Spalte in der Ergebnismenge (oder, bei Anwendung in der HAVING-
Klausel, in der aktuellen Gruppe)
 COUNT( DISTINCT col1 ) bestimmt die Anzahl unterschiedlicher Werte der
 COUNT(*) bestimmt die Anzahl der Zeilen in der Ergebnismenge (oder, bei
Anwendung in der HAVING-Klausel, der aktuellen Gruppe)
 MAX( [DISTINCT] col1 ) bestimmt den Maximalwert der Werte der
 MIN( [DISTINCT] col1 ) bestimmt den Minimalwert der Werte der
 SUM( [DISTINCT] col1 ) bestimmt die Summe der Werte der angegebenen
Spalte in der Ergebnismenge (oder, bei Anwendung in der HAVING-Klausel, in der
aktuellen Gruppe)
Wie in gewöhnlichem SQL müssen bei der Verwendung von Aggregatfunktionen alle nicht in
den Aggregatfunktionen verwendeten Spalten über die GROUP BY-Klausel gruppiert werden.
Werden in der SELECT-Klausel nur Aggregatfunktionen benutzt, ist die Gruppierung jedoch
nicht notwendig. Das Ergebnis hat in diesem Fall ohnehin nur eine Zeile.
NULL-Werte werden nicht in die Berechnung der Aggregatfunktion einbezogen (NULL
bedeutet nicht die Zahl Null, sondern ein leeres Feld in der Tabelle). Nur wenn alle Werte
NULL sind, ist auch das Ergebnis der Aggregatfunktion der NULL-Wert.
Zu beachten ist, dass der Typ der Variablen, die das Ergebnis aufnimmt, geeignet ist. So
könnte beim Zuweisen eines Durchschnittswerts an eine ganzzahlige Variable Präzision
verloren gehen. Auch besteht eine Gefahr von Überläufen bei der Summenberechnung. Bei
COUNT wir das Ergebnis intern über den Typ INT8 repräsentiert. Um diesen bei besonders
großen Tabellen voll auszunutzen, muss auf ABAP-Seite ein entsprechender Typ (P oder
DECFLOAT34) verwendet werden.
Dynamische Spaltenangabe
Die dynamische Spaltenangabe ist über das eingeklammerte Datenobjekt

(column_syntax) möglich. column_syntax muss hierbei ein zeichenartiges
Datenobjekt oder eine interne Tabelle mit zeichenartigem Datentyp sein, die zur Laufzeit die
Seite 59
Einführung in ABAP
Syntax der statischen Spaltenangabe enthält. Bei einer Tabelle darf die Syntax auf mehrere
Zeilen verteilt sein. Groß- und Kleinschreibung wird nicht berücksichtigt8 .
8.4.6.2 Der FROM-Teil
Der FROM-Teil einer Anfrage gibt die zugrundeliegenden Ausgangsdaten (Datenbanktabellen)

an und hat folgende Syntax9 :
... FROM {
{dbtab [AS tabalias] }
| join
| { (dbtab_syntax) [AS tabalias]}}
[ UP TO n ROWS]
[CLIENT SPECIFIED]
[BYPASSING BUFFER] ...
8.4.6.2.1 Auswahl einer einzelnen Tabelle
Durch dbtab [AS tabalias] wird lediglich eine einzelne Tabelle der Datenbank
ausgewählt. Durch AS tabalias kann der Tabelle ein Aliasname gegeben werden, so dass
diese in anderen Teilen der Anfrage über den Aliasnamen ansprechbar wird. Bei einzelnen
Tabellen ist dies jedoch nicht erforderlich.
8.4.6.2.2 Auswahl mehrerer Tabellen: Joins definieren
Durch Joins lassen sich mehrere Tabellen miteinander verknüpfen. Die Syntax für join lautet:
... [(] { dbtab_left [AS tabalias_left]}

| join
{ { [INNER] JOIN } | {LEFT [OUTER] JOIN} | {RIGHT [OUTER] JOIN} }
{dbtab_right [AS tabalias_right]
ON join_cond} [)] ...
Wie Sie am Element join in der Syntaxdarstellung erkennen können, ist der join-Ausdruck
rekursiv schachtelbar.
Ein Join besteht immer aus zwei Seiten. Die linke Seite kann eine Tabelle oder ein weiterer
Join sein, die rechte Seite ist hingegen immer eine Tabelle (Views sind statt Tabellen jeweils
auch möglich, werden aber hier nicht getrennt betrachtet). Hinzu kommen die jeweiligen
Bedingungen im join_cond-Teil. Sie geben an, welche Datensätze im Tabellen-Join
enthalten sein sollen.
8.4.6.2.3 Auswahl mehrerer Tabellen: Arten von Joins
In Open SQL sind innere Joins sowie linke und rechte äußere Joins (deutsch auch
Verbünde genannt) möglich.
8
Keller (2012, S. 1073 f.)
9
Keller (2012, S. 1074)
Seite 60
Einführung in ABAP
Bei einem inneren Join werden die Spalten der linken und der rechten Tabelle verknüpft, so
dass die Ergebnismenge aus den Spalten beider Tabellen besteht. Für jede Zeile der linken
Tabelle werden die Zeilen der rechten Tabelle ermittelt, für die die Bedingung join_cond
erfüllt ist. Die entsprechend verknüpften Zeilen werden in die Ergebnismenge aufgenommen.
In der Ergebnismenge können folglich die Zeilen der linken bzw. rechten Tabelle mehrfach
auftreten, wenn mehrere Verknüpfungen die Bedingung erfüllten.
Erfüllen keine Zeilen die Bedingung join_cond, so ist die Ergebnismenge leer.
Der linke äußere Join ähnelt dem inneren Join. Die Spalten der Ergebnismenge sind gleich.
Es werden lediglich zusätzlich zu den wie zuvor bestimmten Zeilen der Ergebnismenge auch
für alle Zeilen der linken Tabelle, die keine passenden "Partner" in der rechten Tabelle
gefunden haben, Zeilen in der Ergebnismenge erzeugt. Die Spalten der Ergebnismenge, die
zur linken Tabelle gehören, werden für diese Zeilen entsprechend gefüllt, die Spalten die zur
rechten Tabelle gehören erhalten für diese Zeilen NULL-Werte.
Der rechte äußere Join enspricht dem linken äußeren Join, nur dass die Tabellen hier ihre
Rollen tauschen. Dieser Join ist erst mit Release 7.40 SP05 hinzu gekommen.
Als logischer Operator in der ON-Bedingung kann nur AND verwendet werden und jeder
Vergleich in der ON-Bedingung muss ein Feld der rechten Tabelle enthalten. Im WHERE-
Teil dürfen hingegen keine Felder der rechten Tabelle vorkommen. Nähere Erläuterungen
finden Sie in der ABAP-Dokumentation.
Kommen in mehreren Tabellen des join-Ausdrucks gleiche Spaltennamen vor, müssen

diese in anderen Teilen der Anfrage über den Tabellennamen identifiziert werden (in der
Form tabelle~spalte). Wird mehrfach die gleiche Tabelle verwendet, müssen für die
Verwendung an anderen Stellen Aliase (AS tabalias_left bzw. AS
tabalias_right) vergeben werden.
8.4.6.2.4 Beispiel für einen Join
Ein Beispiel für einen Join ist der Abruf von Flügen aus der SFLIGHT-Tabelle, wobei aber
zusätzlich die Zeit des Fluges ermittelt werden soll. Diese ist in der SPFLI-Tabelle enthalten.
Beide Tabellen müssen dafür über einen Join verbunden werden.
Seite 61
Einführung in ABAP
Abbildung 65: Beispiel für einen Tabellen-Join
Bequemer als im ABAP-Code lassen sich Joins in Views im ABAP Dictionary definieren.
Aus den Views kann dann wie aus einer Tabelle gelesen werden, ohne dass die Join-Tabellen
und die Join-Bedingung oder die im View definierten Spalten erneut spezifiziert werden
müssen.
8.4.6.2.5 Praxis: Übung zur Implementierung des Joins im ABAP-Code
In dieser Übung soll der soeben dargestellte Join in ABAP-Code implementiert werden.
Legen Sie hierfür ein neues Programm ZZ_####_JOIN an. Es soll sich wie gewohnt um ein
Programm ohne Top-Include mit dem Status Testprogramm in Ihrem Paket ZZ_####
handeln.
Definieren Sie für die Beschreibung des Ergebnisses zunächst einen lokalen strukturierten
Typ str_join. Dieser soll die Felder CARRID, CONNID, CITYFROM und CARRNAME
enthalten. Hinweis: CARRNAME ist eine Spalte aus der Tabelle SCARR, die die
Fluggesellschaften enthält. Zur Typisierung der Felder des Typs beziehen Sie sich mit LIKE
auf die entsprechenden Felder der Datenbanktabellen.
Definieren Sie anschließend einen Arbeitsbereich vom soeben definierten Typ und lesen Sie
in einer SELECT-Schleife nach und nach die Daten in den Arbeitsbereich. Geben Sie die
Spalten im SELECT-Teil explizit an. Da in beiden Tabellen ein CARRID-Feld vorhanden ist,
müssen Sie diesem den Namen einer der beiden Tabellen und die Tilde voranstellen. Die
Tildennotation benötigen Sie zudem für die Join-Bedingung im FROM-Teil. Dort verbinden
Sie die beiden Tabellen SPFLI und SCARR über einen INNER JOIN.
Geben Sie im Rumpf der SELECT-Schleife den Inhalt des Arbeitsbereiches jeweils in einer
neuen Zeile aus.
Seite 62
Einführung in ABAP
Speichern, prüfen und aktivieren Sie Ihr Programm. Das Ergebnis sollte etwa wie folgt
aussehen:
Abbildung 66: Ausgabe des Join-Programms: SAP-System-Screenshot
Der Code, durch den die abgebildete Ausgabe zustande gekommen ist, sieht wie folgt aus und
sollte mit Ihrem Code in etwa übereinstimmen:
Abbildung 67: Code für das Join-Programm: SAP-System-Screenshot
Da der Code durch umfangreiche Joins schnell unübersichtlich wird, ist es häufig sinnvoll,
statt den Join im Code anzugeben, einen entsprechenden View im Dictionary anzulegen, auf
den dann wie auf eine einfache Tabelle zugegriffen werden kann. Die Definition von Views
wird in Abschnitt 8.9.5 behandelt.
8.4.6.2.6 Dynamische Auswahl von Tabellen
Seite 63
Einführung in ABAP
Die dritte Möglichkeit der Tabellenauswahl ist die der dynamischen Angabe der
Tabellennamen. Hierfür wird, analog zur dynamischen Angabe von Spaltennamen im
SELECT-Teil der Anfrage, ein zeichenartiges Datenobjekt eingeklammert:
...(dtab_syntax) [AS tabalias] ...
Zur Laufzeit des Programms muss das Feld dtab_syntax die Syntax zur Tabellenauswahl
enthalten. Auch hier spielt die Groß- und Kleinschreibung keine Rolle. Der Zusatz AS kann
nur angegeben werden, wenn dtab_syntax nur den Namen einer einzelnen Tabelle enthält.
Innerhalb von dtab_syntax darf hinter dem Sprachelement IN (siehe nächster Abschnitt)
nur eine Liste von Feldern, aber keine Selektionstabelle stehen. Zudem dürfen keine Tabellen
mit Spalten der Typen STRING, RAWSTRING oder SSTRING in den Tabellen
vorkommen10 .
8.4.6.2.7 Zusätzliche Optionen
Durch die Angabe von UP TO n ROWS wird die Anzahl der Zeilen in der Ergebnismenge
begrenzt. Für n wird ein Datenelement vom Typ i erwartet. Hat es den Wert 0, werden alle
Zeilen in die Ergebnismenge übernommen, hat es hingegen einen negativen Wert, kommt es
zu einer nicht behandelbaren Ausnahme.
Mit CLIENT SPECIFIED kann die automatische Mandantenbehandlung von Open SQL
abgeschaltet werden. Mandantenabhängige Tabellen enthalten die Angabe des Mandanten in
der ersten Spalte, diese kann bei Angabe von CLIENT SPECIFIED in der WHERE-
Bedingung (siehe entsprechender Abschnitt) und bei ORDER BY (s. u.) verwendet werden.
BYPASSING BUFFER bewirkt eine Umgehung des Datenbankpuffers im

Anwendungsserver, so dass sichergestellt wird, dass tatsächlich ein Zugriff auf die Datenbank
erfolgt und nicht nur vorhandene Daten aus dem Zwischenspeicher (Puffer) von SAP gelesen
werden. Nähere Informationen zur Pufferung folgen in einem späteren Abschnitt dieses
Kursteils.
8.4.6.3 Der INTO-Teil
Der INTO-Teil (im obigen Syntaxdiagramm der SELECT-Anweisung das Element target)
gibt an, wohin die Ergebnisse der Anfrage gespeichert werden sollen.
Die Syntax lautet11 :

... { INTO
{ [CORRESPONDING FIELDS OF] wa}
| (dobj1, dobj2, ...)}
| {INTO|APPENDING
[CORRESPONDING FIELDS OF] TABLE itab
[PACKAGE SIZE n]
...
Die erste Möglichkeit ist die Angabe per CORRESPONDING FIELDS OF wa. Hierbei ist
wa ein Arbeitsbereich. Enthält die Ergebnismenge mehr als eine Zeile, muss die zuvor
10
Keller (2012, S. 1075)
11
Keller (2012, S. 1081)
Seite 64
Einführung in ABAP
beschriebene ENDSELECT-Anweisung verwendet werden, und es wird Zeilenweise das

Ergebnis an wa übergeben und der Bereich zwischen SELECT-Anweisung und ENDSELECT-
Anweisung ausgeführt. Hinter ENDSELECT enthält wa weiterhin die letzte Zeile der
Ergebnismenge. Achtung: Dies führt manchmal zu dem Fehler, dass unabsichtlich eine
Schleife benutzt wird, obwohl in deren Körper nichts geschieht und lediglich ein Datensatz
nach der Schleife verarbeitet wird.
Durch die Angabe von CORRESPONDING FIELDS werden nur die Inhalte von Spalten
übernommen, für die es in wa namensgleiche Komponenten gibt. Für mehrfach
vorkommende Spalten werden ggf. die verwendeten Aliasnamen berücksichtigt, ansonsten
wird die letzte Spalte des jeweiligen Namens verwendet.
Ohne CORRESPONDING FIELDS werden die Spalteninhalte in der Reihenfolge übergeben,

in der sie im SELECT-Teil auftreten.
Die zweite Möglichkeit ist die Angabe der Datenobjekte (dobj1, dobj2, ...). Dies ist
nur möglich, wenn im SELECT-Teil die Spalten explizit angegeben sind und die Anzahl der
Datenobjekte mit der Spaltenanzahl übereinstimmt. Die Reihenfolge der Daten entspricht der
Reihenfolge im SELECT-Teil. Für mehrzeilige Ergebnismengen ist es auch hier erforderlich,
ENDSELECT zu verwenden, und es wird entsprechend iteriert.
Die dritte Möglichkeit besteht in der Verwendung einer internen Tabelle, in die alle Zeilen der
Ergebnismenge eingelesen werden. Bei der Verwendung von INTO wird die Tabelle zunächst
initialisiert. Wird stattdessen APPEND benutzt, werden etwaige existierende Einträge in der
Tabelle belassen und die Ergebnismenge der Anfrage an die bestehende Tabelle angehängt.
Für jeden Eintrag in der internen Tabelle wird zunächst ein Datenelement des entsprechenden
Zeilentyps erzeugt. Diesem Datenelement werden dann die entsprechenden Werte
zugewiesen. Hierbei gelten die gleichen Regeln bezüglich der Verwendung von
CORRESPONDING FIELDS, wie oben bei der ersten Möglichkeit beschrieben.
8.4.6.4 Praxis: Übung zu SELECT
Durch folgendes Codefragment werden die Spalten cityfrom und cityto, also Abflug-
und Zielort der Flüge, in den Arbeitsbereich wa eingelesen, indem die Komponenten von wa
explizit angegeben werden. Da es sich um ein mehrzeiliges Ergebnis handelt, wird
ENDSELECT verwendet. Jedes Element der Ergebnismenge wird durch die WRITE-
Anweisung ausgegeben. Nach der Abarbeitung beinhalten wa-cityfrom und wa-cityto
die letzten entsprechenden Einträge der Ergebnismenge.
Das Beispiel entspricht der zuvor beschriebenen „zweiten Möglichkeit“.

DATA wa TYPE spfli.
SELECT cityfrom cityto
FROM spfli
INTO (wa-cityfrom, wa-cityto).
WRITE: / wa-cityfrom,
wa-cityto.
ENDSELECT.
Seite 65
Einführung in ABAP
Testen Sie die Ausgaben dieser Zeilen. Legen Sie hierfür ein eigenes Programm
ZZ_####_SQL an. Es soll kein Top-Include besitzen, den Status Testprogramm besitzen
und Ihrem gewohnten Transportauftrag zugeordnet sein. Speichern, prüfen und aktivieren Sie
das Programm, nachdem Sie die entsprechenden Zeilen eingegeben haben und sehen Sie sich
die Ausgabe an, indem Sie das Programm testen.
Als nächstes sollen weitere Angaben zu den Flügen ausgegeben werden. Da Sie die
entsprechenden Spaltennamen der Tabelle spfli an dieser Stelle noch nicht kennen, müssen
Sie den Aufbau der Tabelle ansehen. Hierfür könnten Sie das Dictionary aufrufen, dies wäre
aber umständlich. Stattdessen genügt ein Doppelklick auf spfli. Wenn Ihr Programm nicht
gespeichert war, können Sie dies nun nachholen, indem Sie die entsprechende Meldung des
Systems bestätigen. Mit der F3-Taste gelangen Sie nach Betrachten der Tabelle wieder zurück
zu Ihrem Programm. Ergänzen Sie das Programm so, dass mindestens eine weitere Spalte
ausgegeben wird. Vergessen Sie nicht, Ihr Programm am Ende zu speichern und zu
aktivieren.
8.4.6.5 Der WHERE-Teil
Im WHERE-Teil des Befehls wird die Ergebnismenge eingeschränkt.
Die Syntax ist12 :

...[FOR ALL ENTRIES IN itab] WHERE cond...
Die Variante mit FOR ALL ENTRIES IN itab ist historisch entstanden: Früher
unterstützten nicht alle Datenbanken, die für SAP freigegeben waren, Joins. Daher wurde mit
dieser Option ein Ersatz realisiert: Hier wird eine Art Join zwischen einer internen Tabelle
und einer Datenbanktabelle definiert. So können geschachtelte SELECT-Schleifen vermieden
werden. Die interne Tabelle sollte nicht leer sein, da sonst alle Einträge aus der
Datenbanktabelle übernommen werden13 . Generell sollten Sie dieses Konstrukt eher meiden.
Anfragen lassen sich effizienter direkt auf Datenbankebene zusammensetzen, während in
diesem Fall das System die Anfrage erst zusammensetzen muss. Hierdurch können mehrere
Einzelanfragen zusammen kommen.
In cond werden logische Ausdrücke formuliert, die im Wesentlichen den allgemeinen

logischen Ausdrücken entsprechen. Hier werden die Spalten untereinander und zu anderen
ABAP-Datenelementen in Beziehung gesetzt. Es muss mindestens eine Spalte in einem
logischen Ausdruck vorkommen. Es können wie beim SELECT-Teil Tabellennamen zu den
Spaltennamen mit der Tilde-Notation (~) angegeben werden, falls erforderlich.
Die möglichen Vergleichsoperatoren umfassen = (EQ), <> (NE), < (LT), > (GT), <= (LE) und
>= (GE).
Logische Ausdrücke können grundsätzlich durch AND bzw. OR, und- bzw. oder-verknüpft
werden. Durch Voranstellen von NOT werden sie negiert.
12
Keller (2012, S. 1092)
13
Keller und Krüger (2011, S. 729)
Seite 66
Einführung in ABAP
Darüber hinaus gibt es einige spezielle Operatoren14 :
Intervallzugehörigkeit
Die Intervallzugehörigkeit kann durch
...col [NOT] BETWEEN dobj1 AND dobj2 ...
geprüft werden. Der Ausdruck ist wahr (bzw. nicht wahr, wenn NOT angegeben wird), wenn
der Wert von col zwischen den Werten von dobj1 und dobj2 liegt.
Zeichenkettenvergleiche
Zeichenkettenvergleiche sind wie folgt möglich:
...col1 [NOT] LIKE dobj [ESCAPE esc]...
Hier wird geprüft, ob der Wert in der Spalte col1 zu dem in dobj angegebenen Muster
passt. dobj darf keine Spalte sein, sondern muss ein zeichenartiges Datenobjekt sein. Als
Muster dienen neben gewöhnlichen Zeichen das Maskenzeichen % für eine beliebige (auch
leere) Zeichenkette und das Maskenzeichen _ für ein einzelnes beliebiges Zeichen. Groß- und
Kleinschreibung wird beim Mustervergleich berücksichtigt, schließende Leerzeichen in dobj
jedoch ignoriert.
Mit dem Zusatz ESCAPE kann ein Zeichen als Fluchtsymbol definiert werden. esc muss
dabei ein zeichenartiges Datenobjekt der Länge 1 sein. Das Fluchtsymbol darf nur vor einem
Maskenzeichen oder vor dem Fluchtzeichen selbst stehen, in letzterem Fall verliert dadurch
das Fluchtzeichen seine besondere Bedeutung.
NULL-Wert-Prüfung
Die Prüfung auf den NULL-Wert erfolgt über
col1 IS [NOT] NULL
Dynamische logische Ausdrücke

Auch logische Ausdrücke können dynamisch verwendet werden. Die Syntax ist analog zu den
anderen dynamischen Elementen eine eingeklammerte zeichenartige Variable, die zur
Laufzeit den logischen Ausdruck enthält.
Unteranfragen
In logischen Ausdrücken können auch Unteranfragen verwendet werden, deren Ergebnis für
den Ausdruck verwendet wird. Die Syntax lautet15 :
... ( SELECT result

FROM source
[WHERE cond]
[GROUP BY cols]
[HAVING group_cond] ) ...
Die Unteranfrage ist ähnlich zu verwenden wie der SELECT-Befehl, unterliegt jedoch einigen
14
Keller (2012, S. 1096)
15
Keller (2012, S. 1101)
Seite 67
Einführung in ABAP
Einschränkungen. So ist kein INTO oder ORDER BY verwendbar. Unteranfragen werden als
korrelierte Unteranfragen bezeichnet, wenn Sie auf Spalten der umgebenden Anfrage
zurückgreifen.
Unteranfragen werden in Ausdrücken wie den folgenden benutzt:
 ... [NOT] EXISTS subquery. ist wahr, wenn die Unteranfrage kein (bzw.
mindestens ein) Ergebnis hat
 ... col [NOT] IN subquery... ist wahr, wenn der Wert der Spalte col in den
Ergebnissen der Unteranfrage (nicht) enthalten ist. Hierfür muss die Unteranfrage ein
Ergebnis mit nur einer Spalte liefern.
 ...col operator {ALL|ANY|SOME} subquery... ist wahr, wenn der
Vergleich von col mit den Ergebnissen der Unteranfrage für alle/mindestens einen
Wert wahr ist. Auch hier darf die Unteranfrage nur eine Spalte liefern. Liefert die
Unteranfrage nur einen Einzelwert, kann ALL/ANY/SOME entfallen. ANY und SOME
haben dieselbe Bedeutung.
Unteranfragen mit NOT sind häufig wenig performant und sollten daher vermieden werden. In
vielen Fällen lassen sich Unteranfragen auch durch Joins ersetzen. Eine allgemeine Aussage
zur Performance lässt sich nicht formulieren, da diese sehr unterschiedlich sein kann und im
Einzelfall getestet werden muss.
8.4.6.6 Der GROUP BY- und HAVING-Teil
Durch den GROUP BY-Teil werden Gruppen von Zeilen zusammengefasst, die in den
angegebenen Spalten gleiche Werte aufweisen. Die Syntax lautet16 :
... GROUP BY { {col1 col2 ...} | (column_syntax) } ...
Wenn GROUP BY verwendet wird, müssen im GROUP BY-Teil alle Spalten angegeben
werden, die in der SELECT-Klausel ohne eine Aggregatfunktion verwendet werden. Durch
die Aggregatfunktionen wird für die anderen Spalten bestimmt, welchen Wert die Spalte in
der Zeile der jeweiligen Gruppe erhalten soll. Würde keine Aggregatfunktion verwendet und
nicht über die Spalte gruppiert, lägen mehrere Werte für eine Spalte und Zeile vor, was im
zugrundeliegenden relationalen Datenbankmodell nicht zulässig ist.
Außer einer statischen Angabe der Spalten col1 col2 ... kann auch hier eine dynamische
Angabe nach dem bekannten Schema erfolgen.
Der HAVING-Teil schränkt ein, welche gruppierten Zeilen in der Ergebnismenge auftreten
sollen. Die Syntax ist analog zum WHERE-Teil
... HAVING group_cond ...
Der Unterschied zum WHERE-Teil liegt darin, dass im WHERE-Teil einzelne Zeilen der
Ausgangsmenge gefiltert werden, hier stattdessen gruppierte Zeilen.
8.4.6.7 Der ORDER BY-Teil
16
Keller (2012, S. 1108)
Seite 68
Einführung in ABAP
Der ORDER BY-Teil dient der Sortierung der Ergebnismenge. Die Syntax lautet17 :
... ORDER BY { {PRIMARY KEY}

| { { col1 | a1} [ASCENDING|DESCENDING]
{ col2 | a2} [ASCENDING|DESCENDING]
| (column_syntax)
}
Die Sortierung nach dem Primärschlüssel über PRIMARY KEY ist nur möglich, wenn im
SELECT-Teil alle Spalten des Primärschlüssels enthalten sind (entweder direkt oder über die
Sternnotation (SELECT *) ) und im FROM-Teil kein View oder Join-Ausdruck auftritt.
Andernfalls kann jedoch auch nach beliebigen Spalten sortiert werden, die explizit als col1,
col2... angegeben werden. Alternativ können die Aliasnamen a1, a2... verwendet
werden. ASCENDING bedeutet, dass aufsteigend sortiert werden soll, DESCENDING steht
hingegen für absteigende Sortierung.
Über (column_syntax) ist eine dynamische Spaltenangabe möglich, die wie die anderen
dynamischen Elemente funktioniert.
8.4.6.8 Auslesen von Daten über einen Cursor
Bei der zuvor gezeigten Verwendung des SELECT-Befehls ist das Auslesen der Daten aus der
Datenbank und das Zuweisen der Ergebnisse an ABAP-Datenobjekte ein gemeinsamer
Schritt. Durch die Verwendung eines Cursors kann diese Kopplung aufgehoben werden.
Zunächst muss ein Cursor geöffnet und eine Anfrage gestellt werden. Die Syntax hierfür ist
folgendermaßen18 :
OPEN CURSOR [WITH HOLD] dbcur FOR
SELECT result
FROM source
[[FOR ALL ENTRIES IN itab] WHERE cond]
[GROUP BY cols ]
[HAVING group_cond]
[ORDR BY sort_args].
Die Syntax der Anfrage (ab SELECT) entspricht der SELECT-Anweisung, es kann dort
lediglich kein SINGLE, INTO oder APPENDING verwendet werden.
dbcur muss eine Variable vom speziellen vordefinierten Typ cursor sein. Durch die obige
Anweisung wird der Cursor geöffnet und die Anfrage ausgeführt. Der Cursor steht nun vor
der ersten Zeile der Ergebnismenge.
Um an die Daten auch heranzukommen, d. h. um die Daten der Ergebnismenge ABAP-

Datenobjekten zuzuweisen, wird im Anschluss der FETCH-Befehl verwendet. Seine Syntax
sieht so aus19 :
17
Keller (2012, S. 1111)
18
Keller (2012, S. 1114)
Seite 69
Einführung in ABAP
FETCH NEXT CURSOR dbcur [INTO|APPENDING] target.
dbcur ist hierbei der zuvor geöffnete Cursor. Die Syntax von target ist analog zum
herkömmlichen SELECT-Befehl zu verwenden. Hier können somit sowohl Datenobjekte
stehen, die nur ein Element der Ergebnismenge aufnehmen können, als auch interne Tabellen,
die alle oder bei Angabe einer PACKAGE SIZE mehrere Zeilen aufnehmen. Hiervon hängt
es ab, ob durch den FETCH-Befehl eine, mehrere oder alle Zeilen ausgelesen werden.
Der Cursor wird um so viele Zeilen, wie aus der Ergebnismenge ausgelesen wurden, nach
vorn gesetzt. Wird das Ende der Ergebnismenge erreicht, wird bei jedem nachfolgenden
Ausleseversuch die Systemvariable sy-subrc auf 4 gesetzt, die Variablen hinter
INTO/APPEND jedoch nicht beeinflusst20 .
Bei jeder Entnahme wird zudem die Systemvariable sy-dbcnt gesetzt, und zwar auf die
Anzahl der bisher ausgelesenen Zeilen der Ergebnismenge.
Durch
CLOSE CURSOR dbcur.
wird der Cursor wieder geschlossen. Es empfiehlt sich, dies zu tun, da die Anzahl der
geöffneten Cursor begrenzt ist.
8.4.7 Praxis: Übung zu Gruppierung und Aggregatfunktionen
In dieser Übung sollen Sie einige statistische Daten aus der Flugdatenbank erheben und
ausgeben.
Öffnen Sie den Object Navigator und erstellen Sie ein neues Programm
ZZ_####_STATISTIK, wie zuvor als Testprogramm ohne Top-Include in Ihrem Paket und
mit Ihrem Transportauftrag. Am Ende dieser Übung befindet sich eine Beispiellösung für den
Quellcode des Programms – sie sollten aber unbedingt selbst das Programm implementieren
und nur im Notfall auf den vorgegebenen Quelltext schauen. Der Umfang des Kurses ist so
bemessen, dass genug Zeit für "Irrwege" beim Experimentieren in ABAP bleibt.
Sie sollen nun zu jeder Fluggesellschaft ihr Kürzel, ihren Namen, und die Dauer ihres
(zeitlich) längsten Linienfluges ausgeben. Gesellschaften ohne Linienflüge sollen nicht
erscheinen, ebenfalls sollen keine Fluggesellschaften erscheinen, deren (zeitlich) längster Flug
weniger als 7 Stunden dauert.
In der Tabelle SPFLI der Flüge finden Sie die Angabe des Flugtyps FLTYPE. Hier wird
angegeben, ob es sich um einen Charterflug ('X') oder einen Linienflug (' ') handelt.
Erstellen Sie zunächst einen (lokalen) strukturierten Typ stat_type, der die Felder
carrid, carrname und dauer enthält. Beziehen Sie sich bei den Typangaben der Felder
auf die entsprechenden Felder in den Tabellen SPFLI bzw. SCARR. Erzeugen Sie dann eine
interne Tabelle von Ihrem Typ.
19
Keller (2012, S. 1115)
20
Keller (2012, S. 1116)
Seite 70
Einführung in ABAP
Erzeugen Sie als nächstes die SELECT-Anweisung. Achten Sie beim Gebrauch von
Aggregatfunktionen darauf, dass zwischen den Klammern und dem Inhalt Leerzeichen
bleiben müssen.
Im FROM-Teil benötigen Sie sowohl die SCARR- als auch die SPFLI-Tabelle, da die SCARR-
Tabelle den Namen der Fluggesellschaft enthält, die SPFLI-Tabelle hingegen die Daten der
Flüge.
Im INTO-Teil können Sie bei entsprechender Benennung der Spalten CORRESPONDING

FIELDS OF TABLE verwenden.
Im WHERE-Teil schließen Sie die Charterflüge aus.
Im GROUP BY-Teil müssen Sie wie zuvor beschrieben über alle Spalten gruppieren, die
außerhalb von Aggregatfunktionen im SELECT-Teil vorkommen.
Bei der Angabe des HAVING-Teils geben Sie als untere Grenze für die Flugdauer 420 an, da
die Dauer intern in Minuten repräsentiert wird.
Sortieren Sie das Ergebnis absteigend nach der Fluglänge.
Anschließend muss das Ergebnis ausgegeben werden. Erzeugen Sie hierzu eine Variable von
Ihrem zuvor definierten Typ. Verwenden Sie diese Variable, um in einer LOOP-Schleife die
Elemente der internen Tabelle in die Variable zu übertragen und auszugeben.
Speichern, prüfen und aktivieren Sie Ihr Programm. Wenn Ihr Programm korrekt funktioniert,
sollte die Ausgabe etwa wie folgt aussehen:
Abbildung 68: Ausgaben des Statistikprogramms: SAP-System-Screenshot
Sollten die Ausgaben nicht wie gewünscht sein, versuchen Sie zunächst die Ursache in Ihrem
Programm zu finden. Der Lerneffekt ist am größten, wenn Sie Ihre Fehler eigenständig
finden.
Sollten Sie gar nicht weiter wissen oder Ihre Lösung vergleichen wollen, sehen Sie hier ein
Beispiel für das Programm.
Seite 71
Einführung in ABAP
Abbildung 69: Beispiel für ein Statistik-Programm: SAP-System-Screenshot
8.4.8 Neuerungen in OpenSQL
In Bedingungen im WHERE-Teil, bei denen die Spalten der Datenbank genau so heißen wie
die lokalen Datenobjekte, kann die klassische OpenSQL-Syntax schon einmal verwirrend
sein, wie im folgenden Beispiel:
SELECT carrid connid
FROM spfli
INTO CORRESPONDING FIELDS OF TABLE itab
WHERE carrid = carrid AND
connid = connid
Hier steht carrid bzw. connid auf der linken Seite des Gleichzeichens für eine
Datenbankspalte, auf der rechten Seite hingegen für eine lokale Variable aus dem ABAP-
Programm, mit der der Wert der Spalte verglichen werden soll.
Um Missverständnisse zu vermeiden, wurde daher eine neue Syntax geschaffen. Diese
unterscheidet sich dadurch, dass vor ABAP-Hostvariablen, also ABAP-Variablen, die
innerhalb eines OpenSQL-Statements verwendet werden, ein @-Zeichen vorangestellt wird.
Außerdem werden die Felder im SELECT-Teil durch Kommata getrennt:
Seite 72
Einführung in ABAP
SELECT carrid, connid
FROM spfli
INTO CORRESPONDING FIELDS OF TABLE @itab
WHERE carrid = @carrid AND
connid = @connid.
Sobald Teile der neueren OpenSQL-Funktionalitäten verwendet werden, die seit Release 7.40
hinzu gekommen sind, greift eine strengere Syntaxprüfung, und es muss auch die neue Syntax
eingesetzt werden. Daher ist es durchaus empfehlenswert, direkt mit dieser Syntax zu
arbeiten.
8.4.9 Inline-Deklarationen in OpenSQL
Im vorangegangenen Kapitel haben Sie bereits Inline-Deklarationen kennen gelernt. Diese

werden auch von OpenSQL unterstützt. So muss der Zielbereich einer Datenbankanfrage
nicht mehr explizit im Voraus definiert werden. Die Deklaration kann direkt in der SELECT-
Anfrage stattfinden. Dies erfordert die Verwendung der zuvor dargestellten neuen OpenSQL-
Syntax.
OpenSQL erkennt automatisch, welche Art von Datenobjekt deklariert wird. Dies kann
entweder ein elementares Datenobjekt (wenn ein einzelnes Feld aus der Datenbank selektiert
wird), ein strukturiertes Datenobjekt (wenn mehrere Felder selektiert werden) oder eine
interne Tabelle sein (wenn mehrere Datensätze auf einmal aus der Datenbank gelesen
werden). Im Folgenden werden einige Beispiele gezeigt:
8.4.9.1 Lesen eines einzelnen Wertes
SELECT COUNT(*) FROM spfli INTO @DATA(num).
WRITE num.
Hier entsteht mit num eine numerische Variable (vom Typ p), die die Anzahl Datensätze in
der Tabelle enthält.
8.4.9.2 Strukturierte Daten auslesen
SELECT carrid, connid, fltime FROM spfli INTO @DATA(wa).
WRITE: / wa-carrid, wa-connid, wa-fltime.
ENDSELECT.
Diese Zeilen lesen Datensätze in einen Arbeitsbereich. Die Variable wa wird hier automatisch
als strukturierter Arbeitsbereich mit den drei Komponenten carrid, connid und fltime und
entsprechenden Typen erzeugt.
Seite 73
Einführung in ABAP
8.4.9.3 Lesen von Tabellen
SELECT carrid, connid, fltime FROM spfli INTO TABLE

@DATA(itab).
Hier werden mehrere Datensätze auf einmal gelesen und in eine interne Tabelle itab
gespeichert, die genau die benötigten Felder besitzt.
8.4.9.4 Vorsicht bei Zuweisungen
An dieser Stelle ist Vorsicht geboten, wenn verschiedene Arbeitsbereiche einander

zugewiesen werden sollen. Dadurch, dass nur die für die Anfrage benötigten Felder
vorhanden sind, könnte es passieren dass verschiedene Arbeitsbereiche unterschiedlich
strukturiert sind. Hier ist es empfehlenswert, mit MOVE-CORRESPONDING zu arbeiten.
Diese Anweisung weist namensgleiche Komponenten von Strukturen oder internen Tabellen
einander zu (bei Kopfzeilentabellen nur die Kopfzeile). Die Möglichkeit, den Befehl für
interne Tabellen verwenden zu können, ist erst mit Release 7.40 SP05 hinzugekommen.
Zuvor wurde er nur für strukturierte Datenobjekte angeboten.
MOVE-CORRESPONDING wa1 TO wa2.
MOVE-CORRESPONDING itab1 TO itab2.
8.4.10 SQL-Ausdrücke
SQL-Ausdrücke sind als Bestandteile des SELECT-Teils, im GROUP BY-Teil ider in

Aggregatfunktionen erlaubt. Durch SQL-Ausdrücke können komplexere Anfragen formuliert
werden. Die Ausdrücke werden von ABAP an das Datenbanksystem weitergegeben und dort
berechnet.
SQL_Ausdrücke beinhalten arithmetische Ausdrücke. So kann mit den Operatoren +, -, * und

/ gerechnet werden. In komplexeren Ausdrücken gilt Punkt- vor Strichrechnung. Es können
Klammern verwendet werden.
Beispiel:
SELECT sum( seatsmax + seatsmax_b + seatsmax_f ) FROM SFLIGHT
INTO @DATA(theseats).
Dieser Ausdruck berechnet die Summe aller Sitze aller drei Klassen aller Flüge und speichert
das Ergebnis in einer Variablen theseats.
Zwei Zeichenketten col1 und col2 Können über einen SQL-Ausdruck col1 && col2
verkettet werden.
Es ist auch möglich, Verzweigungen in einer OpenSQL-Anfrage zu benutzen. Hierzu stehen

zwei versionen von CASE zur Verfügung:
Einfache Version:
Seite 74
Einführung in ABAP
…CASE operand
WHEN val1 THEN res1
[WHEN val2 THEN res2] …
[ELSE resd]
ENDCASE …
Diese Version entspricht in etwa der normalen Anweisung CASE in ABAP. Ein gegebener
Wert operand wird mit verschiedenen Werten val1, … valn verglichen. Stimmt er mit
einem der Werte über ein, so wird der enstprechende Wert res1, … resn zurückgegeben.
Falls kein Wert zutrifft, wird resd zurückgegeben.
Komplexe Version:
…CASE
WHEN cond1 THEN res1
[WHEN cond2 THEN res2] …
[ELSE resd]
ENDCASE …
Diese Version ist eher mit einem geschachtelten IF-Konstrukt vergleichbar. Hierbei enthält
jeder WHEN-Zweig eine bedingung cond1, … condn die geprüft wird, und sobald eine der
Bedingungen zutrifft, wird der zugehörige Wert zurück gegeben.
Es gibt noch weitere Möglichkeiten von SQL-Ausdrücken, die Sie in der

Schlüsselwortdokumentation nachlesen können.
8.4.11 Einfügen von Daten
Um Daten in eine Datenbanktabelle einzufügen, wird die INSERT-Anweisung verwendet.

Die Syntax lautet:
INSERT { {INTO target VALUES wa}

| {target FROM { wa | TABLE itab }}
}.
target gibt an, in welche Datenbanktabelle die neuen Einträge gespeichert werden. Diese
Angabe kann entweder durch statische Angabe des Namens der Tabelle erfolgen oder
dynamisch, indem wie bei den anderen dynamischen Elementen eine Variable eingeklammert
wird, die zur Laufzeit den Namen der Tabelle (bzw. des Views) enthält.
Die Tabelle bzw. der View muss im ABAP Dictionary angelegt sein und ein schreibender
Zugriff möglich sein. Auf Views, die sich auf mehrere Datenbanktabellen beziehen, kann
nicht schreibend zugegriffen werden. Bei Views, die nicht alle Spalten der ursprünglichen
Seite 75
Einführung in ABAP
Tabelle enthalten, werden die anderen Spalten entweder mit dem Initialwert, wenn ein solcher
angelegt ist, oder mit dem NULL-Wert befüllt.
Durch den Zusatz CLIENT SPECIFIED nach der Tabellenangabe wird die automatische
Mandantenbehandlung ausgeschaltet. Wird dieser Zusatz nicht angegeben, wird auch dann,
wenn die angegebenen Daten einen anderen Mandanten haben, der aktuelle Mandant
gespeichert.
wa ist ein Arbeitsbereich. Wird FROM angegeben, kann statt des Arbeitsbereichs über TABLE
itab eine interne Tabelle angegeben werden. In diesem Fall werden alle Einträge der
internen Tabelle übernommen. Enthält die interne Tabelle Einträge, die zu doppelten
Schlüsselwerten in der Datenbanktabelle führen würden, hängt das Verhalten von
ACCEPTING DUPLICATE KEYS ab. Ist dieser Zusatz angegeben, so werden die Einträge
der internen Tabelle, die zu doppelten Schlüsseln führen, ignoriert, die anderen Einträge aber
eingefügt. Wird der Zusatz hingegen nicht angegeben, werden keine Zeilen eingefügt und die
Ausnahme CX_SY_OPEN_SQL_DB ausgelöst.
8.4.12 Bearbeiten von Daten
Das Bearbeiten von Daten wird über den UPDATE-Befehl realisiert. Die Syntax lautet wie
folgt:
UPDATE target source.
Angabe des Ziels
Durch target wird die Datenbanktabelle (oder der View) gewählt, in der Änderungen
durchgeführt werden sollen. Die Angabe ist statisch durch den entsprechenden Namen, oder
dynamisch durch eine eingeklammerte zeichenartige Variable möglich, die zur Laufzeit den
Tabellen- bzw. View-Namen enthält.
Wird als Zusatz CLIENT SPECIFIED angegeben, wird hier wie bei INSERT die
automatische Mandantenbehandlung deaktiviert.
Angabe der Quelle
Die Syntax von source lautet21 :

...{ set_expression
| {FROM wa | {TABLE itab} } } ...
Hierdurch wird angegeben, welche Spalten und welche Zeilen wie geändert werden.
Die Variante einer set_expression ist am einfachsten. Hier können Zuweisungen
erfolgen, die folgende Formen haben können:
 col1 = f1 col2 = f2 ... weist den Spalten col1, col2... die Werte von
f1, f2, ... entsprechend zu. f1, f2, ... können entweder ABAP-Datenobjekte sein,
oder andere Spalten. Die Angabe der Tabelle ist über die Tilden-Notation möglich.
21
Keller (2012, S. 1124)
Seite 76
Einführung in ABAP
 col1 = col1 + f1 col2 = col2 + f2 ... addiert die Werte von f1, f2,
... zu col1, col2 ..., verhält sich ansonsten wie die zuvor genannte Form
 col1 = col1 - f1 col2 = col2 - f2 ... subtrahiert die Werte von f1,
f2, ... von col1, col2 ..., entsprechend.
 (expr_syntax1) (expr_syntax2) ... ist die dynamische Variante, in der
die Variable expr_syntax1 bzw. expr_syntax2 zur Laufzeit die
Zuweisungsformulierung enthalten.
Die zweite Möglichkeit ist das Überschreiben ganzer Zeilen. Entweder wird durch FROM wa
ein Arbeitsbereich, oder durch FROM TABLE itab eine Tabelle angegeben. Bei Angabe
eines Arbeitsbereiches wird nach einer Zeile gesucht, deren Primärschlüssel mit dem
entsprechenden Teil des Arbeitsbereichs übereinstimmt und die Zeile durch den Inhalt des
Arbeitsbereichs überschrieben. Bei Angabe einer internen Tabelle wird entsprechend für alle
Zeilen der internen Tabelle verfahren.
8.4.13 Automatisches Einfügen oder Bearbeiten
Es kann vorkommen, dass beim Einfügen neuer Daten in eine Datenbank nicht bekannt ist, ob
für einen Datensatz eine entsprechende Zeile bereits in der Datenbank vorhanden ist und nur
um die neuen Informationen ergänzt (überschrieben) werden müsste.
Es wäre recht umständlich, zunächst den SELECT-Befehl auszuführen und in Abhängigkeit

vom Vorhandensein einer Zeile der Tabelle entweder eine Einfüge- oder eine
Änderungsoperation durchzuführen. Hilfreich ist an dieser Stelle der MODIFY-Befehl. Die
Syntax lautet:
MODIFY target FROM source.
Angabe des Ziels
Das Ziel wird über target nach folgender Syntax angegeben22 :
... {dbtab | (dbtab_syntax)] [CLIENT SPECIFIED] ...
Über dbtab kann eine Tabelle statisch angegeben werden, wohingegen (dbtab_syntax)
die bekannte dynamische Formulierung ermöglicht. CLIENT SPECIFIED schaltet die
automatische Mandantenbehandlung ab.
Angabe der Quelle
Die Syntax der Quellenangabe in source ist wie folgt 23 :
... FROM wa | {TABLE itab} ...
Wird ein nicht-tabellenartiger Arbeitsbereich wa angegeben, wird in der Datenbank eine Zeile
gesucht, deren Primärschlüssel mit dem entsprechenden Teil des Arbeitsbereiches
übereinstimmt. Wird eine solche Zeile gefunden, wird sie gemäß der Regeln des UPDATE-
22
Keller (2012, S. 1130)
23
Keller (2012, S. 1130)
Seite 77
Einführung in ABAP
Befehls geändert. Wird keine solche Zeile gefunden, wird der Arbeitsbereich mittels
INSERT-Befehl eingefügt.
Wird eine interne Tabelle itab angegeben, werden alle Zeilen der internen Tabelle
nacheinander wie zuvor für den Arbeitsbereich beschrieben verarbeitet.
8.4.14 Löschen von Daten
Um Zeilen einer Tabelle zu löschen, wird der DELETE-Befehl benutzt. Die Syntax lautet24 :
DELETE { { FROM target [WHERE cond] }

| {target FROM source} }.
target gibt die Tabelle oder den View an, in dem sich die zu löschenden Daten befinden.
Hier kann entweder eine statische Angabe eines Tabellennamens (bzw. Viewnamens) stehen
oder eine entsprechende dynamische Angabe als geklammerte Variable. Der Zusatz CLIENT
SPECIFIED zur Umgehung der automatischen Mandantenbehandlung ist ebenfalls möglich.
Die zu löschenden Zeilen können entweder über einen WHERE-Teil oder über die source-
Angabe bestimmt werden. Der WHERE-Teil erfordert einen logischen Ausdruck cond. Alle
Zeilen der Tabelle, für die der logische Ausdruck cond wahr ist, werden aus der Tabelle
gelöscht.
Die Source-Angabe enthält hingegen einen Arbeitsbereich oder eine interne Tabelle. Wird ein
Arbeitsbereich angegeben, so werden die Zeilen der Datenbanktabelle gelöscht, deren
Primärschlüssel mit dem entsprechenden Eintrag des Arbeitsbereichs übereinstimmt. Wird
eine interne Tabelle angegeben, so wird die entsprechende Prüfung für alle Zeilen der
internen Tabelle durchgeführt und bei Übereinstimmung die Datenbanktabellenzeile gelöscht.
24
Keller (2012, S. 1132)
Seite 78
Einführung in ABAP
8.5 Berechtigungsprüfungen
Um die Inhalte der Datenbanktabellen vor unberechtigtem Zugriff zu schützen, besitzt das
SAP-System ein Berechtigungskonzept, über das der Entwickler eine Berechtigungsprüfung
vornehmen kann.
Für das Verständnis von Berechtigungsprüfungen in ABAP-Programmen ist ein

grundlegendes Verständnis des Berechtigungskonzepts im SAP-System erforderlich. Das
Berechtigungskonzept von SAP basiert auf sog. Berechtigungsobjekten. Die
Berechtigungsobjekte sind in Objektklassen nach fachlichen Kriterien gegliedert. Diese
Objektklassen können durch entsprechend autorisierte Nutzer in der Transaktion SU21
betrachtet werden. Ein Berechtigungsobjekt selbst stellt noch keine Berechtigung eines
Benutzers dar, eine bestimmte Aktivität durchzuführen. Vielmehr gibt das
Berechtigungsobjekt eine Reihe von Parametern vor, die für die Prüfung der Berechtigung
relevant sind. Dies ist insbesondere ACTVT, die Aktivität die der Benutzer ausführen
möchte. Es können aber weitere Parameter im Berechtigungsobjekt definiert werden.
Jeder Benutzer besitzt einen Benutzerstammsatz, indem ihm wiederum Berechtigungen

zugewiesen werden. Diese Berechtigungen beziehen sich auf ein bestimmtes
Berechtigungsobjekt und legen fest, welche konkreten Rechte der Benutzer im Kontext des
Berechtigungsobjekts besitzt. Es kann hierbei zu einem Berechtigungsobjekt mehrere
Berechtigungen geben. Die Berechtigungen werden dem Benutzer nicht einzeln zugewiesen,
sondern werden in Profilen zusammengefasst. Hierbei werden zusätzlich Sammelprofile
unterschieden, die mehrere Einzelprofile enthalten. Eine etwas fortschrittlichere Möglichkeit,
die Berechtigungen zu vergeben, stellen Rollen dar. Diese repräsentieren bestimmte
Aufgabenbereiche eines Benutzers im System, über die wiederum die zugehörigen Profile mit
ihren Berechtigungen generiert werden können.
Seite 79
Einführung in ABAP
Abbildung 70: Überblick über das Berechtigungskonzept
Die Tatsache, dass es ein bestimmtes Berechtigungsobjekt gibt, bedeutet noch nicht, dass
auch eine Berechtigungsprüfung stattfindet. Eine solche Prüfung muss vom Entwickler auch
tatsächlich implementiert werden. Dies geschieht mit dem AUTHORITY-CHECK-Befehl.
Dieser prüft ob eine geeignete Berechtigung für einen bestimmten Zugriff vorhanden ist und
setzt in Abhängigkeit davon den Wert des sy-subrc. Der Entwickler muss diesen
Rückgabewert auswerten und im Fall einer fehlgeschlagenen Berechtigungsprüfung eine
Fehlermeldung ausgeben und den Zugriff unterbinden.
Die Anweisung AUTHORITY-CHECK greift zunächst auf den Benutzerstammsatz zu, um zu

prüfen, ob eine Berechtigung vorliegt. Abhängig vom Ergebnis dieser Prüfung wird sy-
subrc gesetzt:
 sy-subrc = 0: Die Berechtigung liegt vor. Die gewünschte Aktivität kann also
ausgeführt werden.
Seite 80
Einführung in ABAP
 sy-subrc <> 0: Die Berechtigung liegt nicht vor. Die Aktivität sollte abgebrochen
und der Benutzer benachrichtigt werden.
Das Anlegen des Berechtigungsobjekts ist in der Regel teil der Aufgabe desjenigen, der die
Datenbanktabellen anlegt. Im Fall des Flugdatenbeispiels kann bereits auf das vordefinierte
Objekt S_CARRID zugegriffen werden.
Die Aufgabe der Profilverwaltung und Gestaltung der Benutzerstammsätze fallen hingegen in
den Aufgabenbereich eines Administrators.
Seite 81
Einführung in ABAP
8.6 Praxis: Übung zur Berechtigungsprüfung

Öffnen Sie Ihr Programm ZZ_####_FLUEGE im Object Navigator. Klicken Sie auf die
Schaltfläche (Anderes Objekt). Wählen Sie Erweiterte Optionen. Navigieren Sie dort
über die Pfeile zum Karteireiter Weitere und wählen Sie Berechtigungsobjekt. Geben
Sie als Name S_CARRID ein und bestätigen Sie. Es erscheint daraufhin das
Berechtigungsobjekt:
Abbildung 71: Das Berechtigungsobjekt S_CARRID: SAP-System-Screenshot
Sie sehen, dass das Objekt zwei Felder besitzt: Die ID der Fluggesellschaft und ein
Aktivitätsfeld. Lassen sie sich über die Schaltfläche Zulässige Aktivitäten die erlaubten
Werte für das Aktivitätsfeld anzeigen.
Seite 82
Einführung in ABAP
Abbildung 72: Zulässige Aktivitäten: SAP-System-Screenshot
Öffnen Sie nun Ihren Funktionsbaustein Z_####_GET_FLUEGE. Fügen Sie dort im Reiter
Ausnahmen eine neue Ausnahme no_auth für den Fall einer fehlenden Autorisierung mit
einem entsprechenden Kurztext ein. Speichern Sie und öffnen Sie dann den Quelltext.
Positionieren Sie den Cursor in der Zeile vor dem SELECT-Aufruf und klicken Sie auf die
Muster-Schaltfläche. Wählen Sie dort AUTHORITY-CHECK und geben Sie S_CARRID
ein.
Abbildung 73: AUTHORITY-CHECK als Muster einfügen: SAP-System-Screenshot
Es wird daraufhin ein Gerüst für den Aufruf eingefügt. Ersetzen Sie die Angaben rechts von
FIELD durch im_carrid bzw. '03' (03 ist die Aktivität für das Anzeigen. Die
Anführungsstriche werden benötigt, da der Typ hier zeichenartig ist). Achten Sie darauf, dass
um im_carrid keine Anführungszeichen stehen, da sie sonst statt des Wertes des
Parameters die Zeichenkette „im_carrid“ übergeben würden!
Ergänzen Sie eine Prüfung des sy-subrc die im Falle einer fehlenden Autorisierung über
den RAISE-Befehl eine Ausnahme auslöst.
Seite 83
Einführung in ABAP
Ihr Code sollte nun folgende Anweisungen enthalten:
Abbildung 74: Code zur Prüfung der Berechtigung: SAP-System-Screenshot
Speichern, prüfen und aktivieren Sie den Funktionsbaustein. Öffnen Sie anschließend Ihr
Programm ZZ_####_FLUEGE und ergänzen Sie im Funktionsbaustein-Aufruf im
EXCEPTIONS-Block einen weiteren Ausnahmewert, etwa wie folgt:
EXCEPTIONS
NO_AUTH = 7
Fragen Sie den zugeordneten Wert anschließend ebenfalls in Ihrem IF-Konstrukt aus dem
sy-subrc ab. Geben Sie statt der Flugdaten eine Fehlermeldung aus, wenn der Wert 7
erreicht ist.
Speichern, prüfen und aktivieren Sie Ihr Programm. Wenn Sie es testen, sollten Sie einen
Unterschied bemerken, je nachdem welche Fluglinie Sie wählen. In der Regel konfigurieren
wir Ihre Zugänge so, dass Sie nur Flüge der Lufthansa betrachten können, während bei
anderen Fluggesellschaften die Berechtigungsprüfung scheitert.
Beachten Sie, dass diese Ausnahme (keine Autorisierung) aufgrund Ihrer Berechtigungen
auch dann ausgelöst wird, wenn Sie eine ungültige Fluggesellschaft eingeben. Es ist eine
Designentscheidung, ob ein Benutzer zu einem Datensatz, zu dessen Zugriff er nicht befugt
ist, erfahren soll, ob dieser existiert oder nicht. Falls Sie dieses Verhalten ändern wollen,
müssten Sie den AUTHORITY-CHECK mitsamt seinem IF-Statement unterhalb des anderen
IF-Statements positionieren – dann würde ggf. die nicht-existenz-Ausnahme zuerst ausgelöst.
Seite 84
Einführung in ABAP
8.7 Indizes
Indizes werden verwendet, um möglichst schnell bestimmte Einträge in einer
Datenbanktabelle auffinden zu können. Sie entsprechen etwa einer verkürzten Repräsentation
der Tabelle, von der aus über einen Zeiger schnell auf den vollständigen Eintrag in der
eigentlichen Tabelle zugegriffen werden kann. Dies ist vergleichbar mit dem Index eines
Buches, bei dem die angegebene Seitenzahl den Zeiger zum vollständigen Eintrag darstellt.
Zu einer Tabelle können mehrere Indizes definiert werden, die unabhängig voneinander
existieren. Die Entscheidung, ob und ggf. welcher Index zur Beantwortung einer bestimmten
Datenbankanfrage verwendet wird, obliegt dem Optimizer und kann sich je nach
verwendetem Datenbanksystem unterscheiden. Es ist möglich, mit entsprechenden Traces zu
analysieren, welche Indizes tatsächlich verwendet werden.
Abbildung 75: Zugriff mit und ohne Index
Es werden Primär- und Sekundärindizes unterschieden. Der Primärindex ist ein Index auf
Basis des Primärschlüssels der Tabelle. Er wird automatisch angelegt, sobald Sie eine Tabelle
anlegen. Sekundärindizes sind hingegen zusätzliche Indizes die vom Benutzer explizit
angelegt werden müssen. Dies ist sinnvoll, wenn es bestimmte Felder gibt, die besonders
häufig in WHERE-Bedingungen von Datenbankanfragen verwendet werden, und für die es
daher attraktiv erscheint, einen Performancevorteil zu erreichen. Ein Index kann als unique
index gekennzeichnet werden. Dies bedeutet, dass zu jedem Eintrag im Index nur ein Eintrag
in der Originaltabelle gehören kann.
Seite 85
Einführung in ABAP
Das Anlegen von Indizes sollte jedoch wohl durchdacht sein25 : Es sollte darauf geachtet
werden, eine geeignete Reihenfolge von Feldern im Index zu definieren, bei denen das erste
Feld gleiche Werte für eine Reihe von Datensätzen besitzt. Zudem sollten nur erforderliche
Indizes angelegt werden, da diese auch gewartet werden müssen (d.h. das Datenbanksystem
muss diese stets auf aktuellem Stand halten).
Indizes werden über einen dreistelligen Bezeichner identifiziert. Auf Datenbankebene wird
dieser mit einer Tilde vom Namen der Tabelle getrennt abgelegt, etwa tabelle1~001. Die
Namensraumkonventionen sind auch für Indizes einzuhalten.
8.8 Praxis: Übung zum Anlegen eines Sekundärindex

Öffnen Sie im ABAP Dictionary die Tabelle ZZ####_STUDIS. In dieser Übung soll ein
Sekundärindex über die Felder Name und Vorname angelegt werden, da davon auszugehen
ist, dass viele Zugriffe über diese Felder erfolgen werden.
Wählen Sie den Menüpfad Springen -> Indizes, wählen sie und geben Sie an, dass Sie
einen Index anlegen möchten. Das System fragt Sie daraufhin nach der Indexkennung (die
zuvor genannte ID).
Abbildung 76: Anlegen eines Index: SAP-System-Screenshot
Vergeben Sie die Indexkennung Z1 und fahren Sie fort. Geben Sie im folgenden Bildschirm
eine entsprechende Kurzbeschreibung an und tragen Sie in die Tabelle im unteren Bereich die
Felder Name und Vorname ein:
Der Index soll Non-Unique sein, da es vorkommen könnte, dass zwei Studenten den gleichen
Namen haben.
25
Gupta (2011, S. 122)
Seite 86
Einführung in ABAP
Abbildung 77: Pflege der Eigenschaften des Index: SAP-System-Screenshot
Speichern, prüfen und aktivieren Sie den Index. Die Statusinformationen ändern sich
entsprechend:
Abbildung 78: Status des Index: SAP-System-Screenshot
Seite 87
Einführung in ABAP
8.9 Pufferung
Nachdem Sie nun Kenntnisse im Zugriff auf Datensätze besitzen, wird das Thema Pufferung
im Folgenden vertieft.
Im Puffer werden Datensätze nach dem Schlüssel sortiert. Falls Sekundärindizes definiert
sind, werden diese zur Sortierung herangezogen. Bei Anfragen an den Puffer können nur
Felder bis zum letzten spezifizierten Schlüsselfeld für den Zugriff verwendet werden. Ist bei
der Anfrage das erste Schlüsselfeld nicht angegeben, wird hingegen die komplette Tabelle im
Puffer sequenziell durchlaufen, um das Ergebnis zu bestimmen („Full Table Scan“) 26 .
Wenn eine Tabelle jedoch gepuffert werden soll, ist zwischen verschiedenen Arten von
Pufferung zu unterscheiden:
 Vollständige Pufferung: Hier werden alle Sätze der Tabelle in den Puffer
geladen, sobald auf einen Datensatz der Tabelle zugegriffen wird
 Generische Pufferung: Hier werden beim Zugriff auf einen Datensatz alle Sätze
der Tabelle in den Puffer geladen, deren linksbündiger Teil des Schlüssels mit
diesem Satz übereinstimmt
 Pufferung von Einzelsätzen: Hier wird nur der Satz gepuffert, auf den
zugegriffen wurde
8.9.1 Vollständige Pufferung
Eine vollständig gepufferte Tabelle kann sich nur ganz oder gar nicht im Puffer befinden. Bei
Zugriff auf einen Datensatz der Tabelle werden alle Datensätze in den Puffer geladen.
Die folgende Grafik veranschaulicht den Vorgang anhand der Tabelle SPFLI. Das
Mandantenfeld und einige weitere Felder sind zur Vereinfachung in den folgenden
Darstellungen ausgelassen worden.
26
Gupta (2011, S. 117)
Seite 88
Einführung in ABAP
Abbildung 79: Vollständige Pufferung
Eine vollständige Pufferung wird empfohlen für27
 Tabellen, die klein sind (bis 30 KB)
 Tabellen, die häufig gelesen werden
 Tabellen, bei denen häufig Abfragen auf nicht existente Datensätze erfolgen. Da
alle Datensätze im Puffer stehen, kann auch die Nichtexistenz eines Datensatzes
schon im Puffer entschieden werden.
8.9.2 Generische Pufferung
Die generische Pufferung lädt nicht alle Datensätze in den Puffer, sondern nur die, deren
generische Schlüsselfelder mit denen des selektierten Datensatzes übereinstimmen. Unter
diesem generischen Schlüssel wird ein Teil des Schlüssels verstanden, der beim Einstellen
der generischen Pufferung festgelegt wird. Dieser muss ein linksbündiger Teil des Schlüssels
der Tabelle sein.
27
Gupta (2011, S. 118)
Seite 89
Einführung in ABAP
Die generische Pufferung eignet sich dann, wenn häufig nur auf bestimmte, generische
Bereiche der Tabelle zugegriffen wird. Bei mandantenabhängigen Tabellen (diese enthalten
das Feld MANDT) führt das System automatisch auch bei vollständiger Pufferung eine
generische Pufferung über das Mandantenfeld durch, da angenommen wird, dass nicht auf
allen Mandanten gleichzeitig gearbeitet wird. Ein weiteres Beispiel, bei dem sich die
generische Pufferung gut einsetzen lässt, sind sprachabhängige Tabellen28 .
Die folgende Abbildung zeigt ein Beispiel zur generischen Pufferung. Hierbei wird
angenommen, dass der generische Schlüssel das CARRID-Feld umfasst:
Abbildung 80: Generische Pufferung
Durch die Auswahl des generischen Schlüssels wird die Anzahl der Bereiche, die im Puffer
entstehen, bestimmt. Ein zu kleiner generischer Schlüssel führt zu vielen kleinen Bereichen,
hier ist eine vollständige Pufferung meist effizienter. Ein zu großer generischer Schlüssel
hingegen führt dazu, dass sehr viele Daten gepuffert werden müssen29 .
28
Gupta (2011, S. 118)
29
Gupta (2011, S. 118)
Seite 90
Einführung in ABAP
8.9.3 Pufferung von Einzelsätzen
Am wenigsten Daten werden im Rahmen der Einzelsatzpufferung gepuffert. Hier wird jeweils
nur der aktuell gelesene Datensatz in den Puffer übertragen. Die Pufferung von Einzelsätzen
ist nur beim Zugriff per SELECT SINGLE wirksam, während alle anderen Zugriffe direkt an
die Datenbank weitergeleitet werden. Die Einzelsatzpufferung wird für große Tabellen mit
Anfragegrößen zwischen 100 und 200 KB empfohlen. Bei kleineren Tabellen ist sie nicht
effizient30 .
Auch die Einzelsatzpufferung lässt sich am bekannten Beispiel veranschaulichen:
Abbildung 81: Einzelsatzpufferung
8.9.4 Synchronisation von Puffern
Ein Problem ergibt sich, wenn Daten geändert werden, aber noch im Puffer eines
Anwendungsservers stehen. Bekanntlich können mehrere Anwendungsserver verwendet
werden, diese haben jeweils eigene Puffer. In diesen Fällen muss verhindert werden, dass es
zu Inkonsistenzen kommt.
30
Gupta (2011, S. 119)
Seite 91
Einführung in ABAP
Abbildung 82: Pufferung in zwei Anwendungsservern
Für solche Szenarien muss eine Synchronisation der Puffer stattfinden. In SAP wird dies über
die Synchronisationstabelle DDLOG realisiert. In regelmäßigen Abständen wird darüber
geprüft, ob an einer Tabelle Änderungen vorgenommen wurden und von welchem
Anwendungsserver dies geschah.
Die Synchronisierung wird über Profilparameter konfiguriert. Der Parameter

„rdisp/bufrefmode“ schaltet die Synchronisierung an oder ab (etwa falls es nur einen
Anwendungsserver gibt), der Parameter „rdisp/bufreftime“ gibt die Zeit zwischen den
Synchronisierungen. Der Standardwert dieses Parameters liegt bei 60 Sekunden31 .
Das Prinzip der Synchronisation soll an einem Beispiel mit zwei Anwendungsservern
veranschaulicht werden32 . Diese haben in der Ausgangssituation bereits Daten aus der Tabelle
zz_mytab geladen, so dass die Puffer schon Datensätze daraus enthalten. Es sei vollständige
Pufferung festgelegt.
31
Schneider (2002, S. 288 f.)
32
In Anlehung an das Beispiel von Schneider (2002, S. 287 f.)
Seite 92
Einführung in ABAP
Abbildung 83: Synchronisationsbeispiel 1/4
In Schritt 1 greift Application Server 1 schreibend auf die Datenbanktabelle zz_mytab zu. Die
Datenbankschnittstelle (DB-Interface) füllt daraufhin in Schritt 2 den Puffer von
Anwendungsserver 1 mit den aktuellen Daten. Im dritten Schritt nimmt die
Datenbankschnittstelle einen Eintrag in der DDLOG-Tabelle (Synchronisationstabelle) vor,
der angibt, dass Änderungen an der Tabelle zz_mytab vorgenommen wurden.
Seite 93
Einführung in ABAP
Im aktuellen Zustand könnte es zu Inkonsistenzen kommen: Der Puffer von

Anwendungsserver 2 enthält nun ungültige Daten. Dies kann – für eine beschränkte Zeit –
durch die Synchronisation nicht verhindert werden (eine solche Synchronisation würde zu viel
Last erzeugen). Erst beim nächsten Synchronisationszeitpunkt (Schritt 4 in der obigen
Abbildung) wird der Puffer von Anwendungsserver 2 aufgrund des Eintrags in der DDLOG-
Tabelle als ungültig markiert.
Seite 94
Einführung in ABAP
Es sei nun angenommen, dass ein Programm auf Application Server 2 auf die Tabelle
zugreifen möchte. Das DB-Interface stellt fest, dass der Puffer ungültig ist (5) und leitet die
Anfrage daher an die Datenbank weiter (6).
Seite 95
Einführung in ABAP
Im letzten Schritt (7) wird nun der Puffer des zweiten Application Servers mit den geänderten
Daten befüllt. Beide Puffer sind nun auf dem aktuellen Stand.
Seite 96
Einführung in ABAP
8.9.5 Wirksamkeit von Puffern
Bei der Überlegung, inwiefern die Pufferung einer Tabelle nützlich ist, kann auch die Art der
Datenbankzugriffe auf die Tabelle eine entscheidende Rolle spielen. Dabei geht es nicht allein
darum, auf welche Datensätze einer Tabelle wie oft zugegriffen wird, wie dies in den
vorangegangenen Abschnitten zu den verschiedenen Puffermöglichkeiten skizziert wurde. Es
spielt ebenfalls eine Rolle, welche OpenSQL-Konstrukte zum Einsatz kommen (bei Native
SQL kann grundsätzlich kein Puffer verwendet werden). Ein Rückgriff auf den Puffer findet
nicht statt33
 Wenn dies mit dem Zusatz BYPASSING BUFFER explizit verhindert wird (dies
kann entweder genutzt werden um zu verhindern, dass veraltete Daten aus dem
Puffer geladen werden, oder um einen ohnehin impliziten Puffer-Verzicht auch
explizit sichtbar zu machen
 Bei Anfragen, bei denen im WHERE-Teil eine Unteranfrage verwendet wird.
Beispiel: SELECT * FROM spfli WHERE carrid IN ( SELECT
carrid FROM scarr WHERE currcode = 'EUR').
 Bei Anfragen mit Aggregatfunktionen (COUNT, SUM, MIN, MAX,AVG)
 Bei Anfragen mit GROUP BY oder ORDER BY
 Bei Anfragen mit CLIENT SPECIFIED, aber ohne Mandantenangabe im
WHERE-Teil
 Bei Anfragen mit SELECT DISTINCT
8.10 Views
Views stellen spezielle Sichten auf eine oder mehrere Tabellen des Datenbanksystems dar. Sie
können verwendet werden, um einer Anwendung nur die Daten zur Verfügung zu stellen, die
benötigt werden und auf die sie zugreifen darf. Außerdem können Views aus mehreren
Tabellen durch Joins zusammengesetzt werden. Benötigt ein Programm häufig den gleichen
Join, ist das Anlegen eines Views eine Vereinfachung, da auf diesen in Open SQL wie auf
eine gewöhnliche Datenbanktabelle zugegriffen werden kann.
Aufgrund der zu Tabellen äquivalenten Verwendung in ABAP-Programmen dürfen die

Namen von Views nicht mit denen von Tabellen übereinstimmen. Es empfiehlt sich, bereits
im Namen kenntlich zu machen, dass es sich um einen View handelt.
Vorteile von Datenbank-Views sind:
 Verwendbarkeit in mehreren Programmen

 Möglichkeit der Suche nach bereits definierten Views über die bekannten
Suchmechanismen
 Bei Views, die durch Joins aus mehreren Tabellen zusammengesetzt werden, müssen
gemeinsame Felder in Anfragen nur einmal aus der Datenbank übertragen werden
 Durch den inner Join fallen überflüssige Datensätze weg, zu denen kein passender
Datensatz der jew. anderen Tabelle gefunden wird
Mithilfe von Selektionsbedingungen kann in einem View die Menge der Daten eingeschränkt
werden, die Teil des Views sein soll. Durch die Angabe von Join-Bedingungen kann genau
33
Keller und Krüger (2011, S. 753)
Seite 97
Einführung in ABAP
spezifiziert werden, welche Datensätze der am Join beteiligten Tabellen mit welchen
Datensätzen der anderen verbunden werden sollen. So kann eine Teilmenge des Kartesischen
Produkts der Datensätze definiert werden. Sie kennen diese Bedingungen bereits aus der
Formulierung mit OpenSQL. An dieser Stelle werden Sie unter anderem kennen lernen, wie
Sie diese Bedingungen für Datenbank-Views spezifizieren. Datenbankviews verwenden inner
Joins, outer Joins tauchen erst im Kontext von Pflegeviews auf.
8.10.1 Praxis: Übung zum Anlegen eines Views
In dieser Übung soll ein View erzeugt werden, der auf der Übung zur Nutzung des Data
Browsers aufbaut.
Rufen Sie das ABAP Dictionary auf (Transaktionscode SE11). Wählen Sie dort View aus und
geben Sie in das nebenstehende Textfeld ZZ_####_VIEW_FLU ein. Klicken Sie
anschließend auf die Schaltfläche Anlegen.
Das System fragt Sie nun nach der Art des Views. Hier stehen vier Möglichkeiten zur
Auswahl:
 Datenbank-View: Diese Views werden als echte Views des zugrunde liegenden
Datenbanksystems umgesetzt.
 Projektions-View: Diese Views dienen dem Ausblenden einzelner Spalten einer
Tabelle.
 Pflege-View: Diese Views werden verwendet, wenn Objekte, die für den Anwender
eine Einheit darstellen, technisch auf mehrere Tabellen verteilt sind.
 Help-View: Diese Views haben nur für das Hilfesystem eine Bedeutung.
Wählen Sie für unser Beispiel ein Datenbank-View. Geben Sie anschließend eine treffende
Kurzbeschreibung ein.
Geben Sie im Reiter Tabellen/Joinbedingungen als Tabelle auf der linken Seite die Tabelle
SPFLI an. Auf der rechten Seite könnten Joins definiert werden, dies ist in diesem Beispiel
aber nicht erforderlich. Wechseln Sie anschließend zum Reiter Viewfelder. Hier werden die
Spalten bestimmt, die im View später enthalten sein sollen, und ggf. Aliasnamen definiert.
Geben Sie in der ersten Zeile bei Tabelle SPFLI an und bei Feld MANDT, benutzen Sie
hierbei die Werthilfe. Die anderen Felder werden nun automatisch gefüllt. Unter Viewfeld
könnte nun ein anderer Name als Aliasname angegeben werden, unter dem die Spalte im
View erscheint.
Fügen Sie nach dem gleichen Schema weitere Zeilen für AIRPFROM, AIRPTO, CARRID,
CITYFROM, CITYTO, COUNTRYFR, COUNTRYTO und CONNID hinzu. Alternativ
können Sie die Felder über die Schaltfläche Tabellenfelder durch Anhaken hinzufügen.
Wechseln Sie nun zum Reiter Selektionsbedingungen. Hier werden die Bedingungen
spezifiziert, denen die Zeilen des Views genügen müssen. Die zuvor im ABAP Dictionary
verwendeten Bedingungen sollen nun auch hier angegeben werden.
Hierfür werden vier Zeilen benötigt. Die erste Zeile enthält als Tabelle SPFLI, als Feldname
CARRID, als Operator EQ (Gleich) und als Vergleichswert 'LH'. Dies sorgt dafür, dass
Einträge der Lufthansa angezeigt werden. In der letzten Spalte geben sie OR ein, um sie mit
dem folgenden Eintrag "oder-" zu verknüpfen. Der zweite Eintrag ist entsprechend mit
Seite 98
Einführung in ABAP
CARRID 'DL' vorzunehmen, hier ist in der AND/OR-Spalte AND anzugeben, da die
folgenden Beschränkungen der Flugdauer und-verknüpft werden. Beachten Sie die in diesem
Fall höhere Bindungskraft des OR. OR-Verknüpfungen sind nur zwischen Feldvergleichen
derselben Spalte zulässig.
Die nächsten beiden Einträge dienen der Einschränkung der Flugdauer. Die untere Schranke
wird mit dem GE-Operator (größer als oder gleich) und dem Vergleichswert 60, die obere
Schranke mit LE (kleiner als oder gleich) und Vergleichswert 360 angegeben. In die erste der
beiden Einschränkungen wird in der AND/OR-Spalte die Verknüpfung AND eingetragen. Die
Flugdauern wurden hier in Minuten angegeben.
Wechseln Sie nun in den Reiter Pflegestatus. Hier wird unter anderem festgelegt, ob auf den
View auch schreibend zugegriffen werden kann. Belassen Sie die Einstellungen. Speichern,
prüfen und aktivieren Sie Ihr Programm.
Wechseln Sie anschließend zum Data Browser (Transaktionscode SE16). Geben Sie dort als
Tabellenname ZZ_####_VIEW_FLU an und nehmen Sie im Selektionsbild keine
einschränkenden Eingaben vor, sondern bestätigen Sie direkt mit F8.
Sie sehen nun wie in der Übung zum Data Browser die drei Flüge, auf die die als
Selektionsbedingungen angegebenen Kriterien zutreffen, projiziert auf die als Viewfelder
ausgewählten Spalten.
Seite 99
Einführung in ABAP
8.10.2 Pflegedialoge
Häufig sind Objekte der Realwelt im Datenbanksystem auf mehrere Tabellen verteilt. Der
Anwender ist in der Regel aber daran interessiert, die Realweltobjekte als Ganzes zu pflegen,
d. h. anzulegen, zu bearbeiten oder zu löschen, ohne dabei zahlreiche einzelne Tabellen
aufsuchen zu müssen.
Für diesen Zweck gibt es im SAP-System spezielle Pflege-Views, durch die Objekte, die auf
mehrere Tabellen verteilt sind, auf einfache Art gepflegt werden können. An die View-
Definition ist stets die Definition einer entsprechenden Oberfläche, dem Pflegedialog,
gebunden. Die Generierung des Dialogs wird aus der Viewpflege heraus oder direkt über die
Transaktion SE54 (Generierung Tabellensicht) aufgerufen. Die Funktionsbausteine, die die
Verteilung der Daten auf die Tabellen vornehmen, werden automatisch generiert.
Es können in einem Pflege-View nur Tabellen aufgenommen werden, die zueinander in 1:N-
Beziehungen, von der ersten Tabelle im View ausgehend, über Fremdschlüssel verbunden
sind, da es keine Möglichkeit gibt, eigene Joinbedingungen anzugeben. Stattdessen werden
die Joinbedingungen stets aus den Beziehungen automatisch generiert.
Abbildung 87: Pflegedialog und Pflegeview
Die Schlüsselfelder der Tabellen (einschließlich des Mandantenfeldes) sollten im View

enthalten sein und zusammenhängend am Anfang stehen. Eine Verletzung dieser Restriktion
führt zu einer Warnung bei der Aktivierung.
Pflege-Views sind als kleines Hilfsmittel, nicht aber für die Datenpflege im gewöhnlichen
Betrieb gedacht, da Dateninkonsistenzen möglich sind. Über sie können jedoch bequem
Seite 100
Einführung in ABAP
mittlere Datenmengen in Customizing- und Kundentabellen erfasst werden, bei denen es zu

keinen Überschneidungen in den Daten kommen kann.
Die Konfiguration eines Pflegedialogs wird anhand der folgenden Übung erläutert.
8.10.2.1 Praxis: Übung zu Pflegeviews und Pflegedialogen
In dieser Übung soll ein Pflegedialog für die Tabellen SBUSPART und STRAVELAG erstellt
werden. Die Tabelle SBUSPART enthält Daten zu Geschäftspartnern („Business Partner“).
Da Geschäftspartner sowohl Flugkunden als auch Reisebüros sein können, gibt es für die
spezifischen Attribute eigene Tabellen. Durch den Pflegedialog soll es nun ermöglicht
werden, bei Reisebüros neben ihren allgemeinen Attributen aus der SBUSPART-Tabelle auch
die spezifischen Attribute aus STRAVELAG zu pflegen. Machen Sie sich über das Dictionary
oder den Data Browser mit den Tabellen vertraut.
Öffnen Sie dann das ABAP Dictionary und wählen Sie dort den Eintrag View aus. Geben Sie
als Namen ZZ####_PARTNER an. Wählen Sie anschließend Pflege-View und bestätigen
Sie.
Abbildung 88: Anlegen eines Pflege-Views: SAP-System-Screenshot
Pflegen Sie eine passende Kurzbeschreibung und geben Sie als Tabelle auf der linken Seite
zunächst SBUSPART ein und bestätigen Sie die Eingabe mit Enter. In einen Pflege-View
können nur solche Tabellen aufgenommen werden, die über die so eingegebene Primärtabelle
über einen Fremdschlüssel verbunden sind.
Um sich diese Tabellen anzeigen zu lassen (und sie dann einfügen zu können) positionieren
Sie den Cursor in dem Feld der Primärtabelle und klicken Sie auf (im
unteren linken Bereich). Es erscheint daraufhin ein Fenster, das Ihnen alle Beziehungen der
Tabelle anzeigt:
Seite 101
Einführung in ABAP
Abbildung 89: Beziehungen der Tabelle SBUSPART: SAP-System-Screenshot
Wenn eine Tabelle Beziehungen besitzt, deren Kardinalität für einen Pflege-View nicht
zulässig ist, werden diese als Beziehungen mit ungeeigneter Kardinalität angezeigt. Setzen
Sie das Häkchen vor STRAVELAG und bestätigen Sie durch Klick auf Übernehmen. Sie
sehen daraufhin, wie automatisch die Joinbedingungen festgelegt werden:
Abbildung 90: Automatische Joinbedingungen: SAP-System-Screenshot
Die automatischen Joinbedingungen wurden aus den Fremdschlüsselbeziehungen der

Tabellen generiert.
Es ist auch möglich, Tabellen aufzunehmen, die nicht mit der Primärtabelle, sondern mit einer
der anderen Tabellen über eine Fremdschlüsselbeziehung verbunden sind. Das Vorgehen ist
hierbei analog zum Vorgehen bei der Primärtabelle. Für das Beispiel genügen aber die beiden
ausgewählten Tabellen.
Als nächstes müssen die Felder des Views festgelegt werden. Dies geschieht im Karteireiter
Viewfelder.
Seite 102
Einführung in ABAP
Die Schlüsselfelder sind dort bereits eingetragen. Sie müssen Teil des Pflege-View sein,
genau wie etwaige Schlüsselfelder der Sekundärtabellen, die nicht über eine Joinbedingung
mit einem bereits im View enthaltenen Schlüsselfeld verbunden sind.
Um weitere Felder hinzuzufügen, klicken Sie auf .Wählen Sie im nächsten

Fenster SBUSPART und im darauffolgenden Fenster alle Felder der Tabelle aus und
bestätigen Sie.
Abbildung 91: Auswahl der Felder für den Pflegeview: SAP-System-Screenshot

Wiederholen Sie dieses Vorgehen für die Felder von STRAVELAG, mit Ausnahme der
Felder MANDT und AGENCYNUM. Dies sind die Felder, über die die Beziehung hergestellt
wird. Diese Felder sollten nicht im Pflegeview enthalten sein.
Wechseln Sie nun zum Karteireiter Selektionsbedingungen. Hier können Bedingungen

spezifiziert werden die die Auswahl der über den View selektierbaren Daten einschränken. In
unserem Beispiel sollen jedoch alle Daten verfügbar sein. Wechseln Sie daher ohne Einträge
vorzunehmen zum Karteireiter Pflegestatus. Hier kann festgelegt werden, wie über die
Viewpflege (Transaktion SM30) auf die Viewdaten zugegriffen werden kann. Stellen Sie
sicher, dass unter Zugriff der Eintrag lesen, ändern, löschen und einfügen selektiert ist.
Speichern, prüfen und aktivieren Sie den View.
Als nächstes soll der Pflegedialog konfiguriert werden. Wählen Sie dazu den Menüpfad
Hilfsmittel -> Tabellenpflegegenerator aus.
Seite 103
Einführung in ABAP
Abbildung 92: Tabellenpflegegenerator: SAP-System-Screenshot
Berechtigungsgruppe: Hier wird festgelegt, welche Benutzer zur Pflege berechtigt sind.
Geben sie hier SUNI ein.
Funktionsgruppe: Hier wird festgelegt, in welcher Funktionsgruppe die bereits erwähnten

Funktionsbausteine angelegt werden sollen. Geben Sie hier ZZ_####_FGPFLEGE ein.
Diese wird später automatisch angelegt, da sie noch nicht existiert.
Pflegetyp: Hier kann zwischen einer einstufigen und einer zweistufigen Oberfläche gewählt
werden. Die einstufige Version besteht aus nur einer Bildschirmmaske, in der die Inhalte
tabellarisch dargestellt sind. Bei der zweistufigen Version werden in der ersten Maske nur die
Schlüsselfelder und Textfelder mit mehr als 20 Zeichen Länge angezeigt. In einem Detailbild
(2. Maske) stehen dann alle Daten zur Verfügung. Wählen Sie für dieses Beispiel die
einstufige Version.
Pflegebildnummer: Hier kann die interne Nummer der Bildschirmmaske angegeben werden.
In unserem Beispiel soll dies die 0100 sein.
Als nächstes muss der Pflegedialog gesichert werden, was hier über die Schaltfläche
geschieht. Wählen Sie dabei für alle Nachfragen nicht Ihr Paket, sondern das Paket $TMP
aus, das für lokale Objekte steht. Lokale Objekte werden nicht in andere Systeme transportiert
und gehören zum Paket $TMP. Achtung: Für die folgenden Übungen müssen Sie
unbedingt wieder Ihr eigenes Paket verwenden, achten Sie auf den vorgegebenen Wert!
Seite 104
Einführung in ABAP
Um den Pflegedialog zu testen, wählen Sie den Menüpfad System -> Dienste ->
Tabellenpflege -> Erweit. Tab.pflege aus oder starten Sie die Transaktion SM30. Geben Sie
als Tabelle/Sicht den Namen ZZ####_PARTNER ein. Sie sehen daraufhin eine Liste der
Geschäftspartner und bei Reisebüros auch die zugehörigen Reisebürofelder (Sie müssen dafür
horizontal und vertikal scrollen).
8.10.2.2 Viewcluster
Wie oben beschrieben, sind Pflegeviews auf 1:N-Beziehungen beschränkt. Um auch

komplexere Beziehungen abbilden zu können, gibt es jedoch sog. Viewcluster. Diese
bestehen aus einzelnen Pflegeviews, die technisch oder inhaltlich zusammengehörige Daten
pflegen. Es lassen sich auch Pflegedialoge ohne (Teil-)Schlüsselabhängigkeit zu einem
Viewcluster zusammenfügen. Innerhalb des Clusters wird auch die Konsistenz sichergestellt:
Werden bspw. auf einer Ebene Daten gelöscht, werden diese auch auf weiteren, abhängigen
Ebenen gelöscht34 .
Hierfür müssen erst die einzelnen Pflegedialoge generiert werden. Anschließend werden diese
über die Transaktion SE54 zu einem Viewcluster zusammengesetzt. Innerhalb dieses
Viewclusters kann zwischen den einzelnen Pflegeviews navigiert werden.
34
Gupta (2011, S. 250)
Seite 105
Einführung in ABAP
8.11 Besondere Tabellenarten

Bisher haben Sie Tabellen kennengelernt, die neben ihrer logischen Repräsentation im ABAP
Dictionary auch ein entsprechendes gleichnamiges Gegenstück im Datenbanksystem besitzen.
Diese Tabellen werden als transparente Tabellen bezeichnet. Es gibt jedoch mit Cluster-
und Pooltabellen zwei besondere Tabellenarten, die eine Ausnahme von dieser 1:1-
Beziehung darstellen. Bei diesen Tabellen werden mehrere Tabellen aus dem ABAP
Dictionary in einer Tabelle des Datenbanksystems zusammengefasst.
8.11.1 Clustertabellen und Tabellencluster
Mehrere Tabellen, bei denen ein Teil des Primärschlüssels übereinstimmt (funktional
abhängige Tabellen), können zu einem Tabellencluster zusammengefasst werden. Hierfür
werden die Tabellen im Dictionary zunächst als gewöhnliche, transparente Tabellen angelegt.
Anschließend wird der Tabellentyp über den Menüpfad Zusätze -> Tabellenart ändern
umgestellt.
Abbildung 93: Tabellentyp ändern: SAP-System-Screenshot
Nach der Änderung des Tabellentyps enthält der Tab Auslieferung und Pflege ein neues Feld
in dem das Tabellencluster gewählt werden kann, zu dem die Clustertabelle gehören soll.
Dieser Tabellencluster ist auf der Datenbank als Tabelle mit folgenden Feldern repräsentiert 35 :
 Felder für die gemeinsamen Schlüsselkomponenten
 PAGENO: Eine Zahl zur Unterscheidung mehrerer Teilsätze, falls ein Datensatz nicht
in eine Zeile passt
 TIMESTAMP: Zeitstempel
 PAGELG: Länge des VARDATA-Feldes
 VARDATA: String, der die Daten aller weiteren Felder der Clustertabellen enthält.
Die Daten können also außerhalb des SAP-Systems nicht ohne Weiteres gelesen
werden.
Die folgende Abbildung veranschaulicht den Aufbau eines Tabellenclusters.
35
Gupta (2011, S. 80 f.)
Seite 106
Einführung in ABAP
Abbildung 94: Aufbau eines Tabellenclusters 36

Wie in der Abbildung dargestellt, ist nur das Tabellencluster Teil der Datenbank. Die
einzelnen Clustertabellen existieren nur auf SAP-Ebene.
8.11.2 Pooltabellen und Tabellenpools
Tabellencluster können nur für Tabellen mit gemeinsamen Schlüsselkomponenten verwendet

werden. Für Tabellen, die dieses Kriterium nicht erfüllen, gibt es stattdessen die Möglichkeit,
einen Tabellenpool zu definieren. Das Ergebnis ist ähnlich, auch hier entsteht auf
Datenbankebene eine größere Tabelle (der Tabellenpool), die sich aus mehreren kleineren
Tabellen auf SAP-Ebene zusammensetzt (den Pooltabellen).
Der Tabellenpool besitzt folgende Felder37 :
 TABNAME: Der Name der Pooltabelle, zu der der jeweilige Datensatz gehört
 VARKEY: Maximal 110 Zeichen lange Zeichenkette, die die Werte der
Schlüsselkomponenten der Pooltabelle enthält
 DATALN: Länge des VARDATA-Feldes
 VARDATA: String, der alle weiteren Felder der Pooltabelle enthält.
36
In Anlehnung an Gupta (2011, S. 81)
37
Gupta (2011, S. 79)
Seite 107
Einführung in ABAP
Die folgende Abbildung veranschaulicht einen Tabellenpool aus zwei Pooltabellen.
Abbildung 95: Aufbau eines Tabellenpools 38
8.11.3 Bewertung von Pool- und Clustertabellen
Vorteile von Pool- und Clustertabellen sind:
 Vereinfachung auf Datenbankebene (Weniger Tabellen müssen Administriert werden)
 Datenkomprimierung im VARDATA-Feld möglich
 Weniger Datenbankzugriffe beim laden zusammengehöriger Daten aus Clustertabellen
Als Nachteile sind hingegen zu nennen39 :
 Keine Bildung von Sekundärindizes möglich
 Kein Select Distinct oder Group by möglich, Order by nur auf Primärschlüsselebene
 Kein Zugriff mit Native SQL möglich
 Clustertabellen: Selektion auf Clusterkey-Felder beschränkt
38
In Anlehnung an Gupta (2011, S. 80)
39
Z. T. Gupta (2011, S. 82)
Seite 108
Einführung in ABAP
 Unnötig langes Schlüsselfeld bei einzelnen Pooltabellen mit kürzerem Primärschlüssel
Seite 109
Einführung in ABAP
8.12 Änderungen an Dictionary-Objekten

Durch die gegenseitige Verwendung von Dictionary- und Repositoryobjekten kommt es im
SAP-System zu Abhängigkeiten. So verwendet etwa ein von Ihnen definierter Datentyp eine
zuvor definierte Domäne. Der Datentyp ist in diesem Beispiel von der Domäne abhängig.
Häufig gibt es Abhängigkeiten über mehrere Elemente hinweg, im Beispiel könnte also Ihr
Datentyp noch in einem Tabellentyp verwendet werden, der dann ebenfalls abhängig ist.
8.12.1 Verwendungsnachweise
Besonders dann, wenn Sie ein Objekt bearbeiten, das besonders häufig von anderen Objekten
verwendet wird, sollten Sie sehr vorsichtig sein. In solch einem Fall wird die Änderung des
Objekts sehr viele Änderungen an abhängigen Objekten hervorrufen und es besteht sogar die
Gefahr, dass abhängige Objekte inkonsistent werden. Beispielsweise könnte ein Programm
nicht mehr richtig funktionieren, wenn Sie einen Datentyp verändern, der in diesem
Programm benutzt wird. Es empfiehlt sich daher, vor einer solch riskanten Änderung zunächst
einen Überblick einzuholen, welche Objekte von der Änderung betroffen sein könnten.
Abbildung 96: Verwendungsnachweis
Um die Situation der Abhängigkeiten analysieren zu können, gibt es im SAP-System das

Konzept des Verwendungsnachweises. Über diese Funktion können alle Objekte bestimmt
werden, die ein anderes Objekt benutzen. Hierbei werden nicht nur Dictionary-Objekte
angezeigt, sondern beispielsweise auch Programme, in denen das zu ändernde Dicitonary-
Objekt benutzt wird. Weiterhin können indirekte Abhängigkeiten darstellt werden, also
Objekte, die Objekte verwenden, die das aktuell betrachtete Objekt verwenden. Das SAP-
System bietet hierbei auch Möglichkeiten, eine genauere Eingrenzung vorzunehmen, in
welchem Bereich zu suchen ist. So kann die Suche etwa auf ein bestimmtes Paket oder einen
bestimmten Typ von Objekten beschränkt werden.
Seite 110
Einführung in ABAP
8.12.2 Aktivieren von Objekten
Wenn Sie eine Veränderung an einem Objekt vornehmen, ist diese Änderung zunächst noch
nicht im System wirksam. Stattdessen entsteht eine zweite Version, die parallel vorgehalten
wird und nur für den Entwickler sichtbar ist. Man unterscheidet also die aktive und die
inaktive Version eines Objektes. Nur die aktive Version ist die Version die von den meisten
Systemkomponenten (ABAP-Laufzeitumgebung, Datenbankschnittstelle) verwendet wird.
Erst mit der Aktivierung wird die aktive Version durch die inaktive Version ersetzt. Wenn es
zu einem Objekt abhängige Objekte gibt, müssen diese ebenfalls aktiviert werden, wenn das
veränderte Objekt aktiviert wurde. Diese Aktivierung wird vom System angestoßen. Beachten
Sie, dass die Aktivierung durch viele abhängige Objekte zeitintensiv sein kann. Aufgrund der
Gefahren, die mit der Aktivierung eines fehlerhaften Objektes verbunden sind, wird bei der
Aktivierung auch eine Prüfung durchgeführt. Probleme, die während der Aktivierung
auftreten, werden im Aktivierungsprotokoll festgehalten und der Entwickler erhält einen
entsprechenden Hinweis. Sie kennen solche Hinweise von den Warnungen zur
Erweiterungskategorie aus vergangenen Übungen. Beim Speichern einer veränderten Version,
die noch nicht aktiviert wurde, muss hingegen keine Prüfung durchgeführt werden, da diese
Version andere Teile des Systems noch nicht beeinflusst.
Abbildung 97: Aktive und inaktive Version einer Struktur
Die Abbildung zeigt ein Beispiel für eine Aktivierung. Der Entwickler hat eine Struktur
verändert, indem er ein Feld daraus entfernt hat. Die veränderte Version ist inaktiv und
existiert parallel, ohne das System zu beeinflussen. Erst mit der Aktivierung wird die bis
dahin aktive Version durch die bis dahin inaktive Version ersetzt.
Seite 111
Einführung in ABAP
Weiterhin entsteht im Rahmen der Aktivierung eines Objekts ein zugehöriges

Laufzeitobjekt. Dieses Objekt enthält alle Eigenschaften, die für die Verwendung des
Objekts benötigt werden. Es umfasst somit auch Eigenschaften, die eigentlich zu verwendeten
Objekten gehören. Das Laufzeitobjekt wird von der Laufzeitumgebung benutzt. Es lässt sich
aber auch über Funktionalitäten des Dictionary anzeigen.
8.12.3 Praxis: Übung zum Verwendungsnachweis
Öffnen Sie den Startbildschirm des ABAP Dictionary. Geben Sie als Datentyp den Wert
S_CONN_ID ein und klicken Sie auf die Schaltfläche .
Sie sehen daraufhin das Datenelement, das zur Beschreibung von Flugnummern dient.
Klicken Sie nun auf die Schaltfläche (Verwendungsnachweis).
Es erscheint folgendes Fenster:
Abbildung 98: Auswahlfenster für den Verwendungsnachweis: SAP-System-Screenshot
Stellen Sie sicher, dass nur die Verwendung in Tabellenfeldern für die Suche berücksichtigt
werden soll und bestätigen Sie. Sie erhalten daraufhin eine recht umfangreiche Liste von
Seite 112
Einführung in ABAP
Tabellen, in denen das Datenelement S_CONN_ID Verwendung findet (siehe nächste

Abbildung).
Per Doppelklick können Sie sich von dort die entsprechenden Tabellen anzeigen lassen.
Abbildung 99: Ergebnisse der Suche: SAP-System-Screenshot
Wenn Sie davon ausgehen, dass es sehr viele Verwender gibt, die Sie bei einer Anfrage
suchen, sollten Sie die Suche im Hintergrund laufen lassen.
Öffnen Sie erneut das Datenelement S_CONN_ID und wählen Sie erneut die Schaltfläche
(Verwendungsnachweis). Im darauffolgenden Fenster wählen Sie nun nicht nur
Tabellenfelder, sondern auch Strukturfelder aus. Bestätigen Sie die Maske diesmal nicht über
das grüne Häkchen, sondern die Schaltfläche .
Abbildung 100: Starttermin festlegen: SAP-System-Screenshot
Seite 113
Einführung in ABAP
Wählen Sie im abgebildeten Fenster Sofortstart und bestätigen Sie. Das System bearbeitet
die Suche nun im Hintergrund, während Sie im Dialogbetrieb weiterarbeiten können. Sie
werden benachrichtigt, wenn die Suche fertig gestellt ist. Dies erfolgt aber erst wenn Sie mit
Ihrer SAPGui wieder mit dem System kommunizieren. Wählen Sie daher nun eine andere
Bildschirmmaske, etwa indem Sie einfach das Datenelement mit F3 wieder verlassen. Sie
sollten das folgende Fenster erhalten, falls nicht, war der Hintergrundjob noch nicht beendet
und sie müssen eine (beliebige) weitere Maske aufrufen.
Abbildung 101: Ein Hintergrundjob wurde beendet: SAP-System-Screenshot
Klicken Sie in diesem Fenster auf das Symbol . So gelangen Sie zur Trefferliste, die
analog zur letzten Trefferliste aufgebaut ist, jedoch durch den größeren Suchbereich nun mehr
Treffer enthält.
8.12.4 Änderungen an Tabellen
Bei Änderungen an Datenbanktabellen (gemeint sind Änderungen an der Struktur der

Tabellen, nicht das reine Ändern von Tabelleninhalten) besteht eine besonders hohe
Komplexität. Hierbei muss beachtet werden, dass nicht nur die Repräsentation auf dem
Anwendungsserver mit dem Laufzeitobjekt, sondern auch die eigentliche Tabelle im
Datenbanksystem verändert werden muss.
Seite 114
Einführung in ABAP
Abbildung 102: Änderung an verschiedenen Stellen
Besonders problematisch ist dabei, dass die Tabelle bereits Daten enthalten kann, die von den
Änderungen mit betroffen wären. Änderungen an Tabellen sollten daher grundsätzlich
vermieden werden. Dies gilt insbesondere auf Produktivsystemen, da die Tabellen während
der Änderung nicht verfügbar sind und es so zu Problemen mit Programmen kommen kann,
die diese Tabellen benutzen.
Grundsätzlich bestehen drei Möglichkeiten, eine Änderung an einer Datenbanktabelle

vorzunehmen:
Das Verändern mit den Mitteln des Datenbanksystems. Durch Verwenden des SQL-
Befehls ALTER TABLE auf Ebene der Datenbank können bestimmte Änderungen an
Tabellen vorgenommen werden. Dabei bleiben die Daten der Tabelle erhalten. Die
Möglichkeiten sind hier jedoch begrenzt: Es gibt Änderungen, die das Datenbanksystem nicht
durchführen kann und für die daher nur eine der anderen Möglichkeiten infrage kommen.
Das Löschen und neu Anlegen der Tabelle. Die Möglichkeit, eine Tabelle zu löschen und
neu anzulegen besteht in jedem Fall. Der wesentliche Nachteil liegt darin, dass hierbei
sämtliche Daten aus der Tabelle verloren gehen. Wenn die Tabelle jedoch leer ist, stellt dies
kein Problem dar.
Das Umsetzen der Tabelle. Die Tabellenumsetzung ähnelt in gewissem Maße dem Löschen
und neu Anlegen der Tabelle, in diesem Fall wird jedoch die ursprüngliche Version der
Tabelle zunächst unter verändertem Namen beibehalten. Anschließend wird die neue Tabelle
angelegt und die Daten der alten Tabelle in die neue Tabelle übertragen. Dieser
Umsetzprozess wird vom SAP-System aus gesteuert. Beim Versuch der Aktivierung einer
veränderten Tabelle teilt das SAP-System ggf. mit, dass eine Umsetzung erforderlich ist.
Seite 115
Einführung in ABAP
Nachteil dieser Möglichkeit ist der hohe Aufwand und Speicherbedarf durch das bereithalten
der Sicherung der ursprünglichen Tabelle.
Welche Möglichkeit in einem konkreten Fall zum Einsatz kommen kann, ist von
verschiedenen Faktoren abhängig, etwa dem Inhalt der Tabellen, der Art der Änderung, aber
auch dem verwendeten Datenbanksystem. Es gibt Ausnahmefälle, in denen gar keine
Änderung auf Datenbankebene vorgenommen werden muss: Dies ist dann der Fall, wenn nur
die Reihenfolge von Nicht-Schlüsselfeldern geändert wurde. In diesem Fall muss nur der
Dictionary-Eintrag geändert werden, wohingegen die Datenbanktabelle unverändert bleiben
kann. Die Feldreihenfolge im Dictionary muss also nicht zwingend der Feldreihenfolge auf
Datenbankebene entsprechen.
8.12.5 Ablauf eines Umsetzprozesses
Im Folgenden wird der Ablauf eines Umsetzungsprozesses an einem einfachen Beispiel

schematisch erläutert40 .
Abbildung 103: Umsetzung 1/5
Angenommen sei, dass es eine Tabelle ZZMYTAB gibt, die bereits aktiviert und somit im
Datenbanksystem angelegt wurde und in der auch bereits Daten eingepflegt wurden. Zudem
existieren zwei Indizes zur Tabelle. Im Dictionary wurde nun die Tabelle verändert, indem die
40
Schritte nach Gupta (2011, S. 376 ff.)
Seite 116
Einführung in ABAP
Länge eines Feldes angepasst wurde. Diese veränderte Version wurde gesichert, aber noch
nicht aktiviert. Sie liegt also parallel zur aktiven Version als inaktive Version im Dictionary
bereit. Die obige Abbildung zeigt die initiale Situation.
Es wird nun zunächst eine Sperre auf die Tabelle im Dictionary gesetzt. Somit sind keine
weiteren Änderungen möglich. In der Datenbank wird die Tabelle umbenannt, indem ihrem
Namen am Beginn QCM hinzugefügt wird. Die vorhandenen Indizes werden gelöscht.
Seite 117
Einführung in ABAP
Im nächsten Schritt wird die geänderte Tabelle im Dictionary aktiviert. Die Sperre bleibt
weiterhin erhalten, da die Daten noch nicht zugreifbar sind. Durch die Aktivierung entsteht in
der Datenbank erneut eine Tabelle mit dem Namen ZZMYTAB. Diese hat die geänderte
Struktur, ist jedoch leer.
Seite 118
Einführung in ABAP
Die Daten aus der Sicherung QCMZZMYTAB werden nun in die neu angelegte Tabelle
übertragen. Hier kommt der MOVE-CORRESPONDING-Befehl zum Einsatz, der Daten zu
namensgleichen Feldern überträgt. Dabei kommen bei unterschiedlichen Typen die
entsprechenden Konvertierungsregeln zum Einsatz. Dies sollte beachtet werden, gerade wenn
wie im vorliegenden Beispiel ein Feld verkürzt wird. Bei der Verkürzung von
Schlüsselfeldern können durch entstehende Schlüsselduplikate Einträge verloren gehen.
Nähere Informationen zum Befehl entnehmen Sie bitte der Schlüsselwortdokumentation.
Seite 119
Einführung in ABAP
Nachdem die Daten übertragen worden sind, werden nun die Indizes neu angelegt, die
temporäre Tabelle QCMZZMYTAB gelöscht, und schließlich die Sperre im Dictionary
wieder aufgehoben. Die Tabelle ist somit wieder verwendbar und besitzt die geänderte
Struktur.
Es kann passieren, dass es während der Umsetzung zu Fehlern kommt und diese daher
abgebrochen werden muss. Ein möglicher Grund ist etwa ein Mangel an Speicherplatz:
Während der Umsetzung ist zwischenzeitlich sowohl die neue Tabelle als auch die alte
Tabelle mit ihren Daten vorhanden und beansprucht entsprechend viel Speicher. Es empfiehlt
sich daher, bereits vor dem Beginn eines Umsetzungsprozesses den verfügbaren Speicher im
Tablespace zu überprüfen. Sollte eine Umsetzung abgebrochen worden sein, wird dies
entsprechend in Logs festgehalten. Es ist dann große Vorsicht geboten. Die Umsetzung kann
über das Datenbank-Utility (Transaktion SE14) wiederaufgenommen werden. Es ist auch
möglich, lediglich die Sperre aufzuheben, was jedoch problematisch sein kann je nachdem in
welchem Teilschritt der Umsetzung es zu Problemen gekommen ist. In jedem Fall
beansprucht die Umsetzung eine gewisse Dauer, in der die Tabelle nicht verfügbar ist, was
noch einmal deutlich macht, dass eine Umsetzung nicht im produktiven Betrieb
vorgenommen werden sollte.
Seite 120
Einführung in ABAP
8.12.6 Praxis: Übung zur Umsetzung
Speziell für diese Übung werden Sie eine eigene Tabelle anlegen. Die Umsetzung könnte
zwar auch an der STUDIS-Tabelle demonstriert werden, jedoch könnten Sie dann für den Fall
einer gescheiterten Umsetzung folgende Übungen auf Basis dieser Tabelle nicht mehr
bearbeiten.
Öffnen Sie daher das Dictionary und erstellen Sie eine Tabelle ZZ####_UMSETZ. Pflegen
Sie eine passende Kurzbeschreibung, wählen sie die Auslieferungsklasse A und wählen Sie
Anzeige/Pflege Erlaubt. Wechseln Sie dann zum Karteireiter Felder. Geben Sie als erstes
Feld MANDT mit dem Datenelement MANDT an. Bestätigen Sie dieses Feld mit Enter und
klicken Sie dann auf . Hierdurch können Sie für die weiteren Felder den Typ
direkt eingeben, die entsprechenden Eingabefelder werden eingabebereit:
Abbildung 108: Direkte Typeingabe: SAP-System-Screenshot
Fügen Sie ein Feld SCHLUESSEL vom Typ NUMC mit der Länge 10 sowie ein Feld WERT
vom Typ CHAR mit der Länge 20 ein, machen Sie die Felder MANDT und SCHLUESSEL
zu Schlüsselfeldern und speichern Sie die Tabelle. Stellen sie sicher, dass Ihr Paket
ZZ_#### und nicht $TMP verwendet wird!
Abbildung 109: Felder der Tabelle ZZ####_UMSETZ: SAP-System-Screenshot
Wechseln Sie über den Menüpfad Springen -> Technische Einstellungen zu den
technischen Einstellungen. Wählen Sie dort die Datenart APPL0 und die kleinste
Größenkategorie. Speichern Sie die technischen Einstellungen und kehren Sie zur Tabelle
zurück. Aktivieren Sie die Tabelle.
Wählen Sie nun den Menüpfad Hilfsmittel -> Tabelleninhalt -> Einträge erfassen. Sollte
dieser deaktiviert sein, ist Ihre Einstellung zur Pflege vermutlich nicht korrekt.
Geben Sie einen Schlüssel (aus numerischen Zeichen) und einen Wert ein und speichern Sie.
Wiederholen Sie diesen Vorgang für einige weitere Einträge.
Seite 121
Einführung in ABAP
Kehren Sie nun zur Tabelle zurück. Schauen Sie sich über Hilfsmittel -> Tabelleninhalt ->
Anzeigen ihre Datensätze an (die Suchmaske einfach bestätigen).
Abbildung 110: Daten der Tabelle: SAP-System-Screenshot
Kehren Sie zur Tabelle zurück, wählen Sie den Karteireiter Felder und ändern Sie die Länge
des Feldes WERT von 20 auf 18 Zeichen. Sollte das Feld nicht eingabebereit sein, müssen Sie
noch auf klicken. Speichern Sie die Tabelle anschließend. Versuchen Sie
nun, die Tabelle zu aktivieren. Sie erhalten eine Fehlermeldung (im Gegensatz zur
gewohnten Warnmeldung):
Abbildung 111: Fehlermeldung: SAP-System-Screenshot
Klicken Sie auf Ja, um das Aktivierungsprotokoll anzuzeigen (falls die Verzweigung nicht
angeboten wird ist dieses auch im Menü unter Springen -> Aktivierungsprotokoll zu
finden). Dort sollten die folgenden Zeilen auftauchen:
Abbildung 112: Fehler bei der Aktivierung: SAP-System-Screenshot

Das System hat festgestellt, dass eine Änderung über ALTER TABLE nicht möglich ist und
die Tabelle daher umgesetzt werden muss. Verlassen Sie dafür die Transaktion und öffnen Sie
stattdessen das Datenbank-Utility (Transaktionscode SE14).
Seite 122
Einführung in ABAP
Abbildung 113: Einstiegsmaske des Datenbank-Utility: SAP-System-Screenshot
Geben Sie als Objektname den Namen der Tabelle ein, wählen Sie unter Dictionary
Objekte den Punkt Tabellen und klicken Sie auf Bearbeiten.
Stellen Sie sicher, dass im unteren Bereich Daten erhalten gewählt ist und klicken Sie auf
. Hierdurch wird, da ALTER TABLE nicht möglich ist,
die Umsetzung angestoßen. Bestätigen Sie die Nachfrage.
Das System sollte daraufhin den Erfolg vermelden:
Abbildung 114: Erfolgsmeldung: SAP-System-Screenshot
Verlassen Sie das Datenbank-Utility und kehren Sie zum Dictionary zurück. Öffnen Sie dort
wieder die Tabelle ZZ####_UMSETZ. Sie sehen, dass die Tabelle nun wieder aktiv ist und
das Wert-Feld die korrekte Länge aufweist:
Abbildung 115: Geänderte Tabelle: SAP-System-Screenshot
Wählen Sie den Menüpfad Hilsmittel -> Tabelleninhalt -> Anzeigen und lassen Sie sich
durch bestätigen der Suchmaske alle Datensätze anzeigen. Sie sehen, dass die Daten die
Änderung der Tabelle dank Umsetzung überstanden haben:
Seite 123
Einführung in ABAP
Abbildung 116: Tabelleninhalt nach der Umsetzung: SAP-System-Screenshot
8.12.7 Erweitern von SAP-Standardtabellen
In diesem Abschnitt lernen Sie Möglichkeiten kennen, modifikationsfrei Erweiterungen an

SAP-Standardtabellen vorzunehmen. Hier findet sich auch die Erklärung zu den Warnungen,
die Sie zuvor beim Aktivieren einiger Dictionary-Objekte gesehen haben.
8.12.7.1 Append-Strukturen
Wie im vorangegangenen Abschnitt dargestellt, kann es sehr mühsam und riskant sein, eine
Änderung an einer Tabelle vorzunehmen. Ganz besonders gilt dies für vorgegebene Tabellen
außerhalb des Kundennamensraums, die ohnehin ohne einen entsprechenden
Modifikationsschlüssel gar nicht direkt verändert werden können. Es ist allerdings vorstellbar,
dass es doch gute Gründe geben kann, eine Tabelle zumindest um zusätzliche Felder zu
erweitern. Dies kann etwa der Fall sein, wenn ein Kunde zu einem bestimmten
Geschäftsobjekt eine zusätzliche Eigenschaft hinterlegen möchte. Das SAP-System bietet mit
Append-Strukturen eine Möglichkeit, Tabellen, aber auch Strukturen im Dictionary um
zusätzliche Felder zu erweitern. Eine solche Appendstruktur kann unabhängig davon
verwendet werden, ob es sich um ein Objekt im Kundennamensraum handelt oder nicht. Es ist
jedoch seitens des Entwicklers, der das Originalobjekt pflegt, möglich, bezüglich der
Erweiterung durch Appends, Einschränkungen zu definieren. Dies sind die
Erweiterungskategorien, deren Fehlen bei der Aktivierung einiger Objekte in den bisherigen
Übungen vom System in einer entsprechenden Warnung bemängelt wurde.
Seite 124
Einführung in ABAP
Abbildung 117: Append-Strukturen
Eine Append-Struktur kann nur einer Tabelle zugeordnet werden. Umgekehrt darf eine
Tabelle aber mehrere Append-Strukturen besitzen. Bei der Aktivierung werden die
entsprechenden Zusatzfelder am Ende der Tabelle im Datenbanksystem angehängt. Es kann
nun passieren, dass in einer neuen Version des Originalobjekts ein zusätzliches Feld hinzu
kommt. Ist dieses Feld auch im Append vorhanden, kommt es zu Problemen bei der
Aktivierung. Aus diesem Grund sollten die Namen der Felder von Appends im
Kundennamensraum liegen, so dass Namenskonflikte mit SAP-Feldern ausgeschlossen
werden können. Dies wird vom System aber nicht erzwungen.
Seite 125
Einführung in ABAP
Abbildung 118: Appends und neue Felder von SAP
Sollte seitens des SAP-Entwicklers später ein weiteres Feld hinzukommen, ist dies kein
Problem für die Datenbank: Das neue Feld wird auf Datenbankebene einfach an das Ende der
Tabelle angehängt. Wie Sie bereits wissen, muss die Feldreihenfolge zwischen Dictionary und
Datenbank nicht unbedingt übereinstimmen.
Erweiterungen mit Appends sind dennoch nicht unbedingt unproblematisch. Es könnte etwa
sein, dass sich die Eigenschaften eines Typs verändern. Enthält eine Append-Struktur etwa
eine Komponente mit einem Referenztyp, kann aus einem flachen Typ plötzlich ein tiefer Typ
werden. Dies wiederum kann sich auf dessen Verwendung in anderen Typen oder
Programmen auswirken. Hier kann zum einen ein Blick in den Verwendungsnachweis
hilfreich sein, zum anderen sollte eine passende Erweiterungskategorie für die Tabelle oder
Struktur festgelegt werden. Dies geschieht über den Menüpfad Zusätze-
>Erweiterungskategorie.
Es stehen folgende Erweiterungskategorien zur Auswahl:
 Beliebig erweiterbar: Bei dieser Erweiterungskategorie können beliebige

Erweiterungen vorgenommen werden.
 Erweiterbar und zeichenartig oder numerisch: Bei dieser Erweiterungskategorie
dürfen im Append nur zeichenartige oder numerische Typen verwendet werden, nicht
aber tiefe Typen.
 Erweiterbar und zeichenartig: Bei dieser Erweiterungskategorie dürfen im Append
nur zeichenartige Typen verwendet werden
Seite 126
Einführung in ABAP
 Nicht erweiterbar: Diese Kategorie verbietet das Erweitern ganz

 Nicht klassifiziert: Dieser Wert bedeutet, dass noch keine Klassifizierung
vorgenommen wurde.
8.12.7.2 Customizing Includes
Eine andere Möglichkeit der Erweiterung von SAP-Tabellen sind Customizing Includes.
Hierbei handelt es sich um spezielle Strukturen, deren Name mit CI beginnt, die jedoch im
Kundennamensraum liegen und von SAP vorgedacht sind. Sie können im Gegensatz zu den
Appends in mehreren Tabellen verwendet werden, verhalten sich ansonsten aber ähnlich wie
Append-Strukturen41 .
Das Erweitern von Entwicklungsobjekten der SAP wird im Fortgeschrittenenkurs noch

einmal ausführlicher Behandelt.
8.12.8 Praxis: Übung zu Erweiterungen
Öffnen Sie das ABAP Dictionary und dort Ihre Tabelle ZZ####_UMSETZ im
Änderungsmodus. Wählen Sie den Menüpfad Springen -> Appendstruktur…
Abbildung 119: Anlegen einer Append-Struktur: SAP-System-Screenshot
Bestätigen Sie ggf. die Hinweismeldung und wählen sie den Appendnamen
ZAZZ####_UMSETZ. Pflegen Sie eine passende Kurzbeschreibung und ergänzen Sie ein
Feld mit dem Namen ZZNEU. Das Feld soll den eingebauten Typ INT4 verwenden. Klicken
Sie auf die Schaltfläche , um die Spalte eingabebereit zu machen.
Abbildung 120: Pflege der Append-Struktur: SAP-System-Screenshot
Speichern Sie die Append-Struktur, prüfen und aktivieren Sie diese. Kehren Sie danach zur
Tabelle ZZ####_UMSETZ zurück. Die Tabelle ist aktiv und in der Feldliste erscheint ein
Verweis auf die Append-Struktur:
41
Gupta (2011, S. 132 f.)
Seite 127
Einführung in ABAP
Abbildung 121: Append-Struktur in der Feldliste: SAP-System-Screenshot
Über die Schaltfläche können Sie auch das Feld des Appends einblenden lassen.
Verlassen Sie das Dictionary anschließend wieder.
Seite 128
Einführung in ABAP
8.13 Performance von Anfragen

Der Zugriff auf die Datenbank kann für die Performance einer Anwendung eine
entscheidende Rolle spielen. Bei den Anwendungen, die Sie im Rahmen dieses Kurses
schreiben, werden Sie dies nicht unbedingt merken. Das liegt daran, dass die Menge an Daten
mit denen Sie arbeiten begrenzt ist und es nicht so viele Zugriffe auf die Anwendungen gibt,
wie dies in einem realen Szenario der Fall wäre. Grundsätzlich sollten Sie sich aber Gedanken
zu der Problematik machen, damit Ihre Anwendungen auch in einem Produktivszenario nicht
übermäßig viele Ressourcen in Anspruch nehmen.
Bei der Betrachtung der Performance von Datenbankanfragen sind verschiedene Aspekte zu
berücksichtigen. Das Verhalten des Systems insgesamt hängt davon ab, wie viel Last auf der
Datenbank entsteht, wie viele Daten zwischen Datenbank und Application Server übertragen
werden müssen, und letztlich auch wie viel Last auf dem Application Server selbst entsteht. In
manchen Fällen ist dies ein Trade-Off, bei dem sich die optimale Strategie nicht
allgemeingültig festlegen lässt. Einige grundlegende Regeln für effiziente Zugriffe werden
Ihnen im Folgenden aber genannt.
Die Entscheidung, wie ein Zugriff auf eine Tabelle konkret umgesetzt wird (etwa die
Verwendung eines Index oder ein kompletter Scan der Tabelle, der manchmal trotz eines
vorhandenen Index effizienter sein kann) obliegt dem Datenbanksystem. Hier kommt ein sog.
Optimizer zum Einsatz, der einen Ausführungsplan für die jeweilige Anfrage entwickelt. Es
kann hierbei zu Unterschieden im Verhalten kommen, je nachdem welches Datenbanksystem
zum Einsatz kommt.
8.13.1 Lesen Sie nur die Daten, die Sie wirklich benötigen
Wenn Sie Datensätze aus der Datenbank laden, sollten Sie sich vorher überlegen, welche
Felder des Datensatzes Sie tatsächlich benötigen. Wenn Sie beispielsweise lediglich ein
einzelnes Feld aus jedem Datensatz im Programm verwenden, aber mit SELECT * alle Felder
der Tabelle in das Ergebnis aufnehmen, wird eine große Menge von Daten von der Datenbank
an die Anwendung transportiert, obwohl diese eigentlich nicht benötigt werden. Außerdem
müssen in Spaltenorientierten Datenbanken wie SAP HANA die Zeilen aufwändig wieder
zusammengesetzt werden.
Beispiel für schlechten Code:
SELECT * FROM SPFLI INTO wa.
WRITE: / wa-carrid, wa-connid.
ENDSELECT.
Beispiel für besseren Code:
SELECT carrid connid FROM SPFLI INTO wa.
ENDSELECT.
Seite 129
Einführung in ABAP
Ein ähnliches Beispiel für unnützen Datentransfer ist das Auslassen der WHERE-Bedingung,
so dass im Vergleich zum obigen Beispiel nicht zu viele Spalten, sondern zu viele Zeilen von
der Datenbank an die Anwendung übertragen werden.
SELECT carrid connid FROM SPFLI INTO wa.
IF wa-carrid = 'LH' OR wa-carrid = 'AA'.
ENDIF.
ENDSELECT.
SELECT carrid connid fltime FROM SPFLI INTO wa WHERE carrid =

'LH' OR carrid = 'AA'.
ENDSELECT.
8.13.2 Geben Sie vollständige Schlüssel an
Zugriffe auf Datenbanktabellen sollten möglichst über entsprechende Primärschlüssel oder

Sekundärindizes erfolgen. Hierdurch können Einträge schneller aufgefunden werden. Dies
funktioniert aber nur, solange der entsprechende Schlüssel keine Lücken enthält. Besteht ein
Schlüssel beispielsweise aus den Feldern f1, f2 und f3, sollte das Feld f2 nicht ausgelassen
werden, wenn es bekannt ist.
SELECT * FROM sflight INTO wa WHERE connid = '0401'.
...
SELECT * FROM sflight INTO wa WHERE carrid = 'LH' AND connid =

'0401'.
...
Beachten Sie hierbei, dass das Mandantenfeld automatisch übertragen wird (benutzen Sie aber
nicht CLIENT SPECIFIED ohne das Mandantenfeld dann auch explizit anzugeben!).
Seite 130
Einführung in ABAP
8.13.3 Vermeiden wiederholter, einzelner Zugriffe
Wenn Sie mehrere Datensätze von der Datenbank lesen wollen, ist es ineffizient dies mit
wiederholten, identischen SELECT-Anweisungen zu realisieren, bei denen jedes mal extra
auf die Datenbank zugegriffen werden muss.
Ein Beispiel für schlechten Code könnte so aussehen:
SELECT SINGLE * FROM SPFLI INTO ... WHERE CARRID='LH' AND

CONNID='0400'.
...

CONNID='0401'.
...

CONNID='0402'.
Besser wäre eine solche Formulierung:
SELECT * FROM SPFLI INTO ... WHERE CARRID='LH'.
...
ENDSELECT.
Ebenfalls käme hier eine Zwischenspeicherung in einer internen Tabelle mittels INTO
TABLE infrage.
8.13.4 Verwenden Sie Joins statt geschachtelter SELECTs
Wenn Sie Daten benötigen, die aus voneinander abhängigen Tabellen stammen, sollten Sie
diese bereits auf Datenbankebene mit entsprechenden Joins verbinden.
SELECT feld1 … FROM tabelle1 INTO wa.
SELECT feld2 … FROM tabelle2 INTO wa2 WHERE feld2 = wa-

feld1…
...
ENDSELECT.
ENDSELECT.
Seite 131
Einführung in ABAP
SELECT feld1 feld2 … FROM tabelle1 INNER JOIN tabelle2 ON ...
...
ENDSELECT.
Sie vermeiden so die hohe Zahl von Einzelzugriffen.
8.13.5 Abwägungsentscheidungen
In manchen Fällen müssen Sie abwägen, ob Sie eher Last auf dem Datenbankserver oder auf
dem Anwendungsserver erzeugen wollen.
8.13.5.1 Beispiel: Sortierung
Variante 1:
SELECT * FROM ... INTO TABLE itab ORDER BY feld1.
Variante 2:
SELECT * FROM ... INTO TABLE itab.
SORT itab ...
Bei der ersten Variante wird die Last der Sortierung auf dem Datenbankserver abgewickelt,
bei der zweiten Variante auf dem Anwendungsserver.
8.13.5.2 Beispiel: Berechnungen
Variante 1:
SELECT feld1 SUM( feld2 ) INTO TABLE itab FROM ... GROUP BY
feld1.
Variante 2:
SELECT feld1 feld2 INTO TABLE itab FROM ...
LOOP AT itab INTO wa.
...
ENDLOOP.
Bei der ersten Variante wird die Summe über eine Aggregatfunktion auf Datenbankebene
berechnet. Bei der zweiten Variante werden mehr Daten an den Anwendungsserver
übertragen, dafür entfällt die Last der Berechnung auf dem Datenbankserver. Hier ist im
konkreten Szenario zwischen den Lösungen abzuwägen.
Seite 132
Einführung in ABAP
8.14 Kapitelabschluss
Sie befinden sich am Ende dieses Abschnitts. Bevor Sie die im folgenden Absatz
beschriebene E-Mail verfassen, beachten Sie bitte die folgenden Hinweise:
1. Prüfen Sie, ob Sie wirklich alle Aufgaben seit dem vorangegangenen Abschluss
bearbeitet haben. Diese sind mit „Praxis:“ in der Überschrift gekennzeichnet (8.1.2,
8.2.7, 8.3.3, 8.3.5, 8.4.5, 8.4.6.2.5, 8.4.6.4, 8.4.7, 8.6, 8.8, 8.10.1, 8.10.2.1, 8.12.3,
8.12.6, 8.12.8).
2. Prüfen Sie bitte noch einmal genau, ob alle Ihre Repository-Objekte korrekt
funktionieren
3. Stellen Sie sicher, dass alle Repository-Objekte aktiviert sind. Um Objekte zu finden,
die noch nicht aktiviert sind, wählen Sie aus dem Drop-Down-Menü oberhalb des
Navigationsbaums im Object Navigator Inaktive Objekte aus. Geben Sie
anschließend im darunter befindlichen Feld Ihren Benutzernamen USER#-### ein und
bestätigen Sie. Anschließend werden im Navigationsbaum die inaktiven Objekte
dargestellt, die noch aktiviert werden müssen. Aktivieren Sie diese nun. Beachten Sie,
dass Sie die Zweige des Baums ggf. noch aufklappen müssen. Um zu ihrem Paket
zurückzukehren, wählen Sie im Drop-Down-Menü wieder Paket aus und bestätigen
Sie Ihren Paketnamen.
4. Stellen Sie weiterhin sicher, dass die Namen Ihrer Entwicklungsobjekte genau den
Vorgaben im Skript entsprechen. Sollten Sie sich vertippt haben, können Sie
Programme umbenennen, indem Sie diese mit der rechten Maustaste im
Navigationsbaum des Object Navigators anklicken und Umbenennen… auswählen.
Diese Hinweise gelten auch für die folgenden Kapitel.
Wenn Sie den Kurs bis zu dieser Stelle bearbeitet haben, senden Sie bitte eine formlose
E-Mail an die vom Kursbetreuer für diesen Kurs genannte Adresse mit dem Betreff
„ABAP: Abschluss Kapitel 8 User ####“. Sie erhalten dann in Kürze Feedback (je nach
Ergebnis entweder über den Fortschrittsbericht oder per E-Mail) und können Mängel ggf.
noch nachbessern. Bitte achten Sie darauf, den Betreff genau wie angegeben zu formulieren,
um eine effiziente Verarbeitung der Mail zu ermöglichen.
Sollten Sie Fragen haben, formulieren Sie diese bitte in einer separaten E-Mail mit
aussagekräftigem Betreff, da die Kapitelabschlussmails meist nur über den Betreff verarbeitet
werden!
Seite 133

1 3 de Dictionary PDF

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

1 3 de Dictionary PDF

Hochgeladen von

Copyright:

Verfügbare Formate

Einführung in ABAP

- ABAP Dictionary und Datenbanken -

Prof. Dr. Heimo H. Adelsberger

8.4.7 Praxis: Übung zu Gruppierung und Aggregatfunktionen................................... 70

Abbildung 41: Expandiertes Include: SAP-System-Screenshot............................................... 36

8 ABAP Dictionary und Datenbanken

Abbildung 1: Funktionen des Dictionary im Überblick

kann es sich um Views des zugrundeliegenden DB-Systems handeln, dies ist

Beispiele für diese Interaktion sind:

8.1 Exkurs: Der Data Browser

8.1.1 Aufgaben des Data Browsers

Den Data Browser erreichen Sie über den Menüpfad

Werkzeuge -> ABAP Workbench -> Übersicht -> Data Browser

oder den Transaktionscode SE16.

8.1.2 Praxis: Übung zur Nutzung des Data Browsers

Abbildung 2: Ein Selektionsbild des Data Browsers: SAP-System-Screenshot

Abbildung 3: Ergebnisliste des Data Browsers: SAP-System-Screenshot

Verlassen Sie den Data Browser nun wieder.

8.2 Typen des ABAP Dictionary

Abbildung 4: Der Einstiegsbildschirm des ABAP Dictionary: SAP-System-Screenshot

Abbildung 5: Externe Typen des Dictionary: SAP-System-Screenshot

8.2.1 Von lokalen zu globalen Typen

Abbildung 6: Die Typhierarchie von ABAP

 Elementare Typen über die einfache TYPES-Definition

Abbildung 7: Dictionary-Typen im Zusammenhang

Domänen dienen dazu, technische Eigenschaften von Datentypen zu definieren. Datentypen

Domänen können nicht dazu verwendet werden, Datenobjekte in ABAP-Programmen zu

Abbildung 8: Beispiel für eine Domäne im Dictionary: SAP-System-Screenshot

Groß- und Kleinbuchstaben ein- bzw. ausschaltet. Bei Nichtunterscheidung werden

Abbildung 9: Die Wertebereichs-Angaben der Domäne: SAP-System-Screenshot

 Hinterlegen von Zusatzeigenschaften und Feldbezeichnern

Abbildung 10: Pflegedialog eines Datenelements: SAP-System-Screenshot

Datenelemente beschreiben im Gegensatz zu Domänen auch semantische Eigenschaften des

Abbildung 11: Der Karteireiter zur Festlegung der Feldbezeichner: SAP-System-Screenshot

Der Karteireiter Zusatzeigenschaften ermöglicht einige weitere Einstellungen zum

TYPES: BEGIN OF str_fahrzeug,

Abbildung 12: Der Strukturtyp str_fahrzeug

Abbildung 13: Eine Struktur im ABAP Dictionary: SAP-System-Screenshot

Abbildung 14: Direkte Typangabe bei einer Struktur: SAP-System-Screenshot

Hierdurch werden die Spalten ab Datentyp eingabebereit, die Spalte Komponententyp

DATA meinfirmenwagen TYPE zz0000_fahrzeug.

Analog zu den lokalen Tabellentypen können im Dictionary globale Tabellentypen hinterlegt

Ein Tabellentyp für Fahrzeuge könnte wie folgt aussehen:

Abbildung 15: Ein Tabellentyp im ABAP Dictionary: SAP-System-Screenshot

Abbildung 16: Einstellungen zu Initialisierung und Zugriff: SAP-System-Screenshot

Im Karteireiter Schlüssel können Einstellungen zum Schlüssel des Tabellentyps gemacht

Abbildung 17: Einstellung zum Schlüssel: SAP-System-Screenshot

8.2.6 Typgruppen und Konstanten

Um im Dictionary Konstanten definieren zu können, muss eine Typgruppe (Type Pool)

Abbildung 18: Definition einer Typgruppe im ABAP Dictionary: SAP-System-Screenshot

8.2.7 Praxis: Übung zu globalen Typen

8.2.7.1 Domänen anlegen

Abbildung 20: Definition der Domäne im ABAP Dictionary: SAP-System-Screenshot

Speichern, prüfen und aktivieren Sie die Domäne anschließend.

8.2.7.2 Datenelemente Anlegen

Abbildung 21: Erster Schritt zum Anlegen eines Datenelements: SAP-System-Screenshot

Abbildung 22: Zweiter Schritt zum Anlegen eines Datenelements: SAP-System-Screenshot

Abbildung 23: Datentypangaben des Datenelements: SAP-System-Screenshot

Abbildung 24: Pflege der Feldbezeichner: SAP-System-Screenshot

Speichern, prüfen und aktivieren Sie das Datenelement.

8.2.7.3 Struktur anlegen

Abbildung 27: Beispiel für eine Struktur für Studenten: SAP-System-Screenshot

Speichern, prüfen und aktivieren Sie die Struktur.