Performance-Tip

[Walter4536]

Mit diesem Posting möchte ich gerne den Auftakt zu einer Reihe von Performance-Tips eröffnen.
Weitere Tips, Kommentare, Anmerkungen sind willkommen.

Ein beim Programmieren oftmals auftretender Fall: Loop innerhalb eines Loops.

Bsp.: Tabelle A: taba (500 Einträge), Tabelle B: tabb (1000 Einträge). Beide vom Typ Standard Table.

Code: [Select all] [Expand/Collapse] [Download] (Untitled.txt)

1. ...
2. loop at taba.
3.    loop at tabb where key1 = taba-field1 and key2 = taba-field2.
4. *  do whatever          
5.     endloop.
6. endloop.
7. ...
8.  

GeSHi ©

Die obige Vorgehensweise ist aus Performance-Sicht schlecht, da um die notwendigen Einträge in Tabelle B zu finden, ein sog. Full Table-Scan notwendig ist, d.h es werden 500 * 1000 Durchläufe notwendig, in Summe also 500.000 (!)

Eine erste Optimierung wäre, die Tabellen zu sortieren nach deren Schlüsselfeldern und eine READ-Anweisung mit Zusatz BINARY SEARCH zu verwenden:

Code: [Select all] [Expand/Collapse] [Download] (Untitled.txt)

1. ...
2. LOOP AT taba into ls_taba.
3.       READ TABLE tabb into tabbline WITH KEY field1 = ls_taba-field1                      BINARY SEARCH TRANSPORTING field1.
4.       IF sy-subrc eq 0.
5.         l_tabix = sy-tabix.
6.         LOOP AT tabb INTO ls_tabb FROM l_tabix.              
7.              IF ls_tabb-field1 NE tabbline-field1.
8.                EXIT.
9.              Endif.
10.         ENDLOOP.
11.      ENDIF.
12. ENDLOOP.
13. ...
14.  

GeSHi ©

Durch die Ermittlung des Index des relevanten Bereichs in Tabelle tabb und der Abbruchbedingung, wird eine Verbesserung erreicht.

Eine weitere Optimierung wäre, statt einer Standard oder HashedTable eine SortedTable zu verwenden. Wenn man eine Sorted Table verwendet und in der WHERE-Bedingung den kompletten Schlüssel angibt, findet eine automatische Optimierung statt, d.h. man kann das Coding des ersten Beispiels verwenden.

[Willy1492]

Eine erste Optimierung wäre, die Tabellen zu sortieren nach deren Schlüsselfeldern und eine READ-Anweisung mit Zusatz BINARY SEARCH zu verwenden:

Code: [Select all] [Expand/Collapse] [Download] (Untitled.txt)

1. ...
2. LOOP AT taba into ls_taba.
3.       READ TABLE tabb into tabbline WITH KEY field1 = ls_taba-field1                      BINARY SEARCH TRANSPORTING field1.
4. **********
5. * Hier geht auch TRANSPORTING NO FIELDS,
6. * da Du den Eintrag noch mal innerhalb der
7. * LOOP AT itabb FROM ... prozessierst.
8. **********
9.       IF sy-subrc eq 0.
10.         l_tabix = sy-tabix.
11. **********
12. *       Die Hilfsvariable l_tabix ist unnötig,
13. *       LOOP AT tabb INTO ls_tabb FROM sy-tabix
14. *       geht auch, ist aber fehleranfälliger,
15. *       wenn der Code später mal so erweitert wird,
16. *       dass SY-TABIX dabei verändert wird.
17. **********
18.         LOOP AT tabb INTO ls_tabb FROM l_tabix.              
19.              IF ls_tabb-field1 NE tabbline-field1.
20.                EXIT.
21.              Endif.
22. **********
23. * Hier fehlt:
24. *  do whatever ;)
25. **********
26.         ENDLOOP.
27.      ENDIF.
28. ENDLOOP.
29. ...
30.  

GeSHi ©

Das ist sicher besser als das Original-Beispiel.
Aber wenn taba auch entsprechend sortiert ist, kann man sich je nach Aufbau und Inhalt der itabs auch das READ ... WITH KEY ... BINARY SEARCH sparen.
(s. das LOOP-Beispiel aus SE30, Tipps&Tricks und die im Kommentar angegebenen Bedingungen, wann das Konstrukt effektiv angewendet werden kann.).
Man merkt sich immer den zuletzt bei tabb prozessierten Index, bricht die LOOP AT tabb (oder READ TABLE tabb INDEX l_tabix) ab, wenn der Key größer als der aus taba ist, und merkt sich den neuen Index.
Da der Code umfangreicher und nicht auf Anhieb von jedem, der das Programm vielleicht später einmal warten muss, zu verstehen ist, lohnt das aber nur für große itabs und sollte mit erklärenden Kommentaren versehen werden.

[Willy1492]

Und wenn die itab(s) nicht sowieso schon sortiert vorliegen (müssen), ist das erste Beispiel mit LOOP AT taba ... LOOP AT tabb WHERE ... schneller, als wenn man zuvor noch ein SORT einfügt, um dann den Block LOOP AT taba ... ENDLOOP schneller prozessieren zu können.

Die Antwort auf die Frage, welcher Code der effektivste ist, ist also (wie so oft): "It depends ..."

[Alva1590]

Und wenn die itab(s) nicht sowieso schon sortiert vorliegen (müssen), ist das erste Beispiel mit LOOP AT taba ... LOOP AT tabb WHERE ... schneller, als wenn man zuvor noch ein SORT einfügt, um dann den Block LOOP AT taba ... ENDLOOP schneller prozessieren zu können.

Die Antwort auf die Frage, welcher Code der effektivste ist, ist also (wie so oft): "It depends ..."

Mit anderen Worten - der SORT Befehl ist teurer als x full table-scans über die innere interne Tabelle?
Ich gebe ja zu, dass ich die erhöhten Einfügekosten einer sortierten Tabelle oder das sortieren selbst, bei der Betrachtung der Lesezugriffe auf die Tabelle vernachlässigt habe. Ich bin aber davon ausgegangen, dass bei einem geschachteteln Loop der Grossteil der Zeilen durchlaufen werden muss, so dass sich insbesondere bei grossen Tabellen oder häufige Schleifendurchläufe ein Sort immer rentiert.
Hast Du mal versucht einen Schwellwert zu ermitteln? Ab wieviel Durchläufe rentiert sich der Sort? Wann wäre full-table scan vorzuziehen?
Christian

[Willy1492]

Und wenn die itab(s) nicht sowieso schon sortiert vorliegen (müssen), ist das erste Beispiel mit LOOP AT taba ... LOOP AT tabb WHERE ... schneller, als wenn man zuvor noch ein SORT einfügt, um dann den Block LOOP AT taba ... ENDLOOP schneller prozessieren zu können.

Die Antwort auf die Frage, welcher Code der effektivste ist, ist also (wie so oft): "It depends ..."

Mit anderen Worten - der SORT Befehl ist teurer als x full table-scans über die innere interne Tabelle?

Vergiss es, da habe ich gepennt. In den allermeisten Fällen bringt das Sortieren der "inneren" itab etwas, da ja das LOOP AT ... WHERE für jeden Eintrag in der "äußeren" itab einmal prozessiert wird.

Frank

[Alva1590]

Gott sei dank - ich habe schon mein Weltbild wanken sehen.

[Dan1812]

Hallo,

ich habe hier auch noch einen Trick mit parallelem Cursor. Ist leider nicht auf meinem Mist gewachsen, funktioniert aber prima.
siehe Attachment.
Dank an meinen Kollegen Martin.

Gruß HaJo

[Leona853]

Wo ist das Attachment?

lg
Chris

[Dan1812]

Sorry, ich war eine Zeit Offline. Das mit dem Anhang hat nicht geklappt. Ich versuche es nochmal.
Es ist ein Word-Dokument. Bitte vor dem öffnen in .doc umtaufen.

[Heinrich5128]

Hallo Leute,

ich hatte das vor einer ganzen Weile mal ausprobiert.
Anbei verschiedene Lösungen zu dem Problem + Laufzeiten.

Am besten und einfachsten ist es mit sorted Tables zu arbeiten. Das Programm ist dann auch am lesbarsten. Über Read + loop form ... exit ..
bekommt man auch was noch schnelleres hin, aber so viel besser ist das dann auch nicht.

Gruß Volker



REPORT z_inttab.


* Dieser Report legt automatisch drei interne Tabellen an, die folgende
* Verknüpfungen aufweisen:

* Zu jedem Eintrag in g_tab_b1 gehören mehrere Einträge in g_tab_b2.
* Die Verknüpfung wird hierbei über den KEY1 hergestellt.

* Zu jedem Eintrag in g_tab_b2 gehören mehrere Einträge
* in g_tab_b3. Die Verknüpfung wird hier jedoch über das Feld FKEY
* gebildet.

* Die allgemeine Aufgabe ist es, alle Werte in der Tabelle g_tab_b3 zu
* zählen, die zu einem Eintrag in der Tabelle g_tab_b1 gehören, wo das
* Info Feld <= 9 ist.
* Dabei sind doppelte Referenzierungen auf einen FKEY Schlüssel oder
* einen key1 Schlüssel von verschiedenen Datensätzen aus nicht möglich.
* Und müssen auch nicht doppelt gezählt werden.
* Durch diese Einschränkung eröffnen sich auch weitere Lösungsansätze

* Das diese Tabellen dabei nach einer einfachen festen Regel gefüllt
* werden darf bei den Lösungen nicht berücksichtig werden.
* Über diese festen Regeln wird lediglich sichergestellt, daß
* für Laufzeitmessungen sämtliche Lösungen die gleichen Bedingungen
* vorliegen.

* Wird im Feld Version ein Wert angegeben, so wird nur diese eine
* Lösungsvariante vom Programm getestet.



TYPES: BEGIN OF t_tab1,
key1(5) TYPE c,
info TYPE i,
END OF t_tab1.

TYPES: BEGIN OF t_tab2,
key1(5) TYPE c,
key2(6) TYPE c,
wert TYPE i,
fkey TYPE i,
END OF t_tab2.

TYPES: BEGIN OF t_tab3,
fkey TYPE i,
key3 TYPE i,
wert TYPE i,
END OF t_tab3.


DATA: i1 TYPE i, i2 TYPE i, i3 TYPE i.
DATA: ti1 TYPE i,
ti2 TYPE i,
ti3 TYPE i,
wert TYPE i.

DATA: g_tab_b1 TYPE STANDARD TABLE OF t_tab1 WITH HEADER LINE.
DATA: g_tab_b2 TYPE STANDARD TABLE OF t_tab2 WITH HEADER LINE.
DATA: g_tab_b3 TYPE STANDARD TABLE OF t_tab3 WITH HEADER LINE.

DATA: g_tab_b1_c TYPE STANDARD TABLE OF t_tab1 WITH HEADER LINE.
DATA: g_tab_b2_c TYPE STANDARD TABLE OF t_tab2 WITH HEADER LINE.
DATA: g_tab_b3_c TYPE STANDARD TABLE OF t_tab3 WITH HEADER LINE.


PARAMETERS: version TYPE i.




START-OF-SELECTION.
PERFORM init1.


IF version = 0 OR version = 1.
CLEAR wert.
COMMIT WORK.
PERFORM init.
PERFORM loesung1 CHANGING wert.
PERFORM ausgabe USING '1' wert.
ENDIF.


IF version = 0 OR version <= 2.
CLEAR wert.
COMMIT WORK.
PERFORM init.
PERFORM loesung2 CHANGING wert.
PERFORM ausgabe USING '2' wert.
ENDIF.


IF version = 0 OR version <= 3.
CLEAR wert.
COMMIT WORK.
PERFORM init.
PERFORM loesung3 CHANGING wert.
PERFORM ausgabe USING '3' wert.
ENDIF.


IF version = 0 OR version <= 4.
CLEAR wert.
COMMIT WORK.
PERFORM init.
PERFORM loesung4 CHANGING wert.
PERFORM ausgabe USING '4' wert.
ENDIF.



IF version = 0 OR version <= 5.
CLEAR wert.
COMMIT WORK.
PERFORM init.
PERFORM loesung5 CHANGING wert.
PERFORM ausgabe USING '5' wert.
ENDIF.


IF version = 0 OR version <= 6.
CLEAR wert.
COMMIT WORK.
PERFORM init.
PERFORM loesung6 CHANGING wert.
PERFORM ausgabe USING '6' wert.
ENDIF.



IF version = 0 OR version <= 7.
CLEAR wert.
COMMIT WORK.
PERFORM init.
PERFORM loesung7 CHANGING wert.
PERFORM ausgabe USING '7' wert.
ENDIF.


IF version = 0 OR version <= 8.
CLEAR wert.
COMMIT WORK.
PERFORM init.
PERFORM loesung8 CHANGING wert.
PERFORM ausgabe USING '8' wert.
ENDIF.


IF version = 0 OR version <= 9.
CLEAR wert.
COMMIT WORK.
PERFORM init.
PERFORM loesung9 CHANGING wert.
PERFORM ausgabe USING '9' wert.
ENDIF.

IF version = 0 OR version <= 10.
CLEAR wert.
COMMIT WORK.
PERFORM init.
PERFORM loesung10 CHANGING wert.
PERFORM ausgabe USING '10' wert.
ENDIF.


IF version = 0 OR version <= 10.
CLEAR wert.
COMMIT WORK.
PERFORM init.
PERFORM loesung11 CHANGING wert.
PERFORM ausgabe USING '11' wert.
ENDIF.




*---------------------------------------------------------------------*
* FORM init1 *
*---------------------------------------------------------------------*
* ........ *
*---------------------------------------------------------------------*
FORM init1.
REFRESH: g_tab_b1,
g_tab_b2,
g_tab_b3.

i1 = 100.
i2 = 50.
i3 = 10.
CLEAR g_tab_b2-fkey.

WHILE i1 > 2.
i1 = i1 - 1.
i3 = i3 - 1.
IF i3 = 0. i3 = 10. ENDIF.

g_tab_b1-key1 = i1.
g_tab_b1-info = i3.
APPEND g_tab_b1.
WHILE i2 > 2.
i2 = i2 - 1.
g_tab_b2-key1 = i1.
g_tab_b2-key2 = i2.
g_tab_b2-wert = i1 + 1.
g_tab_b2-fkey = g_tab_b2-fkey + 1.
APPEND g_tab_b2.
g_tab_b3-fkey = g_tab_b2-fkey.
g_tab_b3-key3 = 1.
g_tab_b3-wert = i1 + 10.
APPEND g_tab_b3.
g_tab_b3-fkey = g_tab_b2-fkey.
g_tab_b3-key3 = 2.
g_tab_b3-wert = i1 + 15.
APPEND g_tab_b3.
g_tab_b3-fkey = g_tab_b2-fkey.
g_tab_b3-key3 = 3.
g_tab_b3-wert = i1 + 30.
APPEND g_tab_b3.
g_tab_b3-fkey = g_tab_b2-fkey.
g_tab_b3-key3 = 4.
g_tab_b3-wert = i1 + 30.
APPEND g_tab_b3.
g_tab_b3-fkey = g_tab_b2-fkey.
g_tab_b3-key3 = 5.
g_tab_b3-wert = i1 + 30.
APPEND g_tab_b3.
g_tab_b3-fkey = g_tab_b2-fkey.
g_tab_b3-key3 = 6.
g_tab_b3-wert = i1 + 30.
APPEND g_tab_b3.



IF i2 = 38 OR i2 = 836.
g_tab_b2-key1 = i2.
g_tab_b2-key2 = i2 + i1 + 1000.
g_tab_b2-fkey = g_tab_b2-fkey + 1.
APPEND g_tab_b2.

g_tab_b3-fkey = g_tab_b2-fkey.
g_tab_b3-wert = i1 + 10.
APPEND g_tab_b3.

ENDIF.

ENDWHILE.
i2 = 50.
ENDWHILE.

g_tab_b1_c[] = g_tab_b1[].
g_tab_b2_c[] = g_tab_b2[].
g_tab_b3_c[] = g_tab_b3[].

ENDFORM.



*---------------------------------------------------------------------*
* FORM init *
*---------------------------------------------------------------------*
* ........ *
*---------------------------------------------------------------------*
FORM init.
REFRESH: g_tab_b1,
g_tab_b2,
g_tab_b3.


g_tab_b1[] = g_tab_b1_c[].
g_tab_b2[] = g_tab_b2_c[].
g_tab_b3[] = g_tab_b3_c[].
GET RUN TIME FIELD ti1.
ENDFORM.

*---------------------------------------------------------------------*
* FORM Ausgabe *
*---------------------------------------------------------------------*
* ........ *
*---------------------------------------------------------------------*
* --> Nr *
* --> Wert *
*---------------------------------------------------------------------*
FORM ausgabe USING nr TYPE i
wert TYPE i.

DATA: text(7) TYPE c.
DATA: text2(20) TYPE c.

WRITE nr TO text.
GET RUN TIME FIELD ti2.
ti3 = ti2 - ti1.
WRITE ti3 TO text2.

WRITE: / 'Lösung Nr.', text, ' Laufzeit:', text2, ' Wert:',wert.

ENDFORM.



*---------------------------------------------------------------------*
* FORM loesung1 *
*---------------------------------------------------------------------*
* ........ *
*---------------------------------------------------------------------*
* --> wert *
*---------------------------------------------------------------------*
FORM loesung1 CHANGING wert TYPE i.


LOOP AT g_tab_b1 WHERE info <= 9.
LOOP AT g_tab_b2 WHERE key1 = g_tab_b1-key1.
LOOP AT g_tab_b3 WHERE fkey = g_tab_b2-fkey.
wert = wert + g_tab_b3-wert.
ENDLOOP.
ENDLOOP.
ENDLOOP.
ENDFORM.


*---------------------------------------------------------------------*
* FORM loesung2 *
*---------------------------------------------------------------------*
* ........ *
*---------------------------------------------------------------------*
* --> wert *
*---------------------------------------------------------------------*
FORM loesung2 CHANGING wert TYPE i.

FIELD-SYMBOLS:
<l_str_b1> LIKE LINE OF g_tab_b1,
<l_str_b2> LIKE LINE OF g_tab_b2,
<l_str_b3> LIKE LINE OF g_tab_b3.

LOOP AT g_tab_b1 ASSIGNING <l_str_b1> WHERE info <= 9.
LOOP AT g_tab_b2 ASSIGNING <l_str_b2> WHERE key1 = <l_str_b1>-key1.
LOOP AT g_tab_b3 ASSIGNING <l_str_b3> WHERE fkey = <l_str_b2>-fkey.
wert = wert + <l_str_b3>-wert.
ENDLOOP.
ENDLOOP.
ENDLOOP.
ENDFORM.


*---------------------------------------------------------------------*
* FORM loesung3 *
*---------------------------------------------------------------------*
* ........ *
*---------------------------------------------------------------------*
* --> wert *
*---------------------------------------------------------------------*
FORM loesung3 CHANGING wert TYPE i.

FIELD-SYMBOLS:
<l_str_b1> LIKE LINE OF g_tab_b1,
<l_str_b2> LIKE LINE OF g_tab_b2,
<l_str_b3> LIKE LINE OF g_tab_b3.

SORT g_tab_b1 BY key1.
SORT g_tab_b2 BY fkey.

LOOP AT g_tab_b3 ASSIGNING <l_str_b3>.
READ TABLE g_tab_b2 ASSIGNING <l_str_b2>
WITH KEY fkey = <l_str_b3>-fkey
BINARY SEARCH.
IF sy-subrc = 0.
READ TABLE g_tab_b1 ASSIGNING <l_str_b1>
WITH KEY key1 = <l_str_b2>-key1
BINARY SEARCH.
IF sy-subrc = 0.
IF <l_str_b1>-info <= 9.
wert = wert + <l_str_b3>-wert.
ENDIF.
ENDIF.
ENDIF.
ENDLOOP.
ENDFORM.


*---------------------------------------------------------------------*
* FORM loesung4 *
*---------------------------------------------------------------------*
* ........ *
*---------------------------------------------------------------------*
* --> wert *
*---------------------------------------------------------------------*
FORM loesung4 CHANGING wert TYPE i.

FIELD-SYMBOLS:
<l_str_b1> LIKE LINE OF g_tab_b1,
<l_str_b2> LIKE LINE OF g_tab_b2,
<l_str_b3> LIKE LINE OF g_tab_b3.


DATA: l_tab_b1 TYPE HASHED TABLE OF t_tab1 WITH UNIQUE KEY key1.
DATA: l_tab_b2 TYPE HASHED TABLE OF t_tab2 WITH UNIQUE KEY key1 key2.
DATA: l_tab_b3 TYPE HASHED TABLE OF t_tab3 WITH UNIQUE KEY fkey key3.

INSERT LINES OF g_tab_b1 INTO TABLE l_tab_b1.
INSERT LINES OF g_tab_b2 INTO TABLE l_tab_b2.
INSERT LINES OF g_tab_b3 INTO TABLE l_tab_b3.

LOOP AT l_tab_b1 ASSIGNING <l_str_b1> WHERE info <= 9.
LOOP AT l_tab_b2 ASSIGNING <l_str_b2> WHERE key1 = <l_str_b1>-key1.
LOOP AT l_tab_b3 ASSIGNING <l_str_b3> WHERE fkey = <l_str_b2>-fkey.
wert = wert + <l_str_b3>-wert.
ENDLOOP.
ENDLOOP.
ENDLOOP.
ENDFORM.



*---------------------------------------------------------------------*
* FORM loesung5 *
*---------------------------------------------------------------------*
* ........ *
*---------------------------------------------------------------------*
* --> wert *
*---------------------------------------------------------------------*
FORM loesung5 CHANGING wert TYPE i.

DATA:
l_tabix2 LIKE sy-tabix,
l_tabix3 LIKE sy-tabix,
l_tabix2_2 LIKE sy-tabix,
l_tabix3_2 LIKE sy-tabix.


FIELD-SYMBOLS:
<l_str_b1> LIKE LINE OF g_tab_b1,
<l_str_b2> LIKE LINE OF g_tab_b2,
<l_str_b3> LIKE LINE OF g_tab_b3.

SORT g_tab_b1 BY key1.
SORT g_tab_b2 BY key1.
SORT g_tab_b3 BY fkey.

CLEAR: l_tabix2_2, l_tabix3_2.


LOOP AT g_tab_b1 ASSIGNING <l_str_b1> WHERE info <= 9.
l_tabix2 = l_tabix2_2.
LOOP AT g_tab_b2 FROM l_tabix2 ASSIGNING <l_str_b2>.
IF <l_str_b2>-key1 = <l_str_b1>-key1.
l_tabix2_2 = sy-tabix.


READ TABLE g_tab_b3 WITH KEY fkey = <l_str_b2>-fkey
BINARY SEARCH.
IF sy-subrc = 0.
l_tabix3 = sy-tabix.
LOOP AT g_tab_b3 FROM l_tabix3 ASSIGNING <l_str_b3>.
IF <l_str_b3>-fkey = <l_str_b2>-fkey.
wert = wert + <l_str_b3>-wert.
ELSE.
IF <l_str_b3>-fkey > <l_str_b2>-fkey. EXIT. ENDIF.
ENDIF.
ENDLOOP.
ENDIF.


ELSE.
IF <l_str_b2>-key1 > <l_str_b1>-key1. EXIT. ENDIF.
ENDIF.
ENDLOOP.
ENDLOOP.
ENDFORM.


*---------------------------------------------------------------------*
* FORM loesung5 *
*---------------------------------------------------------------------*
* ........ *
*---------------------------------------------------------------------*
* --> wert *
*---------------------------------------------------------------------*
FORM loesung6 CHANGING wert TYPE i.

DATA:
l_tabix2 LIKE sy-tabix,
l_tabix3 LIKE sy-tabix,
l_tabix2_2 LIKE sy-tabix,
l_tabix3_2 LIKE sy-tabix.



SORT g_tab_b1 BY key1.
SORT g_tab_b2 BY key1.
SORT g_tab_b3 BY fkey.

CLEAR: l_tabix2_2, l_tabix3_2.


LOOP AT g_tab_b1 WHERE info <= 9.
l_tabix2 = l_tabix2_2.
LOOP AT g_tab_b2 FROM l_tabix2.
IF g_tab_b2-key1 = g_tab_b1-key1.
l_tabix2_2 = sy-tabix.


READ TABLE g_tab_b3 WITH KEY fkey = g_tab_b2-fkey
BINARY SEARCH.
IF sy-subrc = 0.
l_tabix3 = sy-tabix.
LOOP AT g_tab_b3 FROM l_tabix3.
IF g_tab_b3-fkey = g_tab_b2-fkey.
wert = wert + g_Tab_b3-wert.
ELSE.
IF g_tab_b3-fkey > g_tab_b2-fkey. EXIT. ENDIF.
ENDIF.
ENDLOOP.
ENDIF.


ELSE.
IF g_tab_b2-key1 > g_tab_b1-key1. EXIT. ENDIF.
ENDIF.
ENDLOOP.
ENDLOOP.
ENDFORM.





*---------------------------------------------------------------------*
* FORM loesung5 *
*---------------------------------------------------------------------*
* ........ *
*---------------------------------------------------------------------*
* --> wert *
*---------------------------------------------------------------------*
FORM loesung7 CHANGING wert TYPE i.

DATA:
l_tabix2 LIKE sy-tabix,
l_tabix3 LIKE sy-tabix,
l_tabix2_2 LIKE sy-tabix,
l_tabix3_2 LIKE sy-tabix.


DATA: l_tah_b3 TYPE HASHED TABLE OF t_tab3
WITH UNIQUE KEY fkey.



FIELD-SYMBOLS:
<l_str_b1> LIKE LINE OF g_tab_b1,
<l_str_b2> LIKE LINE OF g_tab_b2,
<l_str_b3> LIKE LINE OF g_tab_b3.

SORT g_tab_b1 BY key1.
SORT g_tab_b2 BY key1.


loop at g_tab_b3 assigning <l_Str_b3>.
collect <l_str_b3> into l_tah_b3.
endloop.

CLEAR: l_tabix2_2, l_tabix3_2.


LOOP AT g_tab_b1 ASSIGNING <l_str_b1> WHERE info <= 9.
l_tabix2 = l_tabix2_2.
LOOP AT g_tab_b2 FROM l_tabix2 ASSIGNING <l_str_b2>.
IF <l_str_b2>-key1 = <l_str_b1>-key1.
l_tabix2_2 = sy-tabix.


READ TABLE l_tah_b3 ASSIGNING <l_str_b3>
WITH KEY fkey = <l_str_b2>-fkey.
wert = wert + <l_str_b3>-wert.


ELSE.
IF <l_str_b2>-key1 > <l_str_b1>-key1. EXIT. ENDIF.
ENDIF.
ENDLOOP.
ENDLOOP.
ENDFORM.



*---------------------------------------------------------------------*
* FORM loesung5 *
*---------------------------------------------------------------------*
* ........ *
*---------------------------------------------------------------------*
* --> wert *
*---------------------------------------------------------------------*
FORM loesung8 CHANGING wert TYPE i.

DATA:
l_tabix2 LIKE sy-tabix,
l_tabix3 LIKE sy-tabix,
l_tabix2_2 LIKE sy-tabix,
l_tabix3_2 LIKE sy-tabix.


DATA: l_tas_b3 TYPE sorted TABLE OF t_tab3
WITH UNIQUE KEY fkey.



FIELD-SYMBOLS:
<l_str_b1> LIKE LINE OF g_tab_b1,
<l_str_b2> LIKE LINE OF g_tab_b2,
<l_str_b3> LIKE LINE OF g_tab_b3.

SORT g_tab_b1 BY key1.
SORT g_tab_b2 BY key1.


loop at g_tab_b3 assigning <l_Str_b3>.
collect <l_str_b3> into l_tas_b3.
endloop.

CLEAR: l_tabix2_2, l_tabix3_2.


LOOP AT g_tab_b1 ASSIGNING <l_str_b1> WHERE info <= 9.
l_tabix2 = l_tabix2_2.
LOOP AT g_tab_b2 FROM l_tabix2 ASSIGNING <l_str_b2>.
IF <l_str_b2>-key1 = <l_str_b1>-key1.
l_tabix2_2 = sy-tabix.


READ TABLE l_tas_b3 ASSIGNING <l_str_b3>
WITH KEY fkey = <l_str_b2>-fkey.


wert = wert + <l_str_b3>-wert.


ELSE.
IF <l_str_b2>-key1 > <l_str_b1>-key1. EXIT. ENDIF.
ENDIF.
ENDLOOP.
ENDLOOP.
ENDFORM.




*---------------------------------------------------------------------*
* FORM loesung5 *
*---------------------------------------------------------------------*
* ........ *
*---------------------------------------------------------------------*
* --> wert *
*---------------------------------------------------------------------*
FORM loesung9 CHANGING wert TYPE i.

DATA:
l_tabix2 LIKE sy-tabix,
l_tabix3 LIKE sy-tabix,
l_tabix2_2 LIKE sy-tabix,
l_tabix3_2 LIKE sy-tabix.


DATA: l_tas_b3 TYPE sorted TABLE OF t_tab3 with header line
WITH UNIQUE KEY fkey.




SORT g_tab_b1 BY key1.
SORT g_tab_b2 BY key1.


loop at g_tab_b3 .
collect g_tab_b3 into l_tas_b3.
endloop.

CLEAR: l_tabix2_2, l_tabix3_2.


LOOP AT g_tab_b1 WHERE info <= 9.
l_tabix2 = l_tabix2_2.
LOOP AT g_tab_b2 FROM l_tabix2.
IF g_tab_b2-key1 = g_tab_b1-key1.
l_tabix2_2 = sy-tabix.


READ TABLE l_tas_b3
WITH KEY fkey = g_tab_b2-fkey.


wert = wert + l_tas_b3-wert.


ELSE.
IF g_tab_b2-key1 > g_tab_b1-key1. EXIT. ENDIF.
ENDIF.
ENDLOOP.
ENDLOOP.
ENDFORM.




*---------------------------------------------------------------------*
* FORM loesung4 *
*---------------------------------------------------------------------*
* ........ *
*---------------------------------------------------------------------*
* --> wert *
*---------------------------------------------------------------------*
FORM loesung10 CHANGING wert TYPE i.

FIELD-SYMBOLS:
<l_str_b1> LIKE LINE OF g_tab_b1,
<l_str_b2> LIKE LINE OF g_tab_b2,
<l_str_b3> LIKE LINE OF g_tab_b3.


DATA: l_tab_b1 TYPE sorted TABLE OF t_tab1 WITH UNIQUE KEY key1.
DATA: l_tab_b2 TYPE sorted TABLE OF t_tab2 WITH UNIQUE KEY key1 key2.
DATA: l_tab_b3 TYPE sorted TABLE OF t_tab3 WITH UNIQUE KEY fkey key3.

INSERT LINES OF g_tab_b1 INTO TABLE l_tab_b1.
INSERT LINES OF g_tab_b2 INTO TABLE l_tab_b2.
INSERT LINES OF g_tab_b3 INTO TABLE l_tab_b3.

LOOP AT l_tab_b1 ASSIGNING <l_str_b1> WHERE info <= 9.
LOOP AT l_tab_b2 ASSIGNING <l_str_b2> WHERE key1 = <l_str_b1>-key1.
LOOP AT l_tab_b3 ASSIGNING <l_str_b3> WHERE fkey = <l_str_b2>-fkey.
wert = wert + <l_str_b3>-wert.
ENDLOOP.
ENDLOOP.
ENDLOOP.
ENDFORM.




*---------------------------------------------------------------------*
* FORM loesung4 *
*---------------------------------------------------------------------*
* ........ *
*---------------------------------------------------------------------*
* --> wert *
*---------------------------------------------------------------------*
FORM loesung11 CHANGING wert TYPE i.

FIELD-SYMBOLS:
<l_str_b1> LIKE LINE OF g_tab_b1,
<l_str_b2> LIKE LINE OF g_tab_b2,
<l_str_b3> LIKE LINE OF g_tab_b3.


DATA: l_tab_b1 TYPE sorted TABLE OF t_tab1 WITH NON-UNIQUE KEY key1.
DATA: l_tab_b2 TYPE sorted TABLE OF t_tab2
WITH NON-UNIQUE KEY key1 key2.
DATA: l_tab_b3 TYPE sorted TABLE OF t_tab3
WITH NON-UNIQUE KEY fkey key3.

INSERT LINES OF g_tab_b1 INTO TABLE l_tab_b1.
INSERT LINES OF g_tab_b2 INTO TABLE l_tab_b2.
INSERT LINES OF g_tab_b3 INTO TABLE l_tab_b3.

LOOP AT l_tab_b1 ASSIGNING <l_str_b1> WHERE info <= 9.
LOOP AT l_tab_b2 ASSIGNING <l_str_b2> WHERE key1 = <l_str_b1>-key1.
LOOP AT l_tab_b3 ASSIGNING <l_str_b3> WHERE fkey = <l_str_b2>-fkey.
wert = wert + <l_str_b3>-wert.
ENDLOOP.
ENDLOOP.
ENDLOOP.
ENDFORM.