12.7 Codebeispiel zu ITAB mit Workarea 
Unsere Beispiele zum Umgang mit internen Tabellen zeigen wir in Listing 12.1 noch einmal in einem zusammenhängenden Report.
1 *&---------------------------------------------*
2 *& Report Z_TEILNEHMERLISTE12_ITAB_WA *
3 *& *
4 *&---------------------------------------------*
5 *& *
6 *& *
7 *&---------------------------------------------*
8
9 REPORT z_teilnehmerliste12_itab_wa.
10
11 * Workarea deklarieren
12 DATA wa_zteilnehmer02 TYPE zteilnehmer02.
13
14 * Felder deklarieren
15 DATA: zeilen_itab01 TYPE i.
16
17 * Datentypen für Zeilen deklarieren
18 TYPES: BEGIN OF zeile01_typ,
19 zzkurstitel TYPE
zteilnehmer02-zzkurstitel,
20 tkurspreis TYPE
zteilnehmer02-tkurspreis,
21 END OF zeile01_typ.
22
23 TYPES BEGIN OF zeile02_typ.
24 INCLUDE TYPE zeile01_typ.
25 TYPES minteiln TYPE i.
26 TYPES END OF zeile02_typ.
27
28 TYPES: BEGIN OF zeile03_typ,
29 bezeichnung LIKE zteilnehmer02-zzkurstitel,
30 preis TYPE zteilnehmer02-tkurspreis,
31 maxteil TYPE i,
32 END OF zeile03_typ.
33
34 TYPES zeile04_typ TYPE zteilnehmer02.
35
36 * Datentypen für interne Tabellen deklarieren
37 TYPES itab01_typ TYPE STANDARD TABLE
OF zeile01_typ.
38 TYPES itab02_typ TYPE STANDARD TABLE
OF zeile02_typ.
39 TYPES itab03_typ TYPE STANDARD TABLE
OF zeile03_typ.
40 TYPES itab04_typ TYPE STANDARD TABLE
OF zeile04_typ.
41
42 * Interne Tabellen deklarieren ohne Kopfzeile
43 DATA itab01 TYPE itab01_typ.
44 DATA itab02 TYPE itab02_typ.
45 DATA itab03 TYPE itab03_typ.
46 DATA itab04 TYPE itab04_typ.
47
48 * Workareas für interne Tabellen deklarieren
49 DATA wa_itab01 TYPE zeile01_typ.
50 DATA wa_itab02 TYPE zeile02_typ.
51 DATA wa_itab03 TYPE zeile03_typ.
52 DATA wa_itab04 TYPE zeile04_typ.
53
54 * Selektionsbild deklarieren
55
56 *----------------------------------------------*
57 * initialization.
58
59 *----------------------------------------------*
60 * at selection-screen.
61
62 *----------------------------------------------*
63 START-OF-SELECTION.
64
65 * Datenbanktabelle lesen und itab01 füllen
über Workarea
66 SELECT * FROM zteilnehmer02 INTO wa_zteilnehmer02.
67 MOVE-CORRESPONDING wa_zteilnehmer02 TO wa_itab01.
68 APPEND wa_itab01 TO itab01.
69 ENDSELECT.
70
71 * Datenbanktabelle lesen und itab02 füllen
über Array-Fetch
72 SELECT * FROM zteilnehmer02
73 INTO CORRESPONDING FIELDS OF TABLE itab02.
74
75 * Datenbanktabelle lesen und itab03 füllen über
Workarea und Zuweisung
76 wa_itab03-maxteil = 10.
77 SELECT * FROM zteilnehmer02
INTO wa_zteilnehmer02.
78 wa_itab03-bezeichnung =
wa_zteilnehmer02-zzkurstitel.
79 wa_itab03-preis =
wa_zteilnehmer02-tkurspreis.
80 APPEND wa_itab03 TO itab03.
81 ENDSELECT.
82
83 * Datenbanktabelle lesen und itab04 füllen
über Array-Fetch
84 SELECT * FROM zteilnehmer02
85 INTO CORRESPONDING FIELDS OF TABLE itab04.
86
87 *----------------------------------------------*
88 END-OF-SELECTION.
89
90 * Anzahl der Rumpfzeileneinträge für itab01
lesen und ausgeben
91 DESCRIBE TABLE itab01 LINES zeilen_itab01.
92 SKIP.
93 WRITE: / 'Anzahl Zeilen itab01:',
zeilen_itab01.
94
95 * Workarea initialisieren, füllen und
neue Zeile in itab01 anhängen
96 CLEAR wa_itab01.
97 zeilen_itab01 = zeilen_itab01 + 1.
98 wa_itab01-zzkurstitel = 'LINUX-GRUNDLAGEN'.
99 wa_itab01-tkurspreis = '456.78'.
100 INSERT wa_itab01 INTO
itab01 INDEX zeilen_itab01.
101
102 * itab01 ausgeben in Liste
103 SKIP.
104 WRITE: / 'sy-tabix, itab01-zzkurstitel,
itab01-tkurspreis'. "Überschrift
105 LOOP AT itab01 INTO wa_itab01.
106 WRITE: / sy-tabix, wa_itab01-zzkurstitel,
wa_itab01-tkurspreis.
107 ENDLOOP.
108
109 * itab02 verarbeiten und in Liste ausgeben
110 SKIP.
111 WRITE: / 'itab02-zzkurstitel,
itab02-tkurspreis, itab02-minteiln'.
112 LOOP AT itab02 INTO wa_itab02 WHERE
zzkurstitel = 'PC-GRUNDLAGEN'.
113 wa_itab02-minteiln = 2.
114 WRITE: / wa_itab02-zzkurstitel,
wa_itab02-tkurspreis,
wa_itab02-minteiln.
115 ENDLOOP.
116
117 * itab03 verarbeiten, ausgeben und Rumpf modifizieren
118 SKIP.
119 WRITE: / 'itab03-bezeichnung, itab03-preis,
itab03-maxteil'.
120 LOOP AT itab03 INTO wa_itab03.
121 IF wa_itab03-bezeichnung = 'PC-GRUNDLAGEN'.
122 wa_itab03-preis = 567.
123 MODIFY itab03 FROM wa_itab03.
124 ENDIF.
125 WRITE: / wa_itab03-bezeichnung,
wa_itab03-preis, wa_itab03-maxteil.
126 ENDLOOP.
127
128 * Einen Satz aus itab03 mit Index lesen
und ausgeben
129 READ TABLE itab03 INDEX 3 INTO wa_itab03.
130 SKIP.
131 WRITE: / 'gelesen von itab03',
sy-tabix NO-GAP, '.Zeile:',
132 wa_itab03-bezeichnung,
wa_itab03-preis, wa_itab03-maxteil.
133
134 * Einen Satz aus itab04 mit Schlüssel lesen
und ausgeben
135 READ TABLE itab04 INTO wa_itab04 WITH KEY
mandant = sy-mandt tnummer = 5.
136 SKIP.
137 WRITE: / 'gelesen von itab04',
138 wa_itab04-mandant,
wa_itab04-tnummer,
wa_itab04-tname,
wa_itab04-tgeburtsdatum,
wa_itab04-tgeschlecht.
139
140 * Einen Satz aus itab01 über Index lesen,
löschen, protokollieren
141 READ TABLE itab01 INTO wa_itab01 INDEX 3.
142 DELETE itab01 INDEX 3.
143 SKIP.
144 WRITE: / 'gelöscht von itab01',
sy-tabix NO-GAP, '.Zeile:',
145 wa_itab01-zzkurstitel,
wa_itab01-tkurspreis.
146
147 * Gezielt einzelnen Satz aus itab02 über
Schlüssel lesen, löschen, protokollieren
148 READ TABLE itab02 INTO wa_itab02 WITH KEY
zzkurstitel = 'SAP-Grundlagen'.
149 DELETE TABLE itab02 FROM wa_itab02.
150 SKIP.
151 WRITE: / 'gelöscht von itab02',
sy-tabix NO-GAP, '.Zeile:',
wa_itab02-zzkurstitel.
152
153 * Wirkung von CLEAR, REFRESH und FREE bei
internen Tabellen ohne Kopfzeile
154 BREAK-POINT.
155 CLEAR wa_itab01. "initalisiert Workarea
156 CLEAR itab01. "löscht Rumpfzeilen
157
158 CLEAR wa_itab02. "initalisiert Workarea
159 REFRESH itab02. "löscht Rumpfzeilen
160
161 CLEAR wa_itab03. "initalisiert Workarea
162 FREE itab03. "löscht Rumpfzeilen und
gibt Platz frei
163
164 SKIP.
Listing 12.1 Report Z_TEILNEHMERLISTE12_ITAB_WA
Anmerkungen zum Quellcode
Schauen wir uns das Beispiel wieder Zeile für Zeile an.
Zeile 12
Die Workarea für die Datenbanktabelle wird explizit deklariert. Der Zeilentyp ist bereits im ABAP Dictionary deklariert und daher bekannt. Das Datenobjekt WA_ZTEILNEHMER02 wird – wie jedes Datenobjekt – mit der DATA-Anweisung deklariert. Der Name einer Workarea ist frei wählbar, aus Gründen der Lesbarkeit ist es aber weit verbreitet, den Namen mit WA_ beginnen zu lassen.
Zeile 18 bis 21
Der Zeilentyp, der später für die Workarea und die interne Tabelle Verwendung findet, wird deklariert. Es empfiehlt sich, in den Namen des Typs einen Hinweis auf den Verwendungszweck einzubauen, hier auf den Typ 01. In der Praxis würde man dafür sprechende Namensbestandteile wählen, wie z. B. »Rechnungspositionszeile«. Der Zeilentyp besteht hier aus zwei Feldern.
Zeile 23 bis 34
Drei weitere Zeilentypen werden deklariert. Zum besseren Verständnis wurden verschiedene Deklarationsbeispiele gewählt:
-
Beim ersten Zeilentyp wurden die Struktur des Zeilentyps ZEILE01_TYP und ein weiterer Typ eingebunden. Der Zeilentyp enthält sozusagen drei Felder; es handelt sich um eine flache Struktur.
-
Der zweite Zeilentyp enthält nur elementare Typen. Er kann deshalb als Kettensatz geschrieben werden.
-
Beim dritten Zeilentyp wird die Struktur der Datenbanktabelle als Typ eingebunden.
Zeile 37 bis 40
Die Datentypen für die internen Tabellen werden deklariert.
Zeile 43 bis 46
Die Datenobjekte, d. h. die internen Tabellen selbst, werden deklariert.
Zeile 49 bis 52
Für die internen Tabellen wird die zugedachte Workarea deklariert, d. h. das Datenobjekt.
Zeile 66 bis 69
Die interne Tabelle wird gefüllt. Das Lesen und Füllen erfolgt über zwei Workareas in einer Schleife, und zunächst wird eine Zeile der Datenbanktabelle in die Workarea der Datenbanktabelle gestellt. Dann werden die namensgleichen Felder der Workarea für die interne Tabelle gefüllt. Anschließend wird der Inhalt der zweiten Workarea an den Rumpf der internen Tabelle als neue Zeile angehängt.
Zeile 72 bis 73
In diesem Beispiel werden die namensgleichen Spalten der internen Tabelle blockweise gefüllt. Es wird keine Workarea benötigt.
Zeile 96 bis 100
Vor dem neuen Füllen der Workarea wird der Inhalt initialisiert, um Reste des vorherigen Inhalts nicht versehentlich zu übernehmen. Dann wird die Workarea neu aufgebaut und deren Inhalt in den Tabellenrumpf eingefügt. Das Einfügen erfolgt vor dem Index, der im Feld ZEILEN_ITAB01 als Wert steht. Ist der Wert um 1 größer als die Anzahl der Tabellenzeilen, wirkt in diesem Sonderfall per Definition die Anweisung INSERT wie die Anweisung APPEND und hängt die neue Zeile an den Tabellenrumpf an.
Zeile 105 bis 107
Alle Zeilen der internen Tabelle werden Zeile für Zeile in einer Schleife in die Workarea übertragen. Bei der Weiterverarbeitung der Zeile darf ein Feld nun nicht mehr über seinen Tabellennamen angesprochen werden, sondern nur über seinen Workarea-Namen.
Zeile 111 bis 115
Die interne Tabelle wird in einer Schleife zeilenweise verarbeitet. Jede Zeile, die die Bedingung erfüllt, wird in die Workarea gestellt und von dort aus weiterverarbeitet.
Zeile 120 bis 126
In diesem Beispiel wird ein Workarea-Feld geändert und die veränderte Zeile in die Ursprungszeile zurückgeschrieben. Die Rumpfzeile ist damit aktualisiert.
Zeile 149
Im Tabellenrumpf wird mit dieser Anweisung nur eine einzige Zeile gelöscht. Deshalb sollte der Inhalt der Workarea eindeutig die richtige Zeile identifizieren. Falls im Tabellenrumpf mehrere Zeilen mit diesem Inhalt enthalten sind, wird nur die erste Trefferzeile gelöscht; die Suche beginnt bei Zeile 1. Das Löschen mehrerer Zeilen mit einer einzigen DELETE-Anweisung ist ebenfalls möglich. Allerdings müssten dann der Zusatz WHERE und ein logischer Ausdruck die Gruppe von Zeilen identifizieren.
Zeile 155
Die Workarea wird initialisiert.
Zeile 156
Die Anweisung CLEAR wirkt bei internen Tabellen ohne Kopfzeile anders als bei Tabellen mit Kopfzeile. Im Beispiel handelt es sich um eine Tabelle ohne Kopfzeile. Hier werden mit der CLEAR-Anweisung alle Rumpfzeilen der internen Tabelle gelöscht.
Zeile 159
Bei Tabellen ohne Kopfzeile ist die Wirkung der REFRESH-Anweisung mit der CLEAR-Anweisung in Zeile 156 identisch.
Ausgabe des Quellcodes im ABAP Debugger verfolgen
Die internen Abläufe im System verfolgen Sie am besten mit dem ABAP Debugger. Am Stoppschild erkennen Sie den gesetzten Haltepunkt; am gelben Pfeil, vor welcher Anweisung der Debugger gerade steht und welche er als nächste ausführen wird. Mit dem Einzelschritt-Button (
) – oder mit (F5) – führen Sie diese Anweisung aus. Wie in Abbildung 12.1 zu sehen ist, können Sie in der Schleife verfolgen, wie die Workarea der Datenbanktabelle bei jedem Schleifendurchlauf neu gefüllt wird. Über den Einzelschritt-Button () im Tabellenmodus des Debuggers ist der aktuelle Inhalt der Tabelle sichtbar, und Sie können genau verfolgen, wie die Anweisungen des Programms diesen Inhalt verändern.
Abbildung 12.1 Gefüllte Workarea für Datenbanktabelle ZTEILNEHMER02
Auch der Inhalt der Workarea für die interne Tabelle kann geprüft werden: Sie tragen hierzu den Namen der Workarea in das Eingabefeld ein und drücken die (¢)-Taste (siehe Abbildung 12.2).
Abbildung 12.2 Gefüllte Workarea für interne Tabelle ITAB01
Bei Beobachtung der internen Tabelle sehen Sie, wie mit jeder APPEND-Anweisung eine Zeile an den Tabellenrumpf angehängt wird. In Abbildung 12.3 ist zu erkennen, dass das System noch vor der APPEND-Anweisung steht; dies ist am gelben Pfeil vor dem Kommando zu erkennen. Nach dem Klick auf Einzelschritt () sehen Sie, dass der Tabellenrumpf eine zusätzliche Zeile erhalten hat.
Abbildung 12.3 Interne Tabelle aus Workarea füllen
Abbildung 12.4 Alle Rumpfzeilen der internen Tabelle ohne Kopfzeile mit einer CLEAR-Anweisung löschen
In Abbildung 12.4 sehen Sie nur den Tabellenrumpf, da die Tabelle ITAB01 keine Kopfzeile hat. Besäße sie eine Kopfzeile, wäre dies im Debugger an einem Hut zu erkennen (siehe Abbildung 12.6). Das nächste CLEAR-Kommando wird alle Rumpfzeilen der internen Tabelle löschen. Bei einer Tabelle mit Kopfzeile ist die Wirkung anders, wie Sie weiter unten sehen werden. So zeigt Abbildung 12.5 schließlich die leere interne Tabelle nach dem Löschen aller Rumpfzeilen.
Abbildung 12.5 Leere interne Tabelle ohne Rumpfzeile
Einstieg in ABAP
