Einstieg in ABAP - · PDF fileInhalt 5 Inhalt Vorwort 11 1 ABAP und erste Schritte im SAP-System 15 1.1 Architektur des SAP-Systems im Überblick

5Inhalt

Inhalt

Vorwort 11

1 ABAP und erste Schritte im SAP-System 15

1.1 Architektur des SAP-Systems im Überblick ................................................. 161.1.1 Technische Architektur ..................................................................... 161.1.2 Betriebswirtschaftlich-organisatorische Architektur ...................... 181.1.3 Plattformunabhängigkeit .................................................................. 20

1.2 Anwendungsprogramme und Laufzeitumgebung ...................................... 211.2.1 Workprozesse .................................................................................... 211.2.2 Struktur von ABAP-Programmen ..................................................... 23

1.3 Anmelden und Abmelden am System .......................................................... 251.3.1 Betriebswirtschaftlicher Modulüberblick ........................................ 271.3.2 ABAP Workbench .............................................................................. 29

2 Data Dictionary 33

2.1 Einstieg ins ABAP Dictionary ......................................................................... 332.1.1 Datenbanktabellen ............................................................................ 342.1.2 Tabelle anlegen und pflegen ............................................................ 35

2.2 Datenelemente und Domänen ...................................................................... 392.2.1 Datenelement anlegen ...................................................................... 392.2.2 Domäne anlegen ............................................................................... 432.2.3 Datenelement prüfen und aktivieren .............................................. 472.2.4 Technische Einstellungen der Tabelle pflegen ............................... 49

2.3 Datensätze erfassen ......................................................................................... 512.3.1 Datensätze eingeben ......................................................................... 512.3.2 Tabelleninhalt anzeigen .................................................................... 52

3 Programmieren im ABAP Editor 55

3.1 ABAP-Report anlegen ...................................................................................... 55

3.2 ABAP Editor im Überblick ............................................................................... 583.2.1 Modi des ABAP Editors ..................................................................... 593.2.2 Steuerung des ABAP Editors ............................................................ 60

3.3 ABAP-Programme verstehen und bearbeiten ............................................. 65

Inhalt6

3.4 ABAP-Report ausführen .................................................................................. 67

3.5 Datenbanktabelle lesen und ausgeben ........................................................ 69

3.6 Aufbereitung von Listen .................................................................................. 703.6.1 Kettensatz ........................................................................................... 713.6.2 Linien ................................................................................................... 713.6.3 Leerzeilen ............................................................................................ 71

3.7 Quellcode schreiben und editieren ............................................................... 723.7.1 Anmerkungen zum Quellcode ......................................................... 733.7.2 Listbild unseres Beispiel-Quellcodes ............................................... 77

4 Felder und Berechnungen 79

4.1 Report vorbereiten ........................................................................................... 79

4.2 Felder deklarieren ............................................................................................ 834.2.1 Variablen deklarieren ........................................................................ 834.2.2 Konstanten deklarieren ..................................................................... 87

4.3 Grundrechenarten ............................................................................................ 884.3.1 Kompatible und konvertible Datenobjekte .................................... 894.3.2 Konvertierungsregeln ........................................................................ 904.3.3 Besonderheiten bei der Division ...................................................... 91

4.4 Codebeispiel zu Feldern und Berechnungen ............................................... 924.4.1 Anmerkungen zum Quellcode ......................................................... 944.4.2 Verbesserte Listaufbereitung ............................................................ 96

5 Modifikation von Zeichenketten 99

5.1 Zeichenketten deklarieren .............................................................................. 99

5.2 Zeichenkettenoperationen .............................................................................. 1015.2.1 Zeichenketten verschieben ............................................................... 1015.2.2 Zeichenketten ersetzen ..................................................................... 1035.2.3 Zeichenketten verdichten ................................................................. 1045.2.4 Zeichenkettenfelder zusammenziehen ............................................ 1045.2.5 Zeichenketten zerlegen ..................................................................... 1065.2.6 Zeichenkettenoperationen mit direkter Positionierung ................ 106

5.3 Codebeispiel zu String-Operationen ............................................................ 1085.3.1 Anmerkungen zum Quellcode ......................................................... 1105.3.2 Ausgabe des Quellcodes ................................................................... 113

6 Debugging von Programmen 115

6.1 Überblick ............................................................................................................ 115

6.2 Aufruf des ABAP Debuggers ........................................................................... 115

6.3 Arbeiten mit dem ABAP Debugger ............................................................... 118

7Inhalt

6.3.1 Felder-Modus .................................................................................... 1186.3.2 Tabellen-Modus ................................................................................ 1226.3.3 Watchpoints-Modus ........................................................................ 1246.3.4 Breakpoints-Modus ........................................................................... 1266.3.5 Statische Breakpoints ........................................................................ 129

7 Modifikation von transparenten Datenbanktabellen 131

7.1 Datenbanktabelle kopieren ............................................................................ 132

7.2 Ergänzung von Nicht-Schlüsselfeldern ......................................................... 1367.2.1 Festwerte in Domäne einpflegen .................................................... 1367.2.2 Besonderheiten bei Währungs- und Mengenfeldern ................... 1387.2.3 Fremdschlüssel pflegen ..................................................................... 1417.2.4 Append-Strukturen pflegen ............................................................. 1487.2.5 Include-Struktur einpflegen ............................................................. 151

7.3 Schlüsselfelder von Tabellen manipulieren ................................................. 155

7.4 Tabellenfelder löschen .................................................................................... 159

7.5 Tabellen löschen ............................................................................................... 160

8 Rechnen mit Datum und Zeit, Mengen und Währungen 165

8.1 Felddeklarationen ............................................................................................ 165

8.2 Rechnen mit Datumsfeldern .......................................................................... 167

8.3 Rechnen mit Zeitfeldern ................................................................................. 174

8.4 Rechnen mit Mengen- und Währungsfeldern ............................................ 178

8.5 Codebeispiel zu Datums-, Zeit- und Währungsfeldern ............................. 1808.5.1 Anmerkungen zum Quellcode ......................................................... 1868.5.2 Ausgabe des Quellcodes ................................................................... 191

9 Daten in einer Datenbanktabelle verändern 193

9.1 Berechtigungskonzept ..................................................................................... 194

9.2 Sperrkonzept ..................................................................................................... 195

9.3 Open SQL-Anweisungen ................................................................................ 1989.3.1 Neuen Datensatz anlegen ................................................................ 1999.3.2 Bestehenden Datensatz ändern ....................................................... 2019.3.3 Datensatz modifizieren ..................................................................... 2029.3.4 Datensatz löschen ............................................................................. 203

Inhalt8

9.4 Codebeispiel zu INSERT .................................................................................. 2059.4.1 Anmerkungen zum Quellcode ......................................................... 2079.4.2 Ausgabe des Quellcodes ................................................................... 208

9.5 Codebeispiel zu UPDATE ................................................................................ 2099.5.1 Anmerkungen zum Quellcode ......................................................... 2119.5.2 Ausgabe des Quellcodes ................................................................... 212

9.6 Codebeispiel zu MODIFY ............................................................................... 2129.6.1 Anmerkungen zum Quellcode ......................................................... 2149.6.2 Ausgabe des Quellcodes ................................................................... 215

9.7 Codebeispiel zu DELETE ................................................................................. 2169.7.1 Anmerkungen zum Quellcode ......................................................... 2189.7.2 Ausgabe des Quellcodes ................................................................... 219

10 Programmablaufsteuerung und logische Ausdrücke 221

10.1 Kontrollstrukturen ............................................................................................ 221

10.2 Arbeiten mit Mustern ...................................................................................... 222

10.3 Verzweigungen ................................................................................................. 22510.3.1 IF-Struktur .......................................................................................... 22510.3.2 CASE-Struktur .................................................................................... 228

10.4 Schleifen ............................................................................................................. 23010.4.1 SELECT-Schleife ................................................................................. 23010.4.2 DO-Schleife ........................................................................................ 23110.4.3 WHILE-Schleife .................................................................................. 23310.4.4 Abbruchanweisungen für Schleifen ................................................. 234

10.5 Logische Ausdrücke ......................................................................................... 23710.5.1 Einfache logische Ausdrücke ............................................................ 23810.5.2 Verknüpfte logische Ausdrücke ....................................................... 240

10.6 Codebeispiel zu IF ............................................................................................ 24310.6.1 Anmerkungen zum Quellcode ......................................................... 24610.6.2 Ausgabe des Quellcodes ................................................................... 248

10.7 Codebeispiel zu CASE ...................................................................................... 24810.7.1 Anmerkungen zum Quellcode ......................................................... 25010.7.2 Ausgabe des Quellcodes ................................................................... 252

10.8 Codebeispiel zu DO und Abbruchbedingungen ......................................... 25310.8.1 Anmerkungen zum Quellcode ......................................................... 25610.8.2 Ausgabe des Quellcodes ................................................................... 257

10.9 Codebeispiel zu WHILE und logischen Ausdrücken .................................. 25810.9.1 Anmerkungen zum Quellcode ......................................................... 26110.9.2 Ausgabe des Quellcodes ................................................................... 263

9Inhalt

11 Selektionsbildschirme 265

11.1 Ereignisse ........................................................................................................... 26611.1.1 Reihenfolge von Ereignissen ............................................................ 26611.1.2 Beispiele für Ereignisse ..................................................................... 268

11.2 Einfache Selektionen ....................................................................................... 26911.2.1 PARAMETERS-Anweisung ................................................................ 26911.2.2 Zusätze zur PARAMETERS-Anweisung ........................................... 271

11.3 Komplexe Selektionen ..................................................................................... 27511.3.1 SELECT-OPTIONS-Anweisung ......................................................... 27611.3.2 Mehrfachselektionen ........................................................................ 27711.3.3 Zusätze zur SELECT-OPTIONS-Anweisung .................................... 280

11.4 Selektionstexte verwenden ............................................................................ 28111.4.1 Textelemente im Überblick .............................................................. 28111.4.2 Selektionstexte anlegen .................................................................... 281

11.5 Selektionsbildschirm speichern ..................................................................... 28411.5.1 Selektionsvariante anlegen ............................................................... 28511.5.2 Report mit Variante starten .............................................................. 290

11.6 Ergänzende Textobjekte .................................................................................. 29111.6.1 Textsymbole anlegen ........................................................................ 29111.6.2 Nachrichten anlegen ......................................................................... 293

11.7 Selektionsbildschirm frei gestalten ............................................................... 29611.7.1 Einzelne Zeile gestalten .................................................................... 29611.7.2 Zeilenblock gestalten ........................................................................ 298

11.8 Codebeispiel zum Selektionsbildschirm (einfache Form) ......................... 29911.8.1 Anmerkungen zum Quellcode ......................................................... 30311.8.2 Ausgabe des Quellcodes ................................................................... 304

11.9 Codebeispiel zum Selektionsbildschirm (erweiterte Form) ...................... 30511.9.1 Anmerkungen zum Quellcode ......................................................... 31011.9.2 Ausgabe des Quellcodes ................................................................... 314

12 Interne Tabellen 317

12.1 Sinn und Zweck interner Tabellen ................................................................. 317

12.2 Aufbau und Arten von internen Tabellen ..................................................... 319

12.3 Interne Standardtabelle anlegen ................................................................... 32212.3.1 Traditionelle Schreibweise mit Kopfzeile ....................................... 32212.3.2 Objektorientierte Schreibweise ohne Kopfzeile ............................ 323

12.4 Interne Standardtabelle füllen ....................................................................... 32612.4.1 Interne Tabelle mit Kopfzeile füllen ................................................ 32612.4.2 Interne Tabelle mit Workarea füllen ............................................... 331

Inhalt10

12.5 Interne Tabelle zeilenweise verarbeiten ....................................................... 33512.5.1 Interne Tabelle mit Kopfzeile verarbeiten ...................................... 33512.5.2 Interne Tabelle mit Workarea verarbeiten ..................................... 341

12.6 Inhalte von internen Tabellen löschen ......................................................... 34412.6.1 Interne Tabellen mit Kopfzeile löschen .......................................... 34412.6.2 Workareas und interne Tabellen mit Workarea löschen .............. 345

12.7 Codebeispiel zu ITAB mit Kopfzeile .............................................................. 34612.7.1 Anmerkungen zum Quellcode ......................................................... 35112.7.2 Ausgabe des Quellcodes im ABAP Debugger verfolgen ............... 354

12.8 Codebeispiel zu ITAB mit Workarea ............................................................. 35912.8.1 Anmerkungen zum Quellcode ......................................................... 36512.8.2 Ausgabe des Quellcodes im ABAP Debugger verfolgen ............... 367

13 Programme modularisieren 371

13.1 Überblick ............................................................................................................ 371

13.2 Quelltext-Module ............................................................................................. 373

13.3 Prozeduren ......................................................................................................... 37513.3.1 Unterprogramme ............................................................................... 37513.3.2 Funktionsbausteine ........................................................................... 387

13.4 Speicherbereiche für Datenübergabe ........................................................... 40213.4.1 Globales SAP Memory ...................................................................... 40213.4.2 Lokales SAP Memory ......................................................................... 40313.4.3 ABAP Memory .................................................................................... 403

13.5 Codebeispiele zur Modularisierung .............................................................. 40413.5.1 Anmerkungen zum Quellcode ......................................................... 41213.5.2 Ausgabe des Quellcodes ................................................................... 414

13.6 Codebeispiele zum Aufruf fremder Reports ................................................ 41513.6.1 Anmerkungen zum Quellcode ......................................................... 42313.6.2 Ausgabe des Quellcodes ................................................................... 426

Der Autor 427

Index 429

11Vorwort

Vorwort

Ziel des BuchesDieses Buch will ein Lehr- und Lernbuch für alle Interessierten sein, die indie Welt der ABAP-Programmierung einsteigen möchten. Diesem Zielordnet es (fast) alles unter: Es »lügt«, indem es vorgibt, alles wäre ganzunkompliziert. Es vereinfacht und simplifiziert, indem es technische undbetriebswirtschaftliche Probleme auf ein Minimum reduziert. Dafürnimmt es Lücken in Kauf, weil es das Thema ABAP nicht in epischer Breitebehandeln kann und will, sondern sich auf einen thematischen Kern undden roten Faden hin zum Lernziel beschränkt. Damit möchte Ihnen die-ses Buch vor allem eines vermitteln: Erfolgserlebnisse.

Der »Einstieg in ABAP« kann deshalb auch keinen allgemeinen SAP-Grundlagenkurs ersetzen, ebenso wenig vertiefende Literatur zu speziel-len ABAP-Themen, und es erhebt auch keinen Anspruch auf Vollständig-keit. Es möchte auch kein Trockenkurs sein, sondern Sie einfach nur zumLernen und Arbeiten am R/3-System motivieren. Alle dafür relevantenArbeitsschritte werden ausführlich mit Beispielen, Hintergrundinformati-onen und Quellcodebeschreibungen erklärt.

Sie werden vom einfachsten ABAP-Report über wichtige Arbeiten imABAP Dictionary zur Tabellenpflege bis hin zur modularisierten Ablauf-steuerung und komplexen Datenübergabestruktur zwischen Reportsgeführt. Dabei wird ein einfaches betriebswirtschaftliches Beispiel, einefiktive Teilnehmerverwaltung, durchgängig beibehalten und immer wie-der verwendet, um die Theorie direkt in der Praxis anzuwenden. DerSchwerpunkt dieses Buches liegt so auf der Vermittlung und Aneignungvon ABAP-Wissen, nicht auf betriebswirtschaftlichen Zusammenhängen.

ZielgruppenDamit ist es für Entwickler geschrieben, in deren Firmen ein SAP-Systemeingeführt wird. Es ist geschrieben für Berater und Projektleiter, dieABAP-Quellcode lesen und verstehen möchten und einige Änderungenselbst vornehmen wollen. Und es ist geschrieben für Studenten und Aus-zubildende, die ABAP im Rahmen ihrer Berufsausbildung lernen.

Systemvoraus-setzungen

Um den Wissenstransfer optimal ausschöpfen zu können, sollten Sieallerdings einige Voraussetzungen mitbringen: Ideal wäre es sicherlich,sich mit SAP-Grundlagen wie der Navigation im Hauptmenü schon vorabbeschäftigt zu haben. Auch Erfahrungen mit allgemeiner Programmier-logik aus anderen Programmiersprachen, Makros oder Skripten ist für denLernerfolg förderlich. Ideal wäre auch der Zugang zu einem R/3-Systemmit den entsprechenden Berechtigungen – hier genügt auch das Mini-

Vorwort12

SAP-System, das verschiedenen Büchern von SAP PRESS (http://www.sap-press.de) beiliegt oder von SAP-Kunden über die Website derSAP (http://www.sap.com) kostengünstig erworben werden kann. DasMini-SAP-System stellt die ABAP-Entwicklungsumgebung bereit – undmehr benötigen Sie für den Lernerfolg mit diesem Buch nicht.

Kapitelübersichtund Aufbau

Kapitel 1 vermittelt Ihnen das für den Einstieg in ABAP nötige Wissenüber die organisatorische und technische Architektur von SAP-Systemenund die Entwicklungsvoraussetzungen. Ferner wird die Arbeitsteilungzwischen Laufzeitumgebung und Anwendungsprogrammen gezeigtsowie die Struktur von ABAP-Reports.

Kapitel 2 liefert einen Überblick über Sinn und Zweck des ABAP Dictio-nary. Am Beispiel einer transparenten Tabelle lernen Sie das Anlegeneiner Tabelle bis zum Erfassen und Anzeigen von Tabelleneinträgen undalle nötigen Arbeiten mit Datenelementen, Domänen und technischenEinstellungen.

In Kapitel 3 legen Sie Ihren ersten ABAP-Report an, pflegen seine Eigen-schaften, erstellen den Quellcode und führen ihn aus. Gleichzeitig lernenSie die ersten ABAP-Anweisungen und die nötige Syntax kennen.

Das »Grundrechnen mit Variablen« üben Sie in Kapitel 4, betrachten dieEigenschaften von Datenobjekten und den Unterschied zwischen Kom-patibilität und Konvertibilität. Gleichzeitig lernen Sie einige Kniffe füreine bessere Listaufbereitung kennen.

In Kapitel 5 arbeiten Sie mit Zeichenketten und führen Stringoperationenin verschiedenen Varianten aus. Sie suchen Teilstrings und modifizierenZeichenketten.

Kapitel 6 ist dem Verfolgen des Programmablaufs und dem Suchen vonProgrammfehlern gewidmet. Dafür arbeiten Sie mit dem ABAP Debuggerund seinen wichtigsten Modi.

In Kapitel 7 erweitern und modifizieren Sie eine transparente Tabelle, ler-nen, was ein Fremdschlüssel ist und bauen Prüfungen für die Tabellenin-halte ein. Dazu arbeiten Sie mit Festwerten in der Domäne, Wertetabel-len und Prüftabellen. Außerdem lernen Sie Besonderheiten beiWährungs- und Mengenfeldern kennen.

In Kapitel 8 deklarieren Sie Datums- und Zeitfelder, verarbeiten sie undbetrachten ihre besonderen Eigenschaften. Zum Verständnis dienen vieleBeispiele, die auch im ABAP Debugger verfolgt und beschrieben werden.

13Vorwort

Den Inhalt einer Datenbanktabelle modifizieren Sie in Kapitel 9, fügenneue Zeilen über ABAP-Anweisungen ein und ändern und löschen beste-hende Zeilen. Auch die Risiken beim Löschen und der Datenmanipulationwerden gezeigt.

Das Anwendungsbeispiel wird langsam komplexer: In Kapitel 10 treffenSie Fallunterscheidungen, bauen Kontrollstrukturen und Verzweigungenein und lernen logische Ausdrücke kennen.

In Kapitel 11 lernen Sie, einen Report mit Eingabewerten für den Pro-grammlauf in einem Selektionsbildschirm zu versorgen. Sie erarbeitensich einfache und komplexe Selektionen und Selektionstexte und gestal-ten den Selektionsbildschirm völlig frei. Außerdem lernen Sie, was Text-symbole, Nachrichten und Varianten bedeuten, insbesondere in Zusam-menhang mit dem Selektionsbildschirm.

Kapitel 12 zeigt interne Tabellen, ihre Bedeutung und verschiedenen For-men. Sie erfahren, was eine Kopfzeile ist, lernen den Unterschied zu einerWorkarea und wichtige Anweisungen zum Verarbeiten der Tabellenzeilenkennen. Zum besseren Verständnis wird auch in diesem Arbeitsschrittbesonders Wert auf die Ablaufverfolgung im ABAP Debugger gelegt.

Kapitel 13 dient schließlich der Modularisierung von Programmen. Sieerfahren, was Quelltextmodule, interne und externe Unterprogrammesowie Funktionsbausteine sind. Ein weiterer wichtiger Punkt dieses Kapi-tels ist die Übergabe von Daten und Datenstrukturen an gerufeneModule.

Download der Codebeispiele

Um Ihnen Zeit raubende Tipparbeit zu ersparen, können Sie die Quell-codes zu allen Beispiellistings von der Website zum Buch unterhttp://www.sap-press.de herunterladen.

DanksagungNicht versäumen möchte es, mich bei meiner Frau und bei meinen Kin-dern zu bedanken. Sie haben es mir durch viel Verzicht auf unser Famili-enleben und durch häusliche »Entlastungstätigkeiten« ermöglicht, diesesBuch zu schreiben.

Allen Lesern wünsche ich viel Spaß und viel Erfolg beim Lesen und Ler-nen!

Karl-Heinz KühnhauserNürnberg, im Juli 2005

221Programmablaufsteuerung und logische Ausdrücke

10 Programmablaufsteuerung und logische Ausdrücke

Entscheidungen zu treffen ist schwer. Gesunder Menschen-verstand und logische Ausdrücke in der Programmierung scheinen manchmal widersprüchlich zu sein: Warum tut der Rechner nie das, was man meint? Hier lernen Sie die richtigen Regeln im Umgang mit dem Programmablauf.

Noch im letzten Kapitel blieb nichts anderes übrig, als beispielsweise denReturncode der DELETE-Anweisung in die Liste zu schreiben. Damit hättesich der Programmablauf überhaupt nicht geändert, wenn ein Fehler auf-getreten wäre und der Returncode einen anderen Wert als Null zurückge-liefert hätte, sondern es wäre die gleiche Liste produziert worden, nur mitkaum sinnvollen Ergebnissen.

Fallunter-scheidungen

Für die Praxis ist es sinnvoller, eine Fallunterscheidung zu treffen, um bei-spielsweise Fehlerfälle zu erkennen und gesondert zu behandeln. Viel-leicht ist es in bestimmten Fällen sogar besser, gar keine Liste mehr zuerzeugen und stattdessen das Programm mit einer Meldung zu beenden.In diesem Kapitel lernen Sie das Handwerkszeug für diese Fälle: die Pro-grammablaufsteuerung und die logischen Ausdrücke.

10.1 Kontrollstrukturen

Ein Programm hat eine Aufgabe zu lösen, die wiederum aus Teilaufgabenbesteht. Einige Teilaufgaben sind in jedem Fall zu lösen, andere nur unterbestimmten Bedingungen, manche alternativ. Zu jeder Teilaufgabe gehö-ren Anweisungen, die wiederum in Anweisungsblöcken zusammenge-fasst sind. Ein Anweisungsblock kann auch nur aus einem einzigen Kom-mando, beispielsweise einer WRITE-Anweisung bestehen, andererseitsauch komplexe Prozesse beinhalten.

Bedingung und Aktion

Unter welchen Randbedingungen ein Anweisungsblock durchlaufenwird, regeln Anweisungen für die Programmablaufsteuerung, die sogenannten Kontrollstrukturen. Sie enthalten die Bedingung und die dazu-gehörende Aktion. Die Programmablaufsteuerung hat die Aufgabe, dieTeilaufgaben sinnvoll durch Kontrollstrukturen zu verbinden. Es gibt Kon-trollstrukturen für Fallunterscheidungen und für Wiederholungen.

Programmablaufsteuerung und logische Ausdrücke222

Das mag abstrakt klingen, ist es aber nicht, denn solche Kontrollstruktu-ren existieren genauso im täglichen Leben: Wir gehen ins Kino, wenn wirZeit haben, jemand mitgeht und uns der Film interessiert – sonst bleibenwir zu Hause und lesen. Nur sagt das niemand folgendermaßen: IF Zeitund Begleitung und Interesse, THEN Kino, ELSE zu Hausebleiben und lesen, ENDIF.

Strukturanfangund -ende

Eine Kontrollstruktur hat einen Strukturanfang und ein Strukturende. Imgerade genannten Beispiel ist der Strukturanfang die Anweisung IF unddas Strukturende die Anweisung ENDIF: Beide Kontrollstrukturanweisun-gen gehören immer zusammen wie Klammern in der Mathematik. Dazwi-schen stehen die Anweisungsblöcke für die Teilaufgaben. Kontrollstruktu-ren verzweigen zu den relevanten Anweisungsblöcken oder wiederholenbestimmte Anweisungen in einer Schleife.

10.2 Arbeiten mit Mustern

Die Anweisungen für die Kontrollstrukturen müssen wie alle anderenABAP-Anweisungen auch in den Quellcode geschrieben werden. UnterUmständen kann es die Arbeit erleichtern, dabei mit Mustern zu arbeiten,denn sie fügen vorgefertigte Strukturen ab der Cursorposition in denQuellcode ein.

Muster einfügen Um ein solches Muster einzufügen, positionieren Sie den Cursor in derZeile, ab der das Muster eingefügt werden soll, und drücken den Muster-Button wie in Abbildung 10.1 gezeigt.

Es erscheint ein Fenster, in dem häufig verwendete Muster angebotenwerden, beispielsweise die SELECT-Anweisung. Andere Muster wie etwadie IF-Struktur erhalten Sie über die Zeile Anderes Muster. Da eine IF-Struktur eingefügt werden soll, geben Sie dort »IF« ein (siehe Abbildung10.2) und klicken auf den Weiter-Button. Das System fügt dann die kom-plette IF-Strukturbeschreibung in den Quellcode ein (siehe Abbildung10.3).

Abbildung 10.1 Muster einfügen

223Arbeiten mit Mustern

Initiale Anpassungen

Die Zeilen, die nicht benötigt werden, löschen Sie oder machen Sie zurKommentarzeile. Die Teile, die fehlen, also Bedingungen und Anwei-sungsblöcke, ergänzen Sie. Für den Fall, dass Sie noch nicht sicher sind,wie das Muster genau zu bezeichnen ist, können Sie nach dem Fokussie-ren des Feldes Anderes Muster den Hilfe-Button drücken (siehe Abbil-dung 10.4). Sie erhalten dann ein weiteres Fenster mit möglichen Mus-tern angezeigt: Es beginnt mit verschiedenen Mustern für Kom-mentarzeilen, enthält die Anweisungen für die Kontrollstrukturen diesesKapitels sowie weitere Muster (siehe Abbildung 10.5).

Abbildung 10.2 Auswahlfenster für Muster

Abbildung 10.3 In den Quellcode per Muster eingefügte IF-Struktur


Hier wählen Sie das relevante Muster aus – entweder durch Doppelklickoder durch Markieren mit anschließendem Klick auf den Auswählen-But-ton – und es wird daraufhin in das Auswahlfenster übernommen. DerRest funktioniert analog wie oben beschrieben.

VollständigesEinfügen

Das Einfügen von Mustern bewirkt immer ein vollständiges Einfügen derStruktur. Wenn es im Einzelfall einfacher und schneller ist, die Strukturan-

Abbildung 10.4 Andere Muster auswählen

Abbildung 10.5 Listfenster für Muster

225Verzweigungen

weisungen manuell in den Quellcode zu schreiben, spricht nichts dage-gen, dies zu tun. Dafür gewährleistet das Einfügen von Strukturen perMuster beispielsweise eine saubere Schachtelung über alle Ebenen. Beider späteren Arbeit mit Funktionsbausteinen (siehe Kapitel 13) werdenSie die Arbeit mit Mustern ebenso schätzen lernen.

10.3 Verzweigungen

Eine Verzweigung entspricht dem umgangssprachlichen »Entweder–Oder«: Ausschlaggebend, wofür man sich entscheidet, ist eine Bedingungformuliert. Diese Bedingung könnte einfach ein Zustand sein wie »Es reg-net.«, oder eine komplexe Bedingung, die aus vielen verschachteltenBedingungen zusammengesetzt ist, beispielsweise: »Qualitätsklasse 1 giltals erreicht, wenn die Qualitätskriterien 1 bis n erfüllt sind. Qualiktätskri-terium 1 ist erfüllt wenn die Qualitätsmerkmale 1 bis n erfüllt sind. Qua-litätsmerkmal 1 ist erfüllt, wenn ...«.

Operationale Bedingungen formulieren

In allen Fällen gilt aber, dass bestimmte Aktionen – im Quellcode Anwei-sungsblöcke – nur dann durchlaufen werden, wenn die Bedingung erfülltist. Mag es im umgangssprachlichen Bereich noch Interpretationsspiel-räume geben, wie eine Bedingung »genau« lautet und wann sie erfüllt ist,können im ABAP-Quellcode nur operationale, also messbare Bedingun-gen und Zustände verwendet und geprüft werden. Dazu werden Felderund Feldinhalte verglichen oder mit logischen Ausdrücken verknüpft.

10.3.1 IF-Struktur

Die einfachste Kontrollstruktur für eine Verzweigung beginnt in ABAP mitder Anweisung IF und einer Bedingung, sie endet mit der AnweisungENDIF. Zwischen den beiden Anweisungen stehen die Kommandos, dieausgeführt werden, falls die Bedingung erfüllt ist. Zu Beginn prüfen wirzunächst nur einen Feldinhalt ab, im Lauf der weiteren Arbeit werden Siesehen, dass sich für die Bedingungen der IF-Struktur beliebig komplexelogische Ausdrücke verwenden lassen.

IF ... ENDIFAngenommen, Sie möchten nur die Teilnehmer des Kurses »PC-Grund-lagen« zählen, so könnte dies beispielsweise so aussehen: Sie verarbeitenzunächst alle Sätze der Tabelle ganz normal. Doch immer dann, wenn einSatz diese besondere Bedingung erfüllt, zählen Sie die Teilnehmerzahlum 1 hoch.

IF zteilnehmer02-zzkurstitel = 'PC-Grundlagen'.tz_pc_grundlagen = tz_pc_grundlagen + 1.

ENDIF.


Hat das Feld für den Kurstitel den Inhalt »PC-Grundlagen«, ist die Bedin-gung erfüllt und der Anweisungsblock, der hier nur aus einer Zeilebesteht, wird ausgeführt. Auf diese Weise wird gezählt, wie viele Perso-nen den Kurs »PC-Grundlagen« besuchen.

ELSE Eine Verzweigung nach dem Prinzip »entweder A oder B« enthält zusätz-lich für den Fall »oder« die Strukturanweisung ELSE. Ist die Bedingungder IF-Anweisung erfüllt, wird der erste Anweisungsblock ausgeführt,ansonsten der zweite Anweisungsblock nach der ELSE-Anweisung.

Im Beispiel werden im ersten Anweisungsblock die Teilnehmer für denKurs »SAP-Grundlagen« gezählt: Im zweiten Anweisungsblock wird einZähler für alle restlichen Teilnehmer gebildet. Gezählt wird also in jedemFall. Nur welcher Zähler erhöht wird, hängt von der Bedingung ab.

IF zteilnehmer02-zzkurstitel = 'SAP-Grundlagen'.tz_sap_grundlagen = tz_sap_grundlagen + 1.

ELSE.tz_sonst = tz_sonst + 1.

ENDIF.

ELSEIF Die dritte Möglichkeit, mit der IF-Anweisung zu arbeiten, prüft zunächstwieder eine Bedingung. Ist sie nicht erfüllt, wird eine zweite Bedingungmit ELSEIF geprüft. Ist diese auch nicht erfüllt, wird eine dritte Bedin-gung mit ELSEIF geprüft usw. Das Spielchen lässt sich unbegrenzt fort-setzen und kann für die restlichen Fälle auch noch mit einer ELSE-Anwei-sung abgeschlossen werden.

Dazu folgendes Beispiel:

IF zteilnehmer02-zzkurstitel = 'Netzwerktechnik'.tz_netzwerktechnik = tz_netzwerktechnik + 1.

ELSEIF zteilnehmer02-zzkurstitel = 'PC-Grundlagen'.tz_pc_grundlagen = tz_pc_grundlagen + 1.

ELSEIF zteilnehmer02-zzkurstitel = 'SAP-Grundlagen'.tz_sap_grundlagen = tz_sap_grundlagen + 1.

ELSE.tz_sonst = tz_sonst + 1.

ENDIF.

Die erste Bedingung soll dann erfüllt sein, wenn im Feld für die Kursbe-zeichnung der Wert »Netzwerktechnik« enthalten ist. Im ersten Verarbei-tungsblock werden dann die Teilnehmer für den Kurs »Netzwerktechnik«gezählt. Anschließend prüft das System keine weiteren Bedingungen

227Verzweigungen

mehr, sondern geht zu ENDIF und setzt das Programm mit der erstenAnweisung nach der IF-Struktur fort.

Eins, zwei oder drei

Ist die erste Bedingung nicht erfüllt, wird geprüft, ob die zweite Bedin-gung erfüllt ist, ob also die Kursbezeichnung »PC-Grundlagen« lautet. Istdie zweite Bedingung erfüllt, wird der zweite Anweisungsblock ausge-führt und der Zähler für die Teilnehmer am Kurs »PC-Grundlagen«erhöht. Wenn die zweite Bedingung ebenfalls nicht erfüllt ist, wird diedritte Bedingung (»SAP-Grundlagen«) geprüft. Trifft sie zu, werden dieTeilnehmer dieses Kurses hochgezählt.

Falls die dritte Bedingung auch nicht erfüllt ist, tritt der »Sonst-Fall« einund der Zähler für die bis dahin nicht erfassten Kurse und Teilnehmerwird erhöht. Danach springt das System zur Anweisung ENDIF und dannzum nächsten Kommando nach der IF-Struktur.

SammelschachtDie Anweisung ELSE gewährleistet, dass – salopp ausgedrückt –irgendeine Bedingung immer erfüllt ist: Entweder die Daten durchlaufendie Verarbeitung und die Anweisungsblöcke der IF- und ELSEIF-Struktu-ren oder sie durchlaufen den Anweisungsblock für die bis dahin nichtzutreffenden Bedingungen. ELSE ist gewissermaßen der »Sammel-schacht«, für all die Fälle, auf die bislang in der Struktur noch keineBedingungen zutrafen.

IF-Strukturen schachteln

Natürlich können IF-Strukturen auch geschachtelt werden. Dabei istaber darauf zu achten, dass Strukturanfang und Strukturende richtigzueinander passen. Wie in der Mathematik die Klammerebenen, müssenauch hier die Schachtelungsebenen sauber getrennt werden. Es ist eineFrage des Arbeitsstils, der gültigen Programmierkonventionen und derTransparenz, inwieweit Sie geschachtelte IF-Strukturen durch Verknüp-fung mehrerer logischer Ausdrücke ersetzen. Dazu zwei Beispiele:

Beispiel 1: Geschachtelte IF-Strukturen

IF Bedingung_1IF Bedingung_2Anweisungsblock_1

ENDIFENDIF

Beispiel 2: Verknüpfte logische Ausdrücke

IF Bedingung_1 und Bedingung_2Anweisungsblock_1

ENDIF


LogischeAusdrücke

Beide Beispiele sind inhaltlich gleich: Anweisungsblock_1 wird nur dannausgeführt, wenn beide Bedingungen erfüllt sind.

Grundsätzlich geht Transparenz aber vor Genialität. Wenn durch Ver-knüpfen von logischen Ausdrücken Konstrukte entstehen, die Bildschirm-seiten füllen, sollten Sie bitte an Dritte denken, die diese Konstrukte spä-ter verstehen und ändern müssen. In solchen Fällen sollte geprüftwerden, ob durch Schachtelung vielleicht eine bessere Lesbarkeit, Trans-parenz und Änderbarkeit erzielt werden könnte. Wenn dies der Fall ist, istdie Schachtelung vorzuziehen.

10.3.2 CASE-Struktur

CASE ... ENDCASE Starten wir für die CASE-Struktur zunächst wieder mit einer Analogie ausdem täglichen Leben: Eine Fußgängerampel ist entweder rot oder grün.Im Fall rot bleiben wir stehen, im Fall grün gehen wir. Wir blicken nur aufdie Ampel, weitere Bedingungen interessieren uns nicht.1

Ähnlich wie der sture Fußgänger »blickt« die CASE-Struktur nur auf einObjekt. Beim Fußgänger ist es die Ampel, bei der CASE-Struktur ein Feld,ein Datenobjekt. Dabei wird eine Fallunterscheidung getroffen und derInhalt des Felds wird abgefragt. Stimmen Bedingung und Feldinhalt über-ein, wird der zugehörige Anweisungsblock ausgeführt, sonst nicht. Auchin einer CASE-Struktur wird immer nur ein Anweisungsblock abgearbei-tet. Nach dem Anweisungsblock verzweigt das System zu ENDCASE, ohneweitere Feldinhalte zu prüfen, geht danach zum ersten Kommando nachder CASE-Struktur und setzt die Verarbeitung dort fort.

Unterschiedezwischen IF- und

CASE-Struktur

Während also die IF-Struktur komplexe logische Bedingungen prüfenkann, trifft die CASE-Struktur Fallunterscheidungen je nach Inhalt nureines einzigen Feldes. Vereinfacht ausgedrückt: Bei der IF-Struktur kannes den Fall geben, dass es regnet und die Sonne scheint. Bei der CASE-Struktur gibt es diesen Fall nicht, entweder es scheint die Sonne oder esregnet.

EindeutigeAbstimmung

Wie so oft kommt es also wieder einmal auf die Aufgabenstellung an. DieCASE-Struktur ist immer dann im Vorteil, wenn es gelingt, eine Bedingungeindeutig mit einem Feldinhalt abzustimmen.

In unserem Beispiel, in dem die Teilnehmer eines Kurses gezählt werden,könnte man auch sehr gut mit der CASE-Struktur arbeiten: Sie prüfen den

1 Die Konsequenzen einer derart eingeschränkten Sichtweise können im wahrenLeben zwar fatal sein, aber lassen wir das hier einmal aus dem Spiel.

229Verzweigungen

Inhalt des Tabellenfeldes ZTEILNEHMER02-ZZKURSTITEL, je nach Feldin-halt wird in den entsprechenden Anweisungsblock verzweigt.

Danach geht das System zu ENDCASE und setzt die Verarbeitung mit demersten Kommando nach der CASE-Struktur fort. Die StrukturanweisungWHEN OTHERS übernimmt dabei dieselbe Funktion wie die AnweisungELSE bei der IF-Struktur. Vergleichen Sie dazu den folgenden Beispiel-code:

CASE zteilnehmer02-zzkurstitel.WHEN 'Netzwerktechnik'.tz_netzwerktechnik = tz_netzwerktechnik + 1.

WHEN 'PC-Grundlagen'.tz_pc_grundlagen = tz_pc_grundlagen + 1.

WHEN OTHERS.tz_sonst = tz_sonst + 1.

ENDCASE.

Anwendungsfall: Returncode

Ein typischer Anwendungsfall für die der CASE-Struktur ist die Auswer-tung des Returncodes. Es ist eindeutig, welche Anweisung einen Return-code zurückgibt, wie die Werte für den Returncode sein können und wel-che Fehlerfälle damit gemeint sind. Je nach Erfolg oder Misserfolg einerAnweisung hat SY-SUBRC einen eindeutigen Inhalt, dieser Inhalt wirdüber die CASE-Struktur abgefragt.

Fehlerfälle differenzieren

Damit können für den Erfolgsfall und alle dokumentierten Fehlerfälleeigene Anweisungsblöcke geschrieben werden. Bei jeder ABAP-Anwei-sung ist hinterlegt, ob ein Returncode generiert wird, welcher Return-code zurückgeliefert werden kann und welche Fehlerfälle damit definiertwerden. Entsprechend kann man dann die Anweisungsblöcke gestalten.Ziel dieser Bemühungen ist es, das Programm trotz eines Fehlers zu einem»ordnungsgemäßen« Ende zu führen, bzw. sinnvolle Alternativprozesseeinzuleiten.

Suchen Sie beispielsweise mit dem SELECT-Kommando in einer Tabelle,liefert das Kommando den Returncode 0, wenn es mindestens einen Satzin der Tabelle lesen konnte. Konnte kein einziger passender Satz gelesenwerden, liefert die Anweisung den Returncode 4 zurück. Unter Return-code 0 steht also der Anweisungsblock für den günstigen Okay-Fall. Istder Returncode 4, wird die Fehlerbehandlungsroutine durchlaufen. Ver-gleichen Sie dazu folgenden Codeausschnitt:

CASE sy-subrc.WHEN 0.


* Okay-FallWRITE: / tz_netzwerktechnik,

'Teilnehmer für den Kurs Netzwerktechnikgefunden'.

WHEN 4.* Fehlerfall

WRITE: / 'keine Teilnehmer für den KursNetzwerktechnik gefunden'.

WHEN OTHERS.* Kann nicht sein, anderer sy-subrc wird von der

Anweisung nicht geliefertENDCASE.

Es gibt durchaus Anweisungen, die mehrere Fehler differenzieren kön-nen. Auch Funktionsbausteine liefern häufig differenzierte Fehlermeldun-gen zurück. CASE-Strukturen mit sechs oder acht verschiedenen Fehler-behandlungsblöcken sind in der Praxis keine Seltenheit.

CASE-Strukturen können genau wie IF-Strukturen geschachtelt werden.Dabei müssen Sie ebenfalls auf eine saubere Trennung der Ebenen ach-ten. Die Kombination von IF- und CASE-Strukturen ist ebenfalls möglich.

10.4 Schleifen

Schleifen, auch Wiederholungen genannt, führen Anweisungsblöckemehrfach aus. Dabei werden Schleifen ohne Bedingung und mit Bedin-gung unterschieden.

10.4.1 SELECT-Schleife

SELECT ...ENDSELECT

Mit der SELECT-Anweisung kennen Sie bereits die erste Schleife, der esdie Möglichkeit gibt, eine Bedingung mit der Anweisung zu verknüpfen.Wenn Sie in einer Tabelle Sätze lesen, können Sie über eine Selektionsbe-dingung filtern und nur die Sätze lesen, die diese Bedingung erfüllen.Möchten Sie in der Teilnehmertabelle nur die Sätze lesen, bei denen alsKurstitel »Netzwerktechnik« steht, schreiben Sie:

SELECT * FROM zteilnehmer02 WHERE zzkurstitel = 'Netzwerktechnik'. tz_netzwerktechnik = tz_netzwerktechnik + 1.ENDSELECT.

231Schleifen

Der Anweisungsblock, der hier nur aus einer Zeile besteht – hinter derBedingung, die die Teilnehmeranzahl erhöht –, wird nur für die Treffer-sätze ausgeführt, sonst nicht.

10.4.2 DO-Schleife

DO ... ENDDODie Struktur dieser Schleife beginnt mit der Anweisung DO und endet mitder Anweisung ENDDO. Dazwischen steht der zu wiederholende Anwei-sungsblock.

DOAnweisungsblock

ENDDO

Vorsicht vor Endlosschleifen!

Bereits in diesem Moment sollten bei Ihnen die Alarmglocken schrillen,denn es in dieser Anweisung nicht angegeben, wie oft der Anweisungs-block ausgeführt werden soll, ob die Wiederholung ewig laufen oderwann sie abgebrochen werden soll. Doch keine Panik, im Folgenden wer-den einige Möglichkeiten vorgestellt, wie Sie die Zahl der Schleifendurch-läufe begrenzen und Schleifen abbrechen.

Bedingung in der DO-Schleife

Bei der DO-Schleife ist zunächst wichtig, dass der Anweisungsblock in derStruktur das erste Mal angelaufen wird, ohne dass das System vorher eineBedingung prüft. Selbst wenn man ein Kriterium zum Verlassen derSchleife einbaut, werden die Kommandos vor dem Abbruchkriteriumdennoch mindestens einmal ausgeführt. Der Ort der Abbruchbedingungim Anweisungsblock ist deshalb für die Programmlogik sehr bedeutsam.

TIMESUm die Zahl der Schleifendurchläufe zu begrenzen, können Sie eineObergrenze von Durchläufen festlegen. Wollen Sie, dass eine Schleifemaximal zwölfmal durchlaufen wird, schreiben Sie:

DO 12 TIMES.

Statt die Anzahl von Durchläufen fix als Zahl anzugeben, können Sie die-sen Wert auch in einer Variablen hinterlegen. Weisen Sie beispielsweiseder Variablen MONATE vom Typ i den Wert 6 zu, lautet die Anweisung:

DO monate TIMES.

Die Schleife wird dann sechsmal durchlaufen, danach wird das Programmmit der ersten Anweisung nach ENDDO fortgesetzt.

SY-INDEXWährend der Anweisungsblock in der Schleife wiederholt wird, führt dasSystem automatisch einen Schleifenzähler mit. Im Feld SY-INDEX steht zujedem Schleifendurchlauf der aktuelle Wert, beim ersten Durchlauf also


die 1, beim zweiten Durchlauf die 2 usw. Dieser Schleifenzähler kannsowohl im Debugging-Modus zur Fehlersuche als auch als Abbruchkrite-rium sehr nützlich sein.

DO-Schleifen sind schachtelbar und SY-INDEX wird im Falle einer Schach-telung vom System getrennt für jede Ebene extra geführt. Doch auch hiersollten Sie besondere Vorsicht walten lassen: Durch das Schachteln vonSchleifen kann sehr schnell eine erhebliche Systembelastung entstehen.Zum Beispiel mit folgendem Konstrukt:

DO 50 TIMES.Anweisungsblock_1DO 100 TIMES.Anweisungsblock_2

ENDDO.ENDDO.

GeschachtelteDO-Schleifen

In diesem Beispiel gibt es eine innere und eine äußere Schleife. Dieäußere Schleife wird 50-mal ausgeführt. Zu jedem Durchlauf des Anwei-sungsblocks 1 wird die innere Schleife 100-mal durchlaufen, sodassAnweisungsblock_2 somit 100 mal 50, also 5.000-mal ausgeführt.

Ablauflogikder Uhr

Zum Verständnis, wie schnell die Zahl der Schleifendurchläufe ausufernkann, hilft ein Blick auf die Uhr – und zwar auf ihre Ablauflogik. Ein Taghat 24 Stunden, eine Stunde hat 60 Minuten und eine Minute 60 Sekun-den. Bildet man diese »Programmlogik« in ABAP ab, ergeben sich dreigeschachtelte Schleifen. Im Kern steht ein Anweisungsblock, der dieberechnete Zeit zur Anzeige übermittelt, und in diesem Beispiel nur auseiner Zeile besteht, der WRITE-Anweisung als Stellvertreter für die Anzei-geaufbereitung:

DO 24 TIMES.min = 0.DO 60 TIMES.sek = 0.DO 60 TIMES.WRITE: / std, min, sek.sek = sek + 1.

ENDDO.min = min + 1.

ENDDO.std = std + 1.

ENDDO.

233Schleifen

1.440 SeitenDer Verarbeitungsblock im Kern zur Anzeige der Zeit wird an einem Tag60 mal 60 mal 24, also 86.400-mal durchlaufen. Dabei würden 86.400Zeilen in einer Liste ausgegeben. Unterstellt man 60 Zeilen pro Seite,wäre das eine Liste mit 1.440 Seiten! Damit es erst gar nicht so weitkommt, sollten Sie also wohl überlegt vorgehen, Schleifen gründlich pla-nen, diese mit dem Debugger verfolgen und Abbruchbedingungen ein-bauen.

10.4.3 WHILE-Schleife

WHILE ... ENDWHILE

Im Unterschied zur DO-Schleife prüft die WHILE-Schleife eine Bedingung,bevor der Anweisungsblock das erste Mal ausgeführt wird. Gilt die Bedin-gung, wird der Anweisungsblock ausgeführt. Danach prüft das Systemwieder, ob die Bedingung gültig ist. Falls ja, wird der Anweisungsblocknoch einmal ausgeführt usw. Das Spiel wiederholt sich endlos, es seidenn, die Bedingung gilt nicht mehr, weil sie beispielsweise im Anwei-sungsblock verändert oder ein anderes Abbruchkriterium erreicht wurde.

Bedingung vor der WHILE-Schleife

Die Syntax der WHILE-Schleife ist relativ einfach. Die Struktur beginnt mitder Anweisung WHILE und einer Bedingung, anschließend folgt derAnweisungsblock, der ausgeführt wird, falls die Bedingung erfüllt ist.Danach steht für das Strukturende die Anweisung ENDWHILE.

WHILE BedingungAnweisungsblock

ENDWHILE

StoppuhrIm folgenden Beispiel läuft eine Stoppuhr rückwärts und startet mit einerVorlauffrist in Sekunden. Ist der Wert für die Sekunden auf null herunter-gezählt, soll der Startschuss erfolgen. Lässt man einmal das Problem bei-seite, wie die Anzahl von Quarzschwingungen gezählt wird, damit eineSekunde auch genau die richtige Zeiteinheit im Programm abbildet, undbetrachtet nur den Anteil der Programmierlogik, dann gilt: Solange dieSekunden größer sind als null, soll eine weitere Sekunde abgezogen wer-den. Die Anweisungen für die Schleife lauten:

WHILE sek > 0.WRITE: / sek.sek = sek – 1.

ENDWHILE.

Natürlich muss vor der Schleife der Wert für Sekunden gesetzt sein undes wird geprüft, ob der Feldinhalt größer ist als null. Falls ja, wird derWert ausgegeben und um 1 vermindert. Dann wird erneut geprüft, ob


der Wert größer ist als null usw. Hat das Feld SEK den Wert 0 erreicht,wird die Anweisung nicht mehr ausgeführt und zu ENDWHILE verzweigt.Anschließend setzt das System die Programmausführung mit der erstenAnweisung nach ENDWHILE fort.

SY-INDEX Die Anzahl der Schleifendurchläufe wird genau wie bei der DO-Schleife imFeld SY-INDEX protokolliert. SY-INDEX kann im Anweisungsblock gele-sen und für die Programmsteuerung ausgewertet werden.

Natürlich kann man WHILE-Schleifen ebenso wie DO-Schleifen auchschachteln. Die Hinweise, die bei den DO-Schleifen hierzu gegeben wur-den, gelten analog auch für die WHILE-Schleifen.

Schleifen-konstruktion

Welche Schleifenstruktur im konkreten Fall besser geeignet ist, ist wiedervon Aufgabenstellung abhängig. Wichtig zu merken ist für die Schleifen-konstruktion der prinzipielle Unterschied zwischen beiden Schleifen: Beider WHILE-Schleife wird zuerst eine Bedingung geprüft. Ist sie erfüllt,führt das System die erste Anweisung in der Schleife aus, sonst nicht. Beider DO-Schleife wird die erste Anweisung in der Schleife ausgeführt, ohnedass vorher eine Bedingung geprüft wurde.

10.4.4 Abbruchanweisungen für Schleifen

Zum Abbruch von Schleifen kennt ABAP mehrere verschiedene Abbruch-anweisungen.

CONTINUE Die erste dieser Anweisungen, CONTINUE, ist ausschließlich zum Abbrucheines Anweisungsblocks innerhalb einer Schleife gedacht. Steht die CON-TINUE-Anweisung mitten in einem Anweisungsblock, wird der Rest derAnweisungen dieses Blocks nicht mehr ausgeführt und ein neuer Schlei-fendurchlauf gestartet, falls die Bedingungen für einen neuen Durchlaufnoch gelten. Da das Kommando selbst keine Bedingung prüft, packt manes oft in eine Verzweigung, über deren Bedingung der Programmlaufgesteuert wird. Falls die Bedingung erfüllt ist, wird das CONTINUE-Kom-mando ausgeführt, der Anweisungsblock beendet, ein neuer Durchlaufgeprüft und eventuell gestartet. Die Struktur der CONTINUE-Anweisungist relativ einfach:

IF Bedingung_1CONTINUE

ENDIF

Um in der Teilnehmertabelle die Sätze der Kursteilnehmer zu verarbeiten,die nach dem 01.01.1970 geboren sind, schreiben Sie beispielsweise:

235Schleifen

SELECT * FROM zteilnehmer02.IF zteilnehmer02-tgeburtsdatum LT '19700101'.CONTINUE.

ENDIF.* Anweisungsblock_1ENDSELECT.

LTDie Bedingung nach der IF-Anweisung ist ein logischer Ausdruck. LT istdabei der Operand für »kleiner als«, mit dem die beiden Werte verglichenwerden. Liest das System einen Satz mit einem Geburtsdatum vordem 01.01.1970, wird der – hier nicht weiter ausgeführte – Anweisungs-block_1 nicht ausgeführt, sondern sofort der nächste Satz gelesen. Nurdie Sätze, bei denen das Geburtsdatum am oder nach dem 01.01.1970liegt, gelangen in die Verarbeitung des Anweisungsblocks.

CHECKDie zweite Abbruchanweisung CHECK ist mächtiger: Falls die Anweisungin einer Schleife ausgeführt wird, wird die Verarbeitung des Anweisungs-blocks beendet und der nächste Schleifendurchlauf gestartet, sofern dieBedingungen dafür noch gelten. In diesem Sinne könnte man die Anwei-sung CHECK als Kombination aus den Anweisungen IF und CONTINUEbezeichnen. Sie schreiben einfach:

CHECK Bedingung

Ist die Bedingung erfüllt, werden alle Anweisungen des Anweisungs-blocks nach dem CHECK-Kommando ausgeführt. Ist die Bedingung dage-gen nicht erfüllt, werden alle nachstehenden Kommandos des Anwei-sungsblocks übersprungen und nach Prüfung der Bedingungen wird einneuer Schleifendurchlauf gestartet.

Selektion nach dem Geschlechts-schlüssel

Interessiert Sie beispielsweise eine Verteilung der Kursteilnehmer nachGeschlecht, könnten Sie die Sätze entsprechend dem Geschlechtsschlüs-sel selektieren:

SELECT * FROM zteilnehmer02.CHECK zteilnehmer02-tgeschlecht = 'W'.

* AnweisungsblockENDSELECT.

In der Schleife wird geprüft, ob die Bedingung des Geschlechtsschlüsselserfüllt ist. Falls ja, wird der Anweisungsblock ausgeführt; falls nein, wirdder nächste Satz gelesen und geprüft.


Wundern Sie sich nicht, falls Sie später einmal die Anweisung CHECKaußerhalb einer Schleife im Quellcode finden. CHECK kann nicht nurSchleifendurchläufe beenden, sondern auch andere Verarbeitungsblöckewie Unterprogramme oder Ereignisse. Die CHECK-Anweisung wirkt immerauf die Struktur und auf diejenige Ebene, in der sie ausgeführt wird. ImOkay-Fall werden die nachstehenden Anweisungen ausgeführt, sonstwird der jeweilige Verarbeitungsblock beendet.

EXIT Die dritte Anweisung EXIT ist ebenfalls mächtig: Sie beendet nicht nurden Anweisungsblock, sondern die Schleifenverarbeitung an sich. DasSystem verzweigt zum Ende der Struktur und setzt die Programmausfüh-rung mit der ersten Anweisung nach dem Strukturende fort. Dabeibezieht sich das Kommando immer auf die Ebene, in der es ausgeführtwird: Es beendet die Verarbeitung auf dieser Ebene und bewirkt die Pro-grammfortsetzung auf der nächsthöheren, äußeren Ebene.

Steht die ausgeführte EXIT-Anweisung bei zwei geschachtelten Schleifenbeispielsweise in der inneren Schleife, wird diese beendet und das Pro-gramm mit der Anweisung nach dem Strukturende der inneren Schleifefortgesetzt, also eine Ebene höher in der äußeren Schleife. Steht dieEXIT-Anweisung hingegen in der äußeren Schleife und wird dort ausge-führt, wird die äußere Schleife beendet und mit der ersten Anweisungnach ihrem Strukturende fortgesetzt.

AbsichtlicherZeitabbruch

Zur Verdeutlichung soll wieder das Zeitmesserbeispiel dienen: Dieses Mallassen Sie ihn aber nicht durchlaufen, sondern Sie brechen die Schleifenmit der EXIT-Anweisung ab, um die Wirkung zu beobachten. In derinnersten der drei Schleifen steht ein Anweisungsblock. Hat SY-INDEX fürdie innerste Schleife den Wert 3, wird die innerste Schleife beendet undzur mittleren Schleife verzweigt. Der Anweisungsblock wurde aber zuvornoch ausgeführt. Hat in der mittleren Schleife SY-INDEX den Wert 3, wer-den die nachfolgenden Anweisungen der mittleren Schleife nicht mehrausgeführt, die dritte Schleife und ihr Anweisungsblock werden also über-sprungen. Das System geht zur äußeren Schleife und startet den nächstenSchleifendurchlauf auf dieser Ebene. Hat auch der SY-INDEX der äußerenSchleife den Wert 3, wird auch diese Schleife beendet.

DO 24 TIMES.IF sy-index = 3.EXIT.

ENDIF.min = 0.DO 60 TIMES.

237Logische Ausdrücke

IF sy-index = 3.EXIT.

ENDIF.sek = 0.DO 60 TIMES.

* Anweisungsblocksek = sek + 1.IF sy-index = 3.EXIT.

ENDIF.ENDDO.min = min + 1.

ENDDO.std = std + 1.

ENDDO.

Abbruchbedin-gungen sind kontextsensitiv

Wie die Anweisung CHECK ist die Wirkung der Anweisung EXIT abhängigvon der Struktur, also der Ebene, in der sie ausgeführt wird. Wird dieAnweisung in einer Schleife ausgeführt, wird die Schleife abgebrochen.Wird die Anweisung in einem Unterprogramm ausgeführt, wird dasUnterprogramm abgebrochen und in der übergeordneten Struktur wei-tergearbeitet. Dasselbe gilt für Ereignisse: Ein ausgeführtes EXIT-Kom-mando in einem Ereignis beendet das Ereignis und das System setzt mitder Verarbeitung des nächsten Ereignisses fort. Sind keine weiteren Ereig-nisse deklariert und Anweisungen dafür vorgesehen, wird das Programmbeendet. Im Zusammenhang mit dem Beenden von Ereignissen gibt esnoch weitere Möglichkeiten, auf die hier aber nicht weiter eingegangenwerden soll.

Die beschriebenen Abbruchbedingungen funktionieren bei allen Schlei-fenarten gleich. Aus diesem Grund wurde nur jeweils ein Beispiel für eineAbbruchbedingung beschrieben.

10.5 Logische Ausdrücke

Dies ... oder das?Auch im täglichen Leben müssen wir uns permanent entscheiden. Aller-dings laufen menschliche Entscheidungen nicht immer ganz logisch ab.Solange Computer aber nicht in der Lage sind, zu verstehen, was wir mei-nen, müssen in einem Programmablauf eindeutig messbare und nachvoll-ziehbare Bedingungen formuliert werden.

Zugegebenermaßen ist es schwierig, die Komplexität von Prozessen desAlltags- und des Geschäftslebens auf eine logische, programmtechnische


Ebene umzusetzen. Sie müssen auf die Inhalte und die Vergleichbarkeitvon Datentypen und Feldinhalten achten sowie die Reaktionen des Sys-tems antizipieren.

10.5.1 Einfache logische Ausdrücke

LogischeOperatoren

Betrachten Sie zunächst einmal die so genannten logischen Operatoren inTabelle 10.1: Mit ihnen können Sie Bedingungen formulieren, die zweiFelder vergleichen, zum Beispiel:

IF ZAHL01 > ZAHL02.Anweisungsblock

ENDIF

Sind beide Felder hinsichtlich ihrer Attribute kompatibel oder konvertier-bar, ist die Bedingung dann erfüllt, wenn der Inhalt von ZAHL01 größerist als der Inhalt von Feld ZAHL02, und der Anweisungsblock wird ausge-führt. Im Quellcode können für die logischen Ausdrücke wahlweise logi-sche Operatoren oder ihre Symbole verwendet werden.

AutomatischeTypkonvertierung

Je weiter die Attribute der zu vergleichenden Felder jedoch auseinanderdriften, desto mehr muss man die systemimmanenten Konvertierungsre-geln kennen. Zeichenketten vom Typ c werden beispielsweise bei unter-schiedlicher Länge von links nach rechts gemäß der relevanten Code-tabelle verglichen. Klingt ganz einfach, aber wissen Sie immer genau, woein Blank oder ein Sonderzeichen in der Codetabelle steht – vor odernach den Kleinbuchstaben –, und ist die lexikalische Sortierung zur Code-tabelle identisch? Man kann sich im Detail hier ganz schön ärgern undtäuschen.

Logischer Operator Symbol Bedeutung

EQ = gleich

NE <> ungleich

LT < kleiner als

LE <= kleiner gleich

GT > größer als

GE >= größer gleich

Tabelle 10.1 Logische Operatoren für Datenobjekte


Sind die Datentypen unterschiedlich, wird zuerst eine automatische Typ-konvertierung durchgeführt und dann verglichen. Wenn beispielsweiseein Feld vom Typ c mit einem Feld vom Typ n verglichen werden soll,werden vor dem Vergleich beide Felder in den Typ p konvertiert. Auch beidieser Sorte Aufgabenstellung kann einem das System Überraschungenbereiten: Formal arbeitet es natürlich einwandfrei, es ist der Mensch, dersich nicht an die Regeln hält – oder sie nicht kennt – und staunt. Als Kon-sequenz daraus sollten Sie versuchen, die zu vergleichenden Felder hin-sichtlich ihrer Attribute aufeinander abzustimmen.

Spezielle logische Operatoren

Für Zeichenketten gibt es spezielle logische Operatoren. Mit ihnen for-muliert man Bedingungen, um herauszufinden, ob eine Zeichenkettebestimmte Zeichen enthält usw. Für andere spezielle Aufgaben existierennoch einige weitere Operatoren. Für den Einstieg in ABAP soll hier abernicht weiter darauf eingegangen werden, sondern nur noch die Prüfungauf den Initialwert eines Feldes und die Prüfung auf ein Intervall erwähntwerden.

IS INITIALDie Bedingung, dass eine Teilaufgabe nur dann ausgeführt werden soll,wenn der Feldwert der Initialwert ist, kommt relativ häufig vor. Dabeihängt es nur von der Aufgabenstellung ab, ob der Initialwert von Anfangan unverändert bleibt oder – wie in unseren vorherigen Beispielen – wäh-rend der Programmausführung per Anweisung gesetzt wird. In beidenFällen soll der Anweisungsblock nur unter dieser Bedingung ausgeführtwerden.

IF zahl01 IS INITIAL.Anweisungsblock

ENDIF.

Der Anweisungsblock wird nur durchlaufen, wenn der Feldinhalt vonZAHL01 der Initialwert ist. Hat das Feld schon einen Inhalt, ist die Bedin-gung nicht erfüllt und der Anweisungsblock wird dann nicht ausgeführt.

BETWEENBei der Prüfung auf ein Intervall wird der Feldinhalt hinsichtlich einerUntergrenze und einer Obergrenze geprüft. Liegt er dazwischen odergenau auf einer von beiden Grenzen, ist die Bedingung gültig und derAnweisungsblock wird ausgeführt. Die Ober- und Untergrenze des Inter-valls können entweder wieder als Literal oder als Variable angegebenwerden; werden die Grenzen als Variable angegeben, müssen die Grenz-werte, also die Feldinhalte, natürlich vorher sinnvoll gesetzt sein.

Soll in unserem Beispiel für die Teilnehmer des Jahrganges 1969 einebesondere Verarbeitung starten, müssen Sie prüfen, ob das Geburts-


datum zwischen dem 01.01.1969 und dem 31.12.1969 liegt. Ist dieBedingung erfüllt, soll der Anweisungsblock ausgeführt werden.

IF zteilnehmer02-tgeburtsdatumBETWEEN '19690101' AND '19691231'.

* AnweisungsblockENDIF.

Hat jemand genau am 01.01.1969 oder am 31.12.1969 Geburtstag, ist fürdiese Person ebenfalls die Bedingung erfüllt und der Satz durchläuft denAnweisungsblock.

10.5.2 Verknüpfte logische Ausdrücke

Richtig spannend wird die Arbeit, wenn man komplexe Bedingungendurch Verknüpfen von logischen Ausdrücken abbilden will oder muss. Esist eine schwierige Gratwanderung, einerseits die Komplexität abzubil-den, und andererseits die Transparenz, Lesbarkeit und Änderbarkeit desQuellcodes zu erhalten. Dazu sollten Sie zunächst die Regeln für das Ver-knüpfen von logischen Ausdrücken beachten.

OR Arbeiten Sie mit zwei Bedingungen und dem logischen Oder als Verknüp-fungsoperator, muss eine von beiden Bedingungen oder müssen beideerfüllt sein, damit der Anweisungsblock durchlaufen wird. Stellen Sie sichvor, Sie möchten ein Buch ausleihen und lesen. Sie kennen zwei Personenund fragen beide. Sie können das Buch dann ausleihen und lesen, wennIhnen eine von beiden Personen das Buch leiht – oder beide.

In ABAP wird das logische Oder durch den Operand OR abgebildet. Dieallgemeine Grundstruktur ist dieselbe wie beim einfachen IF: Es gibt dieVerzweigungsstruktur IF...ENDIF sowie eine Bedingung b1.

IF b1.* AnweisungsblockENDIF.

Der Unterschied ist jetzt nur, dass sich b1 wiederum aus Bedingungen,wie b2, b3 usw. zusammensetzt, die mit einem logischen Operanden ver-knüpft sind, beispielsweise:

b1 = b2 OR b3

Klammerebenen Dieses Auflösen von Bedingungen kann beliebig fortgesetzt werden,kombiniert mit anderen logischen Operanden sowie mehreren Klammer-ebenen. Sie können auf diese Weise wirklich komplexe Bedingungen


abbilden. Aber auch hier wird den meisten Menschen schneller schwin-delig als einer Maschine: Wenn solche Bedingungen ganze Bildschirmsei-ten füllen, können Sie leicht den Überblick verlieren. Kleinste Änderun-gen an logischen Ausdrücken können riesige Auswirkungen auf denProgrammablauf haben. Bitte vergessen Sie also die Grundsätze der Les-barkeit, Transparenz und Änderbarkeit von Quellcode nicht.

Sollen die Sätze aller Teilnehmer der Kurse »SAP-Finanzwesen« und»SAP-Grundlagen« durch einen eigenen Anweisungsblock laufen, schrei-ben Sie die logische Oder-Bedingung so:

IF zteilnehmer02-zzkurstitel = 'SAP-Finanzwesen' ORzteilnehmer02-zzkurstitel = 'SAP-Grundlagen'.


Das Feld für den Kurstitel muss entweder den Inhalt »SAP-Finanzwesen«oder den Inhalt »SAP-Grundlagen« haben, damit die Bedingung erfüllt ist.So wie die Bedingung formuliert ist, kann das Feld natürlich nicht gleich-zeitig beide Bedingungen erfüllen. Dazu bräuchte man zwei verschiedeneFelder.

ANDStrenger als das logische Oder bindet das logische Und. Bei zwei Bedin-gungen bedeutet das, dass beide Bedingungen gleichzeitig erfüllt seinmüssen, damit der Anweisungsblock durchlaufen wird. Wenn Sie in denUrlaub fahren möchten, brauchen Sie Zeit und Geld – nur eines von bei-dem zu haben, genügt nicht.

In ABAP wird das logische Und durch den Operanden AND symbolisiert.Um wiederum ein einfaches Beispiel zu wählen, nehmen wir an, es sollendie Sätze aller männlichen Teilnehmer, die den Kurs »PC-Grundlagen«besuchen, durch einen eigenen Anweisungsblock laufen. Der ABAP-Quellcode lautet sinngemäß:

IF zteilnehmer02-tgeschlecht = 'M' ANDzteilnehmer02-zzkurstitel = 'PC-Grundlagen'.


Es gibt zwei Felder für Geschlecht und Kurstitel, und beide müssen einenbestimmten Inhalt haben, damit die Bedingung erfüllt ist und der Anwei-sungsblock durchlaufen wird.

NOTAm strengsten bindet der dritte Verknüpfungsoperator NOT: die Nega-tion. Wenn Sie Abfragen wie »Möchten Sie diese Änderung nicht spei-


chern? – Ja!/Nein!« kennen, haben Sie das Problem der Negation bereitserkannt. Für viele Menschen ist es ziemlich schwer, mit negierten Abfra-gen und Bedingungen zu arbeiten, besonders in komplexen Situationenund unter Druck. Deshalb bereits an dieser Stelle die Bitte, dass Sie Nega-tionen in Ihrer praktischen Arbeit so weit wie möglich vermeiden – for-mulieren Sie positiv, wo immer es geht.

Nicht immervermeidbar

Manchmal lässt sich aber das Arbeiten mit Negationen nicht vermeiden,beispielsweise im Umfeld von Abfragen auf Initialwerte von Feldern.Abzufragen, ob ein Feld den Initialwert hat, ist nicht schwer, wie Sie gese-hen haben. Alle möglichen Feldinhalte dagegen abzuprüfen, ist fastunmöglich. Manchmal genügt es auch zu wissen, dass ein Feld einenanderen als den Initialwert, also eben nicht den Initialwert hat, um einenAnweisungsblock auszuführen.

Formal zu beachten ist, dass die Negation NOT grundsätzlich vor derBedingung stehen muss. Soll ein Anweisungsblock nur dann ausgeführtwerden, wenn die Bedingung b1 nicht erfüllt ist, wäre die Schreibweisesinngemäß:

IF NOT b1.

Im folgenden Beispiel sollen die Sätze aller Teilnehmer, die nicht an SAP-Kursen teilnehmen, gesondert verarbeitet werden. Sie schreiben in ABAP:

IF NOT zteilnehmer02-zzkurstitel(3) = 'SAP'.* AnweisungsblockENDIF.

Die Bedingung lautet, dass die ersten drei Zeichen der Kursbezeichnungnicht »SAP« sein dürfen, damit der Anweisungsblock durchlaufen wird.

Zum Abschluss dieses Abschnitts kombinieren wir unser neues Wissenüber Verknüpfungen logischer Ausdrücke in einem kleinen Beispiel.

366 Tage – aberwann?

In unserem Kalender ist ein Jahr immer dann ein Schaltjahr, wenn esdurch vier ganzzahlig ohne Rest teilbar ist. Immer dann, wenn es durch100 ganzzahlig ohne Rest teilbar ist, ist es aber kein Schaltjahr. Es ist abertrotzdem ein Schaltjahr, wenn es durch 400 ganzzahlig ohne Rest teilbarist.

Beispiel

Ermitteln Sie, ob ein Jahr ein Schaltjahr ist.

243Codebeispiel zu IF

Für die Umsetzung in ABAP müssen zunächst drei Bedingungen formu-liert werden:

� b1: das Jahr ist durch 400 ganzzahlig teilbar



Ein Jahr ist dann ein Schaltjahr, wenn b1 oder wenn b3 erfüllt ist, danndarf aber b2 nicht gelten. In kürzerer und eindeutiger Schreibweise kanndie Bedingung so formuliert werden:

b1 OR b3 AND NOT b2

Geklammert werden muss nicht, weil durch die hierarchische Ordnungder Operanden die Negation am engsten bindet, das logische Und alszweitstärkstes und das logische Oder am schwächsten. Wenn Sie die Les-barkeit erhöhen möchten, können Sie natürlich auch Klammern setzen.Die Bedingung würde dann lauten:

b1 OR ( b3 AND NOT b2 )

Bitte beachten Sie aber, dass anders gesetzte Klammern die Logik derBedingung völlig verändern können.

Für die endgültige Umsetzung könnten Sie in ABAP die Ergebnisse derPrüfungen, ob ein Jahr ganzzahlig teilbar ist, in entsprechenden Feldernhinterlegen und dann die Bedingung beispielsweise so schreiben:

IF jahr400 = 0 OR jahr004 = 0 AND NOT jahr100 = 0.* AnweisungsblockENDIF.

Im Codebeispiel zu WHILE und logischen Ausdrücken (siehe Abschnitt10.9) finden Sie nähere Erläuterungen.

10.6 Codebeispiel zu IF

1 *&---------------------------------------------*2 *& Report Z_TEILNEHMERLISTE10_if *3 *& *4 *&---------------------------------------------*5 *& *6 *& *7 *&---------------------------------------------*8


9 REPORT z_teilnehmerliste10_if.1011 * Tabellen deklarieren12 TABLES zteilnehmer02.1314 * Zeichenketten deklarieren15 DATA: tz_pc_grundlagen TYPE i,16 tz_netzwerktechnik TYPE i,17 tz_sap_grundlagen TYPE i,18 tz_sonst TYPE i,19 tz_total TYPE i.2021 * vollständigen Tabelleninhalt ausgeben22 SELECT * FROM zteilnehmer02.23 WRITE: / zteilnehmer02-tnummer,24 zteilnehmer02-tname,25 zteilnehmer02-tgeburtsdatum,26 zteilnehmer02-tgeschlecht,27 zteilnehmer02-tkurspreis,28 zteilnehmer02-twaehrung,29 zteilnehmer02-zzkfztyp,30 zteilnehmer02-zzkurstitel.31 ENDSELECT.32 SKIP.3334 * Tabelleninhalt selektieren mit Bedingung35 SELECT * FROM zteilnehmer0236 WHERE zzkurstitel = 'Netzwerktechnik'.37 WRITE: / zteilnehmer02-tnummer,38 zteilnehmer02-tname,39 zteilnehmer02-tgeburtsdatum,40 zteilnehmer02-tgeschlecht,41 zteilnehmer02-zzkurstitel.42 ENDSELECT.4344 * alle Sätze aus der Tabelle lesen,

aber nur bestimmte Sätze verarbeiten45 SELECT * FROM zteilnehmer02.46 IF zteilnehmer02-zzkurstitel =

'PC-Grundlagen'.


47 tz_pc_grundlagen = tz_pc_grundlagen + 1.48 ENDIF.49 ENDSELECT.50 SKIP.51 WRITE: / tz_pc_grundlagen, 'Personen besuchen

den Kurs PC-Grundlagen'.5253 * alle Sätze der Tabelle lesen,

Anzahl der Kurszeilnehmer grob aufteilen54 SELECT * FROM zteilnehmer02.55 IF zteilnehmer02-zzkurstitel =

'SAP-Grundlagen'.56 tz_sap_grundlagen = tz_sap_grundlagen + 1.57 ELSE.58 tz_sonst = tz_sonst + 1.59 ENDIF.60 ENDSELECT.61 tz_total = tz_sap_grundlagen + tz_sonst.62 SKIP.63 WRITE: / 'von den',64 / tz_total, 'Teilnehmern besuchten',65 / tz_sap_grundlagen, 'den Kurs

SAP-Grundlagen, und',66 / tz_sonst, 'sonstige Kurse'.6768 * wieder benötigte Zähler initialisieren69 CLEAR: tz_netzwerktechnik,70 tz_pc_grundlagen,71 tz_sap_grundlagen,72 tz_sonst.7374 * alle Sätze der Tabelle lesen,

Anzahl der Kurszeilnehmer fein aufteilen75 SELECT * FROM zteilnehmer02.76 IF zteilnehmer02-zzkurstitel =

'Netzwerktechnik'.77 tz_netzwerktechnik = tz_netzwerktechnik + 1.78 ELSEIF zteilnehmer02-zzkurstitel =

'PC-Grundlagen'.79 tz_pc_grundlagen = tz_pc_grundlagen + 1.


80 ELSEIF zteilnehmer02-zzkurstitel ='SAP-Grundlagen'.

81 tz_sap_grundlagen = tz_sap_grundlagen + 1.82 ELSE.83 tz_sonst = tz_sonst + 1.84 ENDIF.85 ENDSELECT.8687 SKIP.88 WRITE: / 'Verteilung der Personen auf die

Kurse:',89 / tz_netzwerktechnik, 'Netzwerktechnik',90 / tz_pc_grundlagen, 'PC-Grundlagen',91 / tz_sap_grundlagen, 'SAP-Grundlagen',92 / tz_sonst, 'sonstige Kurse'.

Listing 10.1 Report Z_TEILNEHMERLISTE10_if

10.6.1 Anmerkungen zum Quellcode

Zeile 35 bis 42Nur die Sätze, die die Bedingung erfüllen, dass im Feld für die Kursbe-zeichnung »Netzwerktechnik« steht, gelangen in die Verarbeitung. DieVerarbeitung wird durch Ausgabe in einer Liste simuliert.

Vorteil:Vorselektion

Diese Vorselektion ist gleichzeitig der große Vorteil dieser Arbeitsweise,sie ist für bestimmte Fälle effizienter. Man kann sich gut vorstellen, dasses umso sinnvoller ist, sich gezielt die »richtigen« Sätze aus einer Tabelleheraus zu picken, je größer die Tabelle ist. Der Nachteil dieser Selektionmit Bedingung könnte sein, dass die anderen Sätze, die vielleicht auchverarbeitet werden sollen, aber eben anders, in diesem Beispiel gar nichtgelesen werden und für eine Verarbeitung nicht zur Verfügung stehen. Eskommt also wie immer auf die Aufgabenstellung an.

Zeile 45 bis 49Es werden alle Sätze der Tabelle gelesen. Zwischen Zeile 45 und 46könnte man sich einen Verarbeitungsblock vorstellen, der für alle Sätzegleich ist. Zusätzlich findet für die Sätze, die die Bedingung »PC-Grundla-gen« erfüllen, eine gesonderte Verarbeitung statt: Sie durchlaufen eineneigenen Anweisungsblock und werden gezählt.


Zeile 51Wichtiges PrinzipHier sehen Sie ein wichtiges Prinzip, vielleicht auch erst auf den zweiten

Blick. In Zeile 45 bis 49 läuft eine Schleife. In der Schleife wird in Zeile 46bis 48 die Zahl der Teilnehmer für den Kurs »PC-Grundlagen« berechnet.Die Ausgabe des Ergebnisses, also die Summe der Anzahl der Teilnehmer,darf erst nach der Schleife erfolgen, die Ausgabe in der Schleife wäre nurein Zwischenergebnis. Das könnte zwar bei anderen Aufgabenstellungensinnvoll sein, hier aber nicht. Also denken Sie bitte immer daran:

� Summen ermitteln: immer in der Schleife

� Summen ausgeben: immer nach der Schleife

Zeile 54 bis 60Wieder werden alle Sätze der Tabelle gelesen, dabei werden zwei Sum-men ermittelt. Wenn das Feld ZTEILNEHMER02-ZZKURSTITEL den Wert»SAP-Grundlagen« enthält, wird die Summe für diese Kursteilnehmererhöht. Sonst steigt die Summe für die Teilnehmer an den restlichen Kur-sen.

Zeile 61 bis 66Aus beiden Gruppensummen wird die Gesamtsumme gebildet. In derListe erscheinen die Gesamtanzahl von Kursteilnehmern, die Anzahl derTeilnehmer am Kurs »SAP-Grundlagen« und die Anzahl der Teilnehmer,die sonstige Kurse besuchen.

Zeile 69 bis 72Die Summenfelder werden für die nachfolgenden Beispiele wieder benö-tigt und deshalb initialisiert.

Zeile 76 bis 85Alle Sätze aus der Datenbanktabelle werden selektiert. Für jeden Satzwerden nacheinander die Bedingungen geprüft. Erfüllt er die erste Bedin-gung, wird der erste Anweisungsblock ausgeführt und zu ENDIF ver-zweigt. Erfüllt er die erste Bedingung nicht, wird geprüft, ob er die zweiteBedingung erfüllt usw. Es werden mehrere Fälle unterschieden und Grup-pensummen für die Kurse »Netzwerktechnik«, »PC-Grundlagen« und»SAP-Grundlagen« gebildet. Die restlichen Kursteilnehmer fallen wiederunter eine Summe für die sonstigen Kurse.


Zeile 88 bis 92Nach der SELECT-Schleife werden die Gruppensummen mit entsprechen-den Texten in die Liste geschrieben.

10.6.2 Ausgabe des Quellcodes

Lesbarkeit durchSKIP erhöhen

Zur Kontrolle werden zunächst alle Sätze der Tabelle ausgelesen, hier ins-gesamt acht Sätze (siehe Abbildung 10.6). Dann erfolgt die Ausgabe derTreffersätze über die SELECT-Anweisung mit Bedingung, daran schließensich die Ausgaben der Gruppensummen aus den einzelnen Beispielen an.Zur besseren Lesbarkeit wurde mit dem SKIP-Kommando jeweils eineLeerzeile eingeschoben, auf weitere optische Aufbereitungsoptionenwurde bewusst verzichtet.

10.7 Codebeispiel zu CASE

1 *&---------------------------------------------*2 *& Report Z_TEILNEHMERLISTE10_case *3 *& *4 *&---------------------------------------------*5 *& *6 *& *7 *&---------------------------------------------*8

Abbildung 10.6 Listbild zum IF-Beispiel

429Index

Index

$TMP 37, 133& 296* 65. 66/ 70_ 76

AABAP 15ABAP Debugger 115, 118, 127, 354, 367

Aufruf 115Ausführungsebene 119beenden 128Systemfelder 121Tabellenbereich 122

ABAP Dictionary 31, 33, 35, 132, 154, 166, 178, 194, 198

ABAP Editor 31, 55, 58, 72dynamische Breakpoints 128Icons 60Steuerung 60Symbolleiste 60

ABAP Memory 403, 404ABAP Objects 23, 326, 383ABAP Workbench 29, 68, 373ABAP-Anweisungen 66ABAP-Befehle 66ABAP-Kommandos 66ABAP-Laufzeitumgebung 23ABAP-Programme

modularer Aufbau 24Struktur 23

ABAP-Prozessor 22ABAP-Report

anlegen 55ausführen 67

ABAP-Schlüsselwortdokumentation 66

Abbruchanweisungen 235Wirkung 236

Abbruchbedingungen 237, 257Abbruchkriterium 231Ablaufsteuerung 426ADD 89Addition 88

ADJACENT DUPLICATES 343Advanced Business Application

Programming -> s. ABAPAktivierungsreihenfolge 136Allgemeiner Berichts-Aufbereitungs-

Prozessor -> s. ABAPalphanumerische Zeichen 99AND 241AND RETURN 387Anfangsposition 107Anmeldebildschirm 26Anmeldemandant 51Anmeldung 26Antwortzeit 321Anweisungen 66Anweisungsblock 221, 226, 228, 297

beenden 234anwendungsübergreifende Kompo-

nenten 28APPEND 327, 333, 366, 368Append-Struktur 131, 148

aktivieren 150anlegen 148Komponenten 149, 150Name 149pflegen 148zuordnen 148

APPL0 49Applikationsschicht 16Applikationsserver 17Arbeitsbereich 324, 328, 335Arbeitsspeicherbereiche 387, 402Arbeitsteilung 194arithmetischen Operationen 174Array-Fetch 330, 352Artikelnummern 100AS CHECKBOX 273AS TEXT 341AT 106AT SELECTION-SCREEN 267, 268, 295AT SELECTION-SCREEN ON 270ausführbares Programm 56Auslieferungsklasse 35Ausnahmebehandlung 402, 425Ausschneiden 156Auswahlknöpfe -> s. RadiobuttonsAUTHORITY-CHECK 195

Index430

automatische Mandantenverwaltung 51

automatische Typkonvertierung 239, 329

BBackend-Modus 58, 59

Vorteile 59Batch-Job 56Bedingungen 233

auflösen 240komplexe 240

Befehle 66rückgängig machen 64

BEGIN OF 322BEGIN OF BLOCK 298BEGIN OF LINE 296Benutzerstammsatz 194Berechnung 79

Alter bestimmen 172Dimension von Zeitspannen 173Fälligkeitsdatum bestimmen 168Fristen ermitteln 167Mehrwertsteuer 179mit Datumsfeldern 167mit Mengenfeldern 178mit Währungsfeldern 178mit Zeitfeldern 174Monatsanfang ermitteln 168, 169Rechnungsbetrag ermitteln 179Rechnungsdatum bestimmen 168Stichtag ermitteln 168Stichtage ermitteln 167Ultimo ermitteln 170verbleibende Tage 172verbleibende Tage ermitteln 171vergangene Tage ermitteln 171Zeit bis Mitternacht 175Zeitspanne in Jahren 173Zeitspanne in Minuten 174Zeitspanne in Sekunden 174Zeitspanne in Stunden 174Zeitspanne in Tagen 173Zeitspanne mit Datumswechsel 176

BerechtigungProgrammausführung 195Transaktionen 195

Berechtigungsgruppe 57

Berechtigungskonzept 194Berechtigungsobjekt 194Berechtigungsprüfung im Quellcode

195BETWEEN 239Bewegungsdaten 36Bindestrich 69Block

verdoppeln 64verschieben 64

Block/Ablage 81Blockname 299blockweises Übertragen 330BREAK-POINT 117, 129Breakpoints 61, 62, 115, 124

aktive 127dynamische 117, 128entfernen 128löschen 127setzen 117, 126sichern 127statische 129verwalten 128

Breakpoints-Modus 126Buchungskreis 27Büro 28BY 340

Cc, Datentyp 99, 102, 107, 167, 178, 200,

201, 238CALL FUNCTION 396, 402CASE 228, 230, 251CASE-Struktur 228, 402CHAR, Datentyp 136, 138CHECK 235, 379Checkbox 386CLEAR 200, 201, 202, 344, 345, 354,

358, 367, 369, 382Client/Server-Architektur 16, 193Cluster 404Cluster-Name 403Clustertabellen 34Codetabelle 238COMMENT 297COMPUTE 91CONCATENATE 105, 113

SEPARATED BY 105

431Index

CONDENSE 104, 113NO-GAPS 104

CONSTANTS 87CONTINUE 234CUKY, Datentyp 139, 140, 178CURK, Datentyp 167CURR

Datentyp 167CURR, Datentyp 139, 140, 167, 178Customizing 18

Dd, Datentyp 165, 200DATA 84, 86, 99, 165, 186, 200, 201,

322, 354, 365, 378BEGIN OF 322DECIMALS 84END OF 322LIKE 85, 100, 165OCCURS 323TYPE 84VALUE 86, 100, 166

Data Browser 36, 135, 155Data Dictionary 33Daten, temporäre 276Datenart 49Datenbank, anpassen 131, 158Datenbankschicht 16Datenbankschnittstelle 22Datenbankserver 17Datenbanksperre 195Datenbanktabellen 402

ausgeben 69lesen 69Modifikation 131transparente 131

Datenbank-Utility 158, 160Datenblock 329Datendeklarationen 375Datenelement 38

aktivieren 48anlegen 39prüfen 47

Datenkonsistenz 387Datenobjekte 83, 323, 332, 378

kompatible 89konvertible 89

Datensatz 318Datensätze

anzeigen 53eingeben 51erfassen 51löschen 203prüfen 134

Datenschnittstelle 391, 392Datentyp 40, 43, 84, 90, 323, 378

elementare 84, 323generischer 99, 100komplexe 324NUMC 43Unterschiede 102zeichenartige 165

Datentyp c 99, 102, 107, 167, 178, 200, 201, 238

Datentyp CHAR 136, 138Datentyp CUKY 139, 140, 178Datentyp CURK 167Datentyp CURR 139, 140, 167, 178Datentyp d 165, 200Datentyp DEC 139, 178Datentyp f 269Datentyp i 84, 90, 173Datentyp n 100, 102, 107Datentyp NUMC 138Datentyp p 84, 87, 90, 167, 173, 178Datentyp QUAN 139, 178Datentyp string 425Datentyp t 166Datentyp UNIT 139, 178Datenübergabe 403Datenverlust 157, 160Datumsfelder 165

deklarieren 165füllen 166, 168Rechnen mit 167Verarbeitung von 167

Datumsformat 78Debugging 115Debugging-Modus 115, 117DEC, Datentyp 139, 178DECIMALS 84DEFAULT 271, 280Deklaration 85Deklarationsteil 23

Index432

DELETE 198, 203, 204, 218, 221, 339, 343, 356, 367ADJACENT DUPLICATES 343

DESCENDING 341DESCRIBE 336

LINES 337Dezimaltrennzeichen 86Dezimalzahlen 84Dialogmodule 24Dictionary-Elemente 324Dictionary-Objekte 34, 38digitale Signatur 321Dispatcher 21DIV 92, 173DIVIDE 89Division 88, 91, 173

ganzzahlige 92, 263verschiedene Fälle 91

DO 231Dokumentation 42Domäne 38, 39, 86

aktivieren 45anlegen 43prüfen 45selbst erstellen 40

DO-Schleifen 232drucken 265Druckposition 96Dump-Aufbereitung 68dynamische Namensvergabe 201, 204Dynamisches Programm -> s. DynproDynpro 21, 265Dynpro-Prozessor 22Dynpro-Prüfung 145

EEditor-Modus 60Editorsperre 57Eigenschaften 56

semantische 145Eingabeblöcke 296Eingabefelder positionieren 296Eingabehilfen 147Eingabeprüfung 138, 141, 143, 145, 268,

270, 313Einsetzen 156Einstellungen, technische 49Einzelschritt 119, 355, 367

Einzelwerte 44, 277elementare Datentypen 84Elemente

kopieren 80selbst erstellen 40

ELSE 226, 227ELSEIF 226, 227END OF 322END OF BLOCK 298END OF LINE 296ENDCASE 228ENDDO 231ENDFORM 377, 380, 381ENDIF 222, 225ENDLOOP 335Endlosschleifen 231ENDSELECT 70ENDWHILE 233Entwicklerschlüssel 29Entwicklungssystem 18Ereignisblöcke 24Ereignisschlüsselwort 266, 312Ereignisse 24, 266, 312

beenden 237Beispiele 268

Ereignissteuerung 312Ersatzzeichen 389EXIT 236, 237, 257Exponentialzahlen 90EXPORT 403EXPORT TO MEMORY 403Exportparameter 397, 401externer Report aufrufen 385

Ff, Datentyp 269F1 52, 66, 272, 297F3 68, 292F4 43, 52, 137, 146, 272, 285F5 119F6 119F7 119F8 68, 120, 313Fallunterscheidung 221, 228Fehleranalyse 68Fehlerausgang 402, 425Fehlerbehandlung 207, 269, 294, 295Fehlerfall 229, 251

433Index

Fehlernachricht 145Fehlerprotokoll 157Fehlersuche 115Feld 37Feldbezeichner 42, 282Felddeklarationen 165Felder 79, 83, 115, 150

deklarieren 83hinzufügen 131Länge 84namensgleiche 323, 328, 329, 333Namensgleichheit 334Sternchen 70verarbeiten 83

Felder-Modus 118Feldinhalte

ändern 121modifizieren 121prüfen 120überwachen 126verschieben 102

Feldlänge 99, 100Feldliste 70, 139, 325, 379, 403Feldname 37Feldtyp 324Festpunktarithmetik 57Festwerte 88, 136

Einzelwerte 137Intervalle 137pflegen 137testen 137

FOR FIELD 297FORM 377, 378, 381, 382, 384FREE 345, 346, 354freie Texte 296Fremdschlüssel 45, 141, 144, 196

pflegen 143, 144testen 146

Fremdschlüsselbeziehung 159Fremdschlüsselfeld, Art 145Fremdschlüsseltabelle 144FROM 344Frontend-Modus 58, 59Function Builder 31, 388, 390

Testumgebung 394Funktionsbausteine 24, 31, 61, 196,

372, 387Ablaufart 391

Aufruf 396aufrufen 398Ausnahmen 393Dokumentation 397Eigenschaften 391Export 392Exportparameter 392Import 391Importparameter 392Name 396suchen 388, 389testen 388, 394, 395Wertübergabe 391

Funktionsbibliothek 388Funktionscodefeld 30Funktionsgruppen 388, 389

Gganze Zahlen 84Ganzzahldivision mit Rest 92ganzzahlige Division 92generischer Datentyp 99, 100generischer Schlüssel 145gepackte Zahlen 90GET PARAMETER 403GET PARAMETER ID 402Gleitpunktzahl 269globale Variablen 377globales SAP Memory 402Grenzen 319Groß- und Kleinschreibung 100, 204,

256, 270, 336, 384Größenkategorie 50Grundrechenarten 83, 88Grundsätze der ABAP-Program-

mierung 25

HHaltepunkte 117Hash-Algorithmus 321, 339Hash-Tabelle 321, 339Hierarchiestufen 100HIGH 276Hilfe 61Hintergrundverarbeitung 288Hochkommas 74Hut 354, 369, 381

Index434

Ii, Datentyp 84, 90, 173IF 222, 225, 227, 235, 240IF-Struktur 228, 275, 278, 402

schachteln 227IMPORT 404IMPORT FROM MEMORY 403Importparameter 397IN PROGRAM 384INCLUDE 330, 334, 373Include

expandieren 154komprimieren 154

INCLUDE STRUCTURE 330Include-Report 373Include-Struktur 151

aktivieren 154anlegen 152einfügen 152einpflegen 151Positionierung 151Voraussetzungen 151

INDEX 336, 342Index 320, 336, 338, 339Indextabellen 321, 336, 339, 343Industrieminuten 189Infosysteme 28INITIAL SIZE 325INITIALIZATION 267, 268, 312Initialwert 38, 86, 200Inkonsistenzen prüfen 146Inline-Dokumentation 65INSERT 198, 199, 202, 337, 342, 366Instanz 18, 20Integer 84interne Tabellen 317, 380, 381, 392,

404deklarieren 319, 322, 325satzweise füllen 326Struktur 318verarbeiten 335Vorteile 318

Intervall 44, 239, 277, 279INTO 342, 343INTO CORRESPONDING FIELDS 331IS INITIAL 239, 274

KKardinalität 146Kernbereiche 28Kettensatz 71, 77, 95, 322, 323, 324Key 37Klammerebenen 240Klammern 243Kommandos 66Kommentare 65

Anführungszeichen 65im Bildschirm 297Sternchen 65

Kommentarzeichen 400Kommentarzeilen 81, 223

umwandeln von Zeilenblöcken in 81kompatible Datenobjekte 89komplexe Bedingung 225Komponenten, Append-Struktur 149,

150Konsolidierungssystem 18, 19Konstanten 83kontextsensitiv 295Kontrollstruktur 221, 225konvertible Datenobjekte 89Konvertierungsregeln 89, 90Kopfzeile 318, 319, 325, 326, 328, 335,

380, 381Kopfzeile initialisieren 344Kopieren 156Korrekturwesen 19Kryptologie 321Kundennamensraum 149, 152Kurzbeschreibung 40Kurzdokumentation 73

LLänge 107Langtext 397Laufzeiten 158Laufzeitobjekt 134Laufzeitumgebung 56, 266Leerzeichen 88

entfernen 104Leerzeile erzeugen 71Lesbarkeit 25, 84Lesesperre 197LIKE 85, 100, 165, 272, 328LINES 337

435Index

LINE-SIZE 76Linie erzeugen 71Listaufbereitung 70Listbild 77Listbildschirm 265Liste anzeigen 120Listen aufbereiten 70Listprozessor 265, 267Listüberschriften 281Literal 66, 87, 100, 204, 218, 336, 356,

396, 404Literale 186, 256, 291LOAD-OF-PROGRAM 24, 267logische Ausdrücke 221, 237

verknüpfen 240verknüpfte 227

logische Datenbank 57logische Operatoren 238logisches Oder 240logisches Und 241Logistik 28lokale Namen 382lokale Objekte 20lokale Variable 378, 380

explizit deklarieren 378implizit deklarieren 378

lokales Objekt 37, 80, 133lokales SAP Memory 403LOOP 335, 336, 339, 342LOW 276LOWER CASE 272, 273, 280LT 235

MMandant 27Mandantenbehandlung, automa-

tische 198Mandantennummer 198Mandantenunabhängigkeit 198Mandantenverwaltung, automatische

51Markiermodus 63, 64, 81Mehrfachselektion 277Mehrfachverwendbarkeit 152Meldung in der Statuszeile 269Memory-ID 403Mengeneinheit 139Mengenfelder 138, 139

Menu Painter 32MESSAGE 293, 295, 313MESSAGE-ID 293MOD 92, 173MODIFY 198, 202, 336, 342

FROM 342Modularisierung 16, 324, 371Module 378Modulpool 266Modus 68MOVE-CORRESPONDING 328Multi-Byte-Codierung 57Multiplikation 88MULTIPLY 89Muster 62, 222

einfügen 222, 224

Nn, Datentyp 100, 102, 107Nachkommastellen 84, 86Nachrichten 291

pflegen 294sichern 294

Nachrichtenklasse 293, 295anlegen 293

Nachrichtennummer 295Nachrichtenpflege 293Nachrichtenpool 293Nachrichtentyp 295, 313Nachrichtentyp E 295Namensgleichheit 333Namenskonventionen 35, 55, 149Namensräume 35Namensvergabe

dynamisch 204für Variablen 83statisch 202, 203

Native SQL 22, 35Navigationsfenster 61Negation 241Netzlaufwerke 395Netzwerkpfade 395NEW-PAGE PRINT ON 265Nicht-Schlüsselfelder 155

ergänzen 136NO-EXTENSION 280NO-GAPS 104NOT 241

Index436

NUMC, Datentyp 138numerische Textfelder 100numerische Zeichen 100

OObject Navigator 32Objekt

aktivieren 136lokale 20lokales 37, 80, 133

Objektklassen 194Objektliste 61Objektorientierung 322, 323Objektschlüssel 148obligatorische Parameter 397OBLIGATORY 271, 280OCCURS 323Open SQL 22, 31, 35, 193

Anweisungen 198Operationen, arithmetische 174OPTION 276OR 240Originalsprache 56

PPaket 36Parameter

obligatorische 397, 400optionale 400

Parameter-ID 402anlegen 403initialisieren 414lesen 414schreiben 424

Parameterliste, prüfen 383PARAMETERS 269PERFORM 376, 377, 380, 381, 382,

384, 414IN PROGRAM 384USING 378

Personal 28Pflegebildschirm 35, 153Pflegedialog 135physikalischer Bereich 49Platzhalter 295Pooltabellen 34POSITION 298Position 96

angeben 96Positionierung 107

direkte 107Positionsnummern 100Postleitzahlen 86Präsentationsschicht 16Präsentationsserver 16Pretty Printer 62Primärschlüssel 202, 203Produktivsystem 18, 19Profile 194Programm

aktivieren 61, 67prüfen 67sichern 67starten 68

Programmabbruch 68Programmablaufsteuerung 221Programmausführung 68Programmlogik prüfen 115Programmnamen 55

dynamische 384Programmstatus 57, 60Prozeduren 24, 372, 375, 387Prüfsummenverfahren 321Prüftabelle 144, 159Pufferung 50, 193

QQualitätssicherungssystem 19QUAN, Datentyp 139, 178Quellcode

editieren 63, 72modularisieren 371schreiben 72umschalten 60

Quellfeld 90, 105Quelltabelle 132

RRADIOBUTTON GROUP 275Radiobuttons 274Rahmen 296Rahmenprogramm 376READ 337, 338, 343, 353, 355

INDEX 342INTO 342

Rechengenauigkeit 91, 92, 178

437Index

Rechenzeichen 89- 89* 89+ 88/ 89, 91

Rechnungswesen 28Redundanzen 157Referenzfeld 140, 159, 167REFRESH 344, 345, 354, 367Registerblatt, Felder 150Reorganisationsarbeiten 132REPLACE 103, 113REPORT 66, 80, 116, 293Report 21

Datenübergabe 402kopieren 79mit Variante starten 290über Variante starten 385

REPORT, LINE-SIZE 76Repository-Infosystem 388reservierter Speicherbereich frei-

geben 345Returncode 121, 198, 200, 202, 203,

229, 251, 356, 402, 425Rolle 194Rückgabewert 121Rumpfzeile 381, 404

löschen 343, 344, 345verändern 336

SSammelprofile 194Sammelschacht 227Sandkasten 19SAP GUI 17, 26SAP Logon 26SAP Memory 414

lesen 402schreiben 402

SAP R/3 15SAPScript-Editor 42SAP-System, Architektur 16Satz

ändern 202anlegen 202

Schachteln 75Schachtelung 230, 232, 234, 324, 375Schachtelungsebenen 227

Schaltjahr 242Schleife 70, 74, 75, 191, 230, 318

Abbruchanweisungen 234äußere 232Endlosschleifen 231innere 232mit Bedingung 230ohne Bedingung 230

Schleifendurchläufe begrenzen 231Schleifenverarbeitung 75Schlüssel 325, 336, 338, 343

benutzerdefinierter 320eindeutige 320generischer 145nicht eindeutige 320, 325

Schlüsselfelder 37, 151, 156, 338, 343löschen 157, 159Manipulation 131Veränderung 155

Schlüsselwortdokumentation 66Schlüsselwörter 61Schnittstellen 324Schrägstich 70Schreibsperre 197Schreibweise 322

moderne 383traditionelle 383

Screen Painter 32SE11 33, 132SE38 55SE91 293SELECT 70, 191, 198, 229, 230, 327, 331SELECTION-SCREEN 296

BEGIN OF BLOCK 298BEGIN OF LINE 296COMMENT 297END OF BLOCK 298END OF LINE 296FOR FIELD 297POSITION 298TITLE 299WITH FRAME 299

SELECT-OPTIONS 276, 281Selektionen 269, 275Selektionsbildschirm 57, 265, 272, 284,

289, 385, 386speichern 284übergehen 386

Index438

Selektionsbildverarbeitung 295Selektionstabelle 276Selektionstexte 281

aktivieren 283anlegen 281pflegen 282verwenden 281

Selektionsvariante anlegen 285semantische Eigenschaften 145SEPERATED BY 105SET PARAMETER 403SET PARAMETER ID 402SHIFT 102SIGN 276Sizing 18SKIP 71, 248SORT 340, 358

BY 340SORTED TABLE 325Sortierkriterien 341Sortierreihenfolge 341sortierte Tabelle 321, 337, 339Sortierung

binär 341sprachspezifisch 341

SPACE 112Spaltenaufteilung 96Speicherbereich 323Speicherplatz, initialer 325Sperre

aufheben 197logische 196Zeitpunktproblematik 197

Sperrkonzept 194, 195physikalische Datenbank 195SAP R/3 196

Sperrobjekt 196entsperren 196Sperre setzen 196

Sperrproblematik 197Sperrtabelle 196SPLIT 106, 113

AT 106Sprachenschlüssel 293Stammdaten 36STANDARD TABLE OF 325Standardschlüssel 320Standard-Selektionsbild 266

Standardtabelle 149, 155, 320, 325, 337erweitern 148

START-OF-SELECTION 24, 267, 314, 376

Startwert 86statische Namensvergabe 202, 203Status 56Stellungsoperanden 105, 295, 378,

380, 384Stoppschild 355Stoppuhr 233Streuwertfunktion 321string, Datentyp 425String-Operation 187String-Operationen 101, 108, 174Struktur 69, 318

einbinden 330Komponenten 150

Strukturanfang 222Strukturen 150Strukturende 222, 266Strukturpflegebildschirm 153SUBMIT 385, 386, 387, 403

AND RETURN 387VIA SELECTION-SCREEN 385WITH 386

SUBTRACT 89Subtraktion 88Suchbegriff 103Suche, generische 389Suchen 65Suffix 395Summen

ausgeben 247ermitteln 247

Summenfelder, initialisieren 247SY-DATUM 165SY-INDEX 234, 236Symbolleisten 60Syntax 321

prüfen 61Syntaxfehler 61Syntaxprüfung 61, 375Systemdatum 165Systemmandant 39Systemtabelle 121, 293SY-SUBRC 121, 198, 200, 229, 393SY-TABIX 339

439Index

Tt, Datentyp 166T100 293, 313Tabelle 61, 324

aktivieren 50anlegen 35deklarieren 73Fehlermeldung 140interne 317kopieren 132löschen 160, 162modifizieren 131ohne Kopfzeile 326Pflegedialog 51pflegen 35, 135physikalische Umsetzung 157prüfen 49sichern 36temporäre 317transparente 34Umsetzung 159vervollständigen 48

Tabelle T100 313Tabelle TCURC 141Tabellenarbeitsbereich 69

als Puffer 200löschen 200

Tabellenbereich 69, 73prüfen 122

Tabellendeklaration 321Tabelleneinträge 135Tabellenfeld

löschen 159pflegen 37

Tabellenindex 339Tabelleninhalt

anzeigen 52modifizieren 198

Tabellenkopf 319Tabellen-Modus 118, 122Tabellenrumpf 318, 319, 326, 335Tabellenstatus 134Tabellenstruktur 76

physikalische 155Tabellentyp 324, 325, 332Tabellenverarbeitung 321

mehrdimensional 319n-dimensional 319

Tabellenzeile 134, 318TABLE 344TABLES 69, 199, 380, 382Tablespace 49TCURC 142, 144

Tabelle 141technische Einstellungen 49Teilstring 107temporäre Daten 276temporäre Tabellen 317Testdatensätze eingeben 135Testmodus 61Testsystem 18Texte länderspezifisch pflegen 56Textelemente 186, 281

Pflegedialog 291Textfelder, numerische 100Textobjekte, ergänzende 291Textpool 281

aktivieren 292Textsymbole 281, 291, 297

aktivieren 292pflegen 291

Textsymbolnummer 292TIMES 231TITLE 299Transaktion SE91 293Transaktion, Laufzeit 403Transaktionscode 30, 195TRANSLATE 273transparente Tabellen 34Transparenz 25Transport 36Transportwesen 19Trennzeichenkette 106Trick 35 169, 171Typdeklaration 69, 324, 325, 334TYPE 84TYPES 324Typkonvertierung 113, 165

automatische 239

UÜbersetzbarkeit 291ULINE 71Umsetzung im Dialog 158Unabhängigkeit 15UNDER 96

Index440

Unicodeprüfung 57UNIT, Datentyp 139, 178Unterprogramm 24, 372, 375, 379

aufrufen 376, 383externe 383interne 383

Unterprogrammfelder 379Unterstrich 76Unterstrukturen 151UPDATE 198, 201, 202Upgrade 148USING 378, 382

VVALUE 86, 100, 166, 354VALUE CHECK 272Variablen 83, 404Variablennamen 83Variante 58, 285

anlegen 285Eigenschaften 288schützen 288, 289Start über 58

Variantenpflege 287Verarbeitung

lesende 318schreibende 318

VerarbeitungsartDirekt 158Hintergrund 158

Verarbeitungsblöcke 24, 266, 371Verbuchungsaufgaben 391Verprobung 138, 146Verschieben von Feldinhalten 102Verwendungsnachweis 61, 160, 161Verzweigung 225VIA SELECTION-SCREEN 385, 386Vorbelegung 86Vorselektion 246Vorwärtsnavigation 40, 69, 150, 153,

154, 373, 376, 403

WWAERS, Domäne 141, 143Währungsbetrag 139Währungsbezeichnung 167Währungseinheit 139, 143, 215Währungsfelder 138, 139, 166

deklarieren 166Währungsschlüssel 167Wartbarkeit 25Watchpoints 115, 124

anlegen 124sichern 127

Watchpoints-Modus 124Wechselkursumrechnung 178Weitersuchen 65Werte

gültige 141negativer 86übergeben 385, 386

Wertebereich 44Werteliste 141Wertetabelle 44, 141, 143, 144Werthilfe 136, 146Werthilfeliste 137, 146WHEN OTHERS 229WHERE 204, 230, 340, 353, 367WHILE 233WHILE-Schleife 233Wiederholung 221Wiederverwendbarkeit 324WITH 295, 386WITH FRAME 299WITH HEADER LINE 325, 365WITH KEY 338, 343WITH UNIQUE KEY 325Workarea 200, 202, 318, 319, 323, 341,

343, 366deklarieren 200, 325initialisieren 208, 345

Workprozess 21, 196WRITE 66, 70, 71, 96

UNDER 96

XX-Ablage 62

YY-Ablage 62

ZZ-Ablage 62Zahlen

ganze 84gepackte 90

441Index

Zeichenalphanumerische 99ausschneiden 101numerische 100

Zeichenkette 74, 99, 165ergänzen 101ersetzen 101, 103modifizieren 99suchen 101verdichten 104verschieben 101zerlegen 106zusammenziehen 105

Zeichenkettenoperationen 101Zeile

aktualisieren 203ändern 336anlegen 202ausschneiden 63Doppelungen 321einfügen 156, 337einsetzen 63frei gestalten 296kopieren 63löschen 64, 156, 203, 339markieren 59

neue Zeile einfügen 64redundante 343verdoppeln 64verketten 64verschieben 64

Zeilenblock 298löschen 81markieren 81

Zeilenstruktur 325Zeilentyp 320, 323, 324, 331

deklarieren 326Zeilenumbruch 70, 76Zeitfelder 166

deklarieren 166füllen 166

Zeitpunktproblematik 197Zeitspanne bei Datumswerten 172zentrale Steuerungskomponente 426Zielfeld 90, 105Zieltabelle 132Zugriffsaufwand 338Zugriffsschlüssel 320Zugriffszeit 320, 321Zusätze 66Zwischenablagen 59, 62Zwischenpuffer 62

Documents

Einstieg in ABAP - · PDF fileInhalt 5 Inhalt Vorwort 11 1 ABAP und erste Schritte im SAP-System 15 1.1 Architektur des SAP-Systems im Überblick