Improve Performance

[576512765hsgssdd]

*&---------------------------------------------------------------------*
*& Report ZTEST_ZCTVWALL
*&---------------------------------------------------------------------*
*&
*&---------------------------------------------------------------------*
REPORT ZTEST_ZCTVWALL.
TABLES: MARA, MARC, ZMSLSTAT, EINA, EINE.
SELECT-OPTIONS: S_MATNR FOR MARC-MATNR,
S_LIFNR FOR EINA-LIFNR.
PARAMETERS : P_WERKS LIKE MARC-WERKS OBLIGATORY,
P_OHNEUM RADIOBUTTON GROUP R1,
P_MITUM RADIOBUTTON GROUP R1,
P_MAX RADIOBUTTON GROUP R2,
P_MIN RADIOBUTTON GROUP R2.
SELECT-OPTIONS: S_MONAT FOR ZMSLSTAT-MONAT.


DATA: BEGIN OF T_EINA OCCURS 0,
INFNR TYPE EINA-INFNR,
MATNR TYPE EINA-MATNR,
LIFNR TYPE EINA-LIFNR,
END OF T_EINA.

FIELD-SYMBOLS : <FS_EINA> LIKE T_EINA.
ASSIGN T_EINA TO <FS_EINA>.

*DATA: BEGIN OF WA_EINE,
* INFNR TYPE EINE-INFNR,
* EKORG TYPE EINE-EKORG,
* WERKS TYPE EINE-WERKS,
* END OF WA_EINE.

DATA: BEGIN OF T_MARCI OCCURS 0,
MATNR TYPE MARC-MATNR,
WERKS TYPE MARC-WERKS,
MMSTA TYPE MARC-MMSTA,
END OF T_MARCI.

FIELD-SYMBOLS : <FS_MARCI> LIKE T_MARCI.
ASSIGN T_MARCI TO <FS_MARCI>.


TYPES: BEGIN OF TY_MARC,
MATNR TYPE MARC-MATNR,
WERKS TYPE MARC-WERKS,
MMSTA TYPE MARC-MMSTA,
END OF TY_MARC.

DATA: T_MARC TYPE SORTED TABLE OF TY_MARC
WITH HEADER LINE
WITH UNIQUE KEY MATNR WERKS.

FIELD-SYMBOLS : <FS_MARC> LIKE T_MARC.
ASSIGN T_MARC TO <FS_MARC>.

TYPES: BEGIN OF TY_MAT,
MATNRINIT TYPE MARC-MATNR,
WERKSINIT TYPE MARC-WERKS,
MATNR TYPE MARC-MATNR,
WERKS TYPE MARC-WERKS,
END OF TY_MAT.
DATA: T_MAT TYPE SORTED TABLE OF TY_MAT
WITH HEADER LINE
WITH UNIQUE KEY MATNRINIT WERKSINIT
MATNR WERKS.


TYPES: BEGIN OF TY_OUT,
MATNRINIT TYPE MARC-MATNR,
WERKSINIT TYPE MARC-WERKS,
MATNR TYPE MARC-MATNR,
WERKS TYPE MARC-WERKS,
BKLAS TYPE MBEW-BKLAS,
MAKTX TYPE MAKT-MAKTX,
UMGES TYPE ZMSLSTAT-UMGES,
END OF TY_OUT.
DATA : T_OUT TYPE TABLE OF TY_OUT,
WA_OUT TYPE TY_OUT.

CONSTANTS : CO_E VALUE 'E'.

TYPES: BEGIN OF TY_MAKT,
MATNR TYPE MAKT-MATNR,
SPRAS TYPE MAKT-SPRAS,
MAKTX TYPE MAKT-MAKTX,
END OF TY_MAKT.
DATA: T_MAKT TYPE SORTED TABLE OF TY_MAKT
WITH HEADER LINE
WITH UNIQUE KEY MATNR SPRAS.

FIELD-SYMBOLS : <FS_MAKT> LIKE T_MAKT.
ASSIGN T_MAKT TO <FS_MAKT>.

TYPES: BEGIN OF TY_MBEW,
MATNR TYPE MBEW-MATNR,
BWKEY TYPE MBEW-BWKEY,
BKLAS TYPE MBEW-BKLAS,
END OF TY_MBEW.
DATA: T_MBEW TYPE SORTED TABLE OF TY_MBEW
WITH HEADER LINE
WITH UNIQUE KEY MATNR BWKEY.

FIELD-SYMBOLS: <FS_MBEW> LIKE T_MBEW.
ASSIGN T_MBEW TO <FS_MBEW>.

DATA: BEGIN OF T_MATALL OCCURS 0,
MATNRINIT TYPE MARC-MATNR,
WERKSINIT TYPE MARC-WERKS,
MATNRWKINIT TYPE MARC-MATNR,
WERKSWKINIT TYPE MARC-WERKS,
MATNRV TYPE MARC-MATNR,
WERKSV TYPE MARC-WERKS,
MATNR TYPE MARC-MATNR,
WERKS TYPE MARC-WERKS,
STUFE(3) TYPE N,
TVW TYPE C,
END OF T_MATALL.

FIELD-SYMBOLS : <FS_MATALL> LIKE T_MATALL.
ASSIGN T_MATALL TO <FS_MATALL>.

DATA: BEGIN OF T_MATNEW OCCURS 0,
MATNRINIT TYPE MARC-MATNR,
WERKSINIT TYPE MARC-WERKS,
MATNRWKINIT TYPE MARC-MATNR,
WERKSWKINIT TYPE MARC-WERKS,
MATNRV TYPE MARC-MATNR,
WERKSV TYPE MARC-WERKS,
MATNR TYPE MARC-MATNR,
WERKS TYPE MARC-WERKS,
END OF T_MATNEW.

FIELD-SYMBOLS : <FS_MATNEW> LIKE T_MATNEW.
ASSIGN T_MATNEW TO <FS_MATNEW>.

DATA: BEGIN OF T_MATAKT OCCURS 0,
MATNRINIT TYPE MARC-MATNR,
WERKSINIT TYPE MARC-WERKS,
MATNRWKINIT TYPE MARC-MATNR,
WERKSWKINIT TYPE MARC-WERKS,
MATNRV TYPE MARC-MATNR,
WERKSV TYPE MARC-WERKS,
MATNR TYPE MARC-MATNR,
WERKS TYPE MARC-WERKS,
END OF T_MATAKT.

FIELD-SYMBOLS : <FS_MATAKT> LIKE T_MATAKT.
ASSIGN T_MATAKT TO <FS_MATAKT>.

TYPES: BEGIN OF TY_ZMSLSTAT,
MATNR TYPE ZMSLSTAT-MATNR,
WERKS TYPE ZMSLSTAT-WERKS,
URSAT TYPE ZMSLSTAT-URSAT,
UMGES TYPE ZMSLSTAT-UMGES,
END OF TY_ZMSLSTAT.

DATA: T_ZMSLSTAT1 TYPE SORTED TABLE OF TY_ZMSLSTAT
WITH UNIQUE KEY MATNR WERKS URSAT
WITH HEADER LINE.

FIELD-SYMBOLS : <FS_ZMSLSTAT1> LIKE T_ZMSLSTAT1.
ASSIGN T_ZMSLSTAT1 TO <FS_ZMSLSTAT1>.


DATA: BEGIN OF T_ZMSLSTAT2 OCCURS 0,
MATNR TYPE ZMSLSTAT-MATNR,
WERKS TYPE ZMSLSTAT-WERKS,
MONAT TYPE ZMSLSTAT-MONAT,
KUNUR TYPE ZMSLSTAT-KUNUR,
MATUR TYPE ZMSLSTAT-MATUR,
VKORG TYPE ZMSLSTAT-VKORG,
VTWEG TYPE ZMSLSTAT-VTWEG,
URSAT TYPE ZMSLSTAT-URSAT,
UMGES TYPE ZMSLSTAT-UMGES,
END OF T_ZMSLSTAT2.


DATA: T_ZMSLSTAT TYPE SORTED TABLE OF TY_ZMSLSTAT
WITH UNIQUE KEY MATNR WERKS URSAT
WITH HEADER LINE.

FIELD-SYMBOLS : <FS_ZMSLSTAT2> LIKE T_ZMSLSTAT2.
ASSIGN T_ZMSLSTAT2 TO <FS_ZMSLSTAT2>.

DATA: BEGIN OF T_ZMSLWERK OCCURS 0,
WERKS TYPE ZMSLWERK-WERKS,
STWAE TYPE ZMSLWERK-STWAE,
END OF T_ZMSLWERK.

FIELD-SYMBOLS : <FS_ZMSLSTAT> LIKE T_ZMSLSTAT.
ASSIGN T_ZMSLSTAT TO <FS_ZMSLSTAT>.

DATA: BEGIN OF T_EKKO OCCURS 0,
EBELN TYPE EKKO-EBELN,
LIFNR TYPE EKKO-LIFNR,
END OF T_EKKO.

DATA: BEGIN OF WA_EKPO,
EBELN TYPE EKPO-EBELN,
MATNR TYPE EKPO-MATNR,
WERKS TYPE EKPO-WERKS,
END OF WA_EKPO.



DATA: LT_WULTB LIKE STPOV OCCURS 0 WITH HEADER LINE,
LT_EQUICAT LIKE CSCEQUI OCCURS 0 WITH HEADER LINE,
LT_KNDCAT LIKE CSCKND OCCURS 0 WITH HEADER LINE,
LT_MATCAT LIKE CSCMAT OCCURS 0 WITH HEADER LINE,
LT_STDCAT LIKE CSCSTD OCCURS 0 WITH HEADER LINE,
LT_TPLCAT LIKE CSCTPL OCCURS 0 WITH HEADER LINE,

LS_WULTB TYPE STPOV.
DATA: V_STUFE(3) TYPE N,
V_STUFE1 TYPE N,
V_STUFEC TYPE C,
F_ANZ TYPE P.

PERFORM GET-DATA.
PERFORM TVW.
PERFORM GET-PLANT.
PERFORM GET-MAKT.
PERFORM GET-MBEW.
PERFORM OUTPUT.
*&---------------------------------------------------------------------*
*& Form GET-DATA
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
* --> p1 text
* <-- p2 text
*----------------------------------------------------------------------*
FORM GET-DATA .
IF S_LIFNR-LOW > ' '.
SELECT INFNR, MATNR, LIFNR FROM EINA
INTO TABLE @T_EINA
WHERE LIFNR IN @S_LIFNR
AND MATNR IN @S_MATNR
AND LOEKZ = ' '.
IF T_EINA[] IS NOT INITIAL.
SELECT INFNR, EKORG, WERKS FROM EINE
INTO TABLE @DATA(T_EINE)
FOR ALL ENTRIES IN @T_EINA
WHERE INFNR = @T_EINA-INFNR
AND WERKS = @P_WERKS
AND LOEKZ = ' '. "#EC CI_NO_TRANSFORM
ENDIF.
SORT T_EINA BY INFNR.
SORT T_EINE BY INFNR.

LOOP AT T_EINA INTO <FS_EINA>.
IF T_EINE IS NOT INITIAL.
READ TABLE T_EINE ASSIGNING FIELD-SYMBOL(<FS_EINE>) WITH KEY INFNR = <FS_EINA>-INFNR BINARY SEARCH.
IF SY-SUBRC = 0.
LOOP AT T_EINE INTO <FS_EINE> FROM SY-TABIX.
IF <FS_EINE>-INFNR NE <FS_EINA>-INFNR.
EXIT.
ENDIF.
T_MARCI-MATNR = <FS_EINA>-MATNR.
T_MARCI-WERKS = <FS_EINE>-WERKS.
APPEND T_MARCI.
* CLEAR : <FS_EINE>.
ENDLOOP.
ENDIF.
ENDIF.
* CLEAR : <FS_EINA>.

ENDLOOP.

SELECT EBELN, LIFNR FROM EKKO
INTO TABLE @T_EKKO
WHERE BSTYP = 'L'
AND LIFNR IN @S_LIFNR
AND LOEKZ = ' '
AND KDATB <= @SY-DATUM
AND KDATE >= @SY-DATUM.

IF T_EKKO[] IS NOT INITIAL.
SELECT EBELN, MATNR, WERKS FROM EKPO
INTO TABLE @DATA(T_EKPO)
FOR ALL ENTRIES IN @T_EKKO
WHERE EBELN = @T_EKKO-EBELN
AND MATNR IN @S_MATNR
AND WERKS = @P_WERKS
AND LOEKZ = ' '. "#EC CI_NO_TRANSFORM
ENDIF.

SORT T_EKKO BY EBELN.
SORT T_EKPO BY EBELN.

LOOP AT T_EKKO ASSIGNING FIELD-SYMBOL(<FS_EKKO>).
IF T_EKPO IS NOT INITIAL.
READ TABLE T_EKPO ASSIGNING FIELD-SYMBOL(<FS_EKPO>) WITH KEY <FS_EKKO>-EBELN BINARY SEARCH.
IF SY-SUBRC = 0.
LOOP AT T_EKPO INTO <FS_EKPO> FROM SY-TABIX.
IF <FS_EKKO>-EBELN NE <FS_EKPO>-EBELN.
EXIT.
ENDIF.
T_MARCI-MATNR = <FS_EKPO>-MATNR.
T_MARCI-WERKS = <FS_EKPO>-WERKS.
APPEND T_MARCI.
* CLEAR : <FS_EKPO>.
ENDLOOP.
ENDIF.
ENDIF.
* CLEAR : <FS_EKKO>.
ENDLOOP.

SORT T_MARCI[] BY MATNR WERKS.
DELETE ADJACENT DUPLICATES FROM T_MARCI[] COMPARING MATNR WERKS.
ELSE.
SELECT MATNR WERKS MMSTA FROM MARC
INTO TABLE T_MARCI
WHERE MATNR IN S_MATNR
AND WERKS = P_WERKS.
ENDIF.

IF T_MARCI[] IS INITIAL.
WRITE: /'Keine Daten gefunden'.
EXIT.
ENDIF.

SELECT MATNR WERKS MMSTA
FROM MARC
INTO TABLE T_MARC
WHERE MMSTA > '28'
AND MMSTA < '94' . "ORDER BY PRIMARY KEY.

LOOP AT T_MARCI INTO <FS_MARCI>.
READ TABLE T_MARC INTO <FS_MARC> WITH KEY MATNR = <FS_MARCI>-MATNR
WERKS = <FS_MARCI>-WERKS BINARY SEARCH.
IF SY-SUBRC = 0.
READ TABLE T_MAT WITH KEY MATNRINIT = <FS_MARC>-MATNR
WERKSINIT = <FS_MARC>-WERKS
MATNR = <FS_MARC>-MATNR
WERKS = <FS_MARC>-WERKS BINARY SEARCH.
IF SY-SUBRC = 0.
CONTINUE.
ELSE.
MOVE-CORRESPONDING <FS_MARC> TO T_MAT.
T_MAT-MATNRINIT = <FS_MARC>-MATNR.
T_MAT-WERKSINIT = <FS_MARC>-WERKS.
INSERT TABLE T_MAT.
ENDIF.
APPEND VALUE #( MATNRINIT = <FS_MARC>-MATNR
WERKSINIT = <FS_MARC>-WERKS
MATNRWKINIT = <FS_MARC>-MATNR
WERKSWKINIT = <FS_MARC>-WERKS
MATNRV = <FS_MARC>-MATNR
WERKSV = <FS_MARC>-WERKS
MATNR = <FS_MARC>-MATNR
WERKS = <FS_MARC>-WERKS ) TO T_MATNEW.

APPEND VALUE #( MATNRINIT = <FS_MARC>-MATNR
WERKSINIT = <FS_MARC>-WERKS
MATNRWKINIT = <FS_MARC>-MATNR
WERKSWKINIT = <FS_MARC>-WERKS
MATNR = <FS_MARC>-MATNR
WERKS = <FS_MARC>-WERKS
STUFE = 0 ) TO T_MATALL.
ELSE.
* CLEAR <FS_MARC>.
ENDIF.
ENDLOOP.
ENDFORM.
*&---------------------------------------------------------------------*
*& Form TVW
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
* --> p1 text
* <-- p2 text
*----------------------------------------------------------------------*
FORM TVW .
DO.
IF T_MATNEW[] IS INITIAL.
EXIT.
ENDIF.
V_STUFE = V_STUFE + 1.
CLEAR T_MATAKT[].

APPEND LINES OF T_MATNEW[] TO T_MATAKT[].
CLEAR T_MATNEW[].


SORT T_MATAKT[] BY MATNRINIT WERKSINIT MATNR WERKS.
LOOP AT T_MATAKT INTO <FS_MATAKT>.
REFRESH: LT_WULTB[],
LT_EQUICAT[],
LT_KNDCAT[],
LT_MATCAT[],
LT_STDCAT[],
LT_TPLCAT[].

CALL FUNCTION 'CS_WHERE_USED_MAT'
EXPORTING
DATUB = SY-DATUM
DATUV = SY-DATUM
MATNR = <FS_MATAKT>-MATNR
WERKS = <FS_MATAKT>-WERKS
TABLES
WULTB = LT_WULTB
EQUICAT = LT_EQUICAT
KNDCAT = LT_KNDCAT
MATCAT = LT_MATCAT
STDCAT = LT_STDCAT
TPLCAT = LT_TPLCAT
EXCEPTIONS
CALL_INVALID = 1
MATERIAL_NOT_FOUND = 2
NO_WHERE_USED_REC_FOUND = 3
NO_WHERE_USED_REC_SELECTED = 4
NO_WHERE_USED_REC_VALID = 5
OTHERS = 6.


IF LT_WULTB[] IS NOT INITIAL.
SORT LT_WULTB[] BY MATNR WERKS.
LOOP AT LT_WULTB ASSIGNING FIELD-SYMBOL(<FS_WULTB>).
READ TABLE T_MARC WITH KEY MATNR = <FS_WULTB>-MATNR
WERKS = <FS_WULTB>-WERKS BINARY SEARCH.
IF SY-SUBRC = 0.
ELSE.
CONTINUE.
ENDIF.
IF P_MAX = 'X'.
READ TABLE T_MAT WITH KEY MATNRINIT = <FS_MATAKT>-MATNRINIT
WERKSINIT = <FS_MATAKT>-WERKSINIT
MATNR = <FS_WULTB>-MATNR
WERKS = <FS_WULTB>-WERKS BINARY SEARCH.
ELSE.
READ TABLE T_MAT WITH KEY MATNR = <FS_WULTB>-MATNR
WERKS = <FS_WULTB>-WERKS.
ENDIF.
IF SY-SUBRC = 0.
CONTINUE.
ELSE.
MOVE-CORRESPONDING <FS_WULTB> TO T_MAT.
T_MAT-MATNRINIT = <FS_MATAKT>-MATNRINIT.
T_MAT-WERKSINIT = <FS_MATAKT>-WERKSINIT.
INSERT TABLE T_MAT.
ENDIF.
APPEND VALUE #( MATNRINIT = <FS_MATAKT>-MATNRINIT
WERKSINIT = <FS_MATAKT>-WERKSINIT
MATNRV = <FS_MATAKT>-MATNR
WERKSV = <FS_MATAKT>-WERKS
MATNR = <FS_WULTB>-MATNR
WERKS = <FS_WULTB>-WERKS ) TO T_MATNEW.

APPEND VALUE #( MATNRINIT = <FS_MATAKT>-MATNRINIT
WERKSINIT = <FS_MATAKT>-WERKSINIT
MATNRV = <FS_MATAKT>-MATNR
WERKSV = <FS_MATAKT>-WERKS
MATNR = <FS_WULTB>-MATNR
WERKS = <FS_WULTB>-WERKS
STUFE = V_STUFE ) TO T_MATALL.
* CLEAR <FS_WULTB>.
ENDLOOP.
ENDIF.
* CLEAR <FS_MATAKT>.
ENDLOOP.
ENDDO.

ENDFORM.
*&---------------------------------------------------------------------*
*& Form OUTPUT
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
* --> p1 text
* <-- p2 text
*----------------------------------------------------------------------*
FORM OUTPUT .

IF P_MITUM = 'X'.
PERFORM GET-UMSATZ.
ENDIF.

LOOP AT T_MAT ASSIGNING FIELD-SYMBOL(<FS_MAT>).


MOVE-CORRESPONDING <FS_MAT> TO WA_OUT.

* CLEAR <FS_MAKT>.
READ TABLE T_MAKT INTO <FS_MAKT> WITH KEY MATNR = <FS_MAT>-MATNR.
WA_OUT-MAKTX = <FS_MAKT>-MAKTX.

* CLEAR <FS_MBEW>.
READ TABLE T_MBEW INTO <FS_MBEW> WITH KEY MATNR = <FS_MAT>-MATNR
BWKEY = <FS_MAT>-WERKS.
WA_OUT-BKLAS = <FS_MBEW>-BKLAS.

IF P_MITUM = 'X'.
CLEAR <FS_ZMSLSTAT>.
READ TABLE T_ZMSLSTAT INTO <FS_ZMSLSTAT> WITH KEY MATNR = <FS_MAT>-MATNR
WERKS = <FS_MAT>-WERKS.
WA_OUT-UMGES = <FS_ZMSLSTAT>-UMGES.
ENDIF.

APPEND WA_OUT TO T_OUT.
CLEAR WA_OUT.
ENDLOOP.

PERFORM DISPLAY_ALV.
ENDFORM.
*&---------------------------------------------------------------------*
*& Form GET-PLANT
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
* --> p1 text
* <-- p2 text
*----------------------------------------------------------------------*
FORM GET-PLANT .
DO.
CLEAR: T_MATNEW[], T_MATAKT[].
V_STUFE1 = V_STUFE / 100.
V_STUFE1 = V_STUFE1 + 1.
V_STUFE = V_STUFE1 * 100.
LOOP AT T_MATALL INTO <FS_MATALL>.
IF <FS_MATALL>-TVW = 'X'.
CONTINUE.
ELSE.
MOVE-CORRESPONDING T_MATALL TO T_MATAKT.
APPEND T_MATAKT.
ENDIF.
<FS_MATALL>-TVW = 'X'.
MODIFY T_MATALL.
ENDLOOP.
* CLEAR <FS_MATALL>.

IF T_MATAKT[] IS INITIAL.
EXIT.
ENDIF.

SORT T_MATAKT BY MATNRINIT WERKSINIT MATNR WERKS.
DELETE ADJACENT DUPLICATES FROM T_MATAKT
COMPARING MATNRINIT WERKSINIT MATNR WERKS.

LOOP AT T_MATAKT INTO <FS_MATAKT>.
LOOP AT T_MARC INTO <FS_MARC> WHERE MATNR = <FS_MATAKT>-MATNR
AND WERKS <> <FS_MATAKT>-WERKS.
READ TABLE T_MAT WITH KEY MATNRINIT = <FS_MATAKT>-MATNRINIT
WERKSINIT = <FS_MATAKT>-WERKSINIT
MATNR = <FS_MARC>-MATNR
WERKS = <FS_MARC>-WERKS.
IF SY-SUBRC = 0.
CONTINUE.
ELSE.
MOVE-CORRESPONDING <FS_MARC> TO T_MAT.
T_MAT-MATNRINIT = <FS_MATAKT>-MATNRINIT.
T_MAT-WERKSINIT = <FS_MATAKT>-WERKSINIT.
INSERT TABLE T_MAT.
ENDIF.

APPEND VALUE #( MATNRINIT = <FS_MATAKT>-MATNRINIT
WERKSINIT = <FS_MATAKT>-WERKSINIT
MATNRWKINIT = <FS_MARC>-MATNR
WERKSWKINIT = <FS_MARC>-WERKS
MATNRV = <FS_MARC>-MATNR
WERKSV = <FS_MARC>-WERKS
MATNR = <FS_MARC>-MATNR
WERKS = <FS_MARC>-WERKS ) TO T_MATNEW.
ENDLOOP.
ENDLOOP.

LOOP AT T_MATNEW INTO <FS_MATNEW>.
MOVE-CORRESPONDING <FS_MATNEW> TO T_MATALL.
T_MATALL-STUFE = V_STUFE.
CLEAR: T_MATALL-MATNRV, T_MATALL-WERKSV.
T_MATALL-TVW = 'X'.
APPEND T_MATALL.
ENDLOOP.
CLEAR T_MATALL.

PERFORM TVW.

ENDDO.
ENDFORM.
*&---------------------------------------------------------------------*
*& Form GET-MAKT
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
* --> p1 text
* <-- p2 text
*----------------------------------------------------------------------*
FORM GET-MAKT .
DESCRIBE TABLE T_MAT LINES F_ANZ.
IF F_ANZ > 0.
SELECT MATNR SPRAS MAKTX
FROM MAKT
INTO TABLE T_MAKT
FOR ALL ENTRIES IN T_MAT
WHERE MATNR = T_MAT-MATNR
AND SPRAS = 'EN'.
ENDIF.
ENDFORM.
*&---------------------------------------------------------------------*
*& Form GET-MBEW
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
* --> p1 text
* <-- p2 text
*----------------------------------------------------------------------*
FORM GET-MBEW .
DESCRIBE TABLE T_MAT LINES F_ANZ.
IF F_ANZ > 0.
SELECT MATNR BWKEY BKLAS
FROM MBEW
INTO TABLE T_MBEW
FOR ALL ENTRIES IN T_MAT
WHERE MATNR = T_MAT-MATNR
AND BWKEY = T_MAT-WERKS
AND BWTAR = ' '.
ENDIF.
ENDFORM.
*&---------------------------------------------------------------------*
*& Form GET-UMSATZ
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
* --> p1 text
* <-- p2 text
*----------------------------------------------------------------------*
FORM GET-UMSATZ .
SELECT WERKS STWAE
FROM ZMSLWERK
INTO TABLE T_ZMSLWERK
WHERE STWAE <> 'EUR'.
IF T_MAT[] IS NOT INITIAL.
SELECT MATNR WERKS MONAT KUNUR MATUR VKORG
VTWEG URSAT UMGES
FROM ZMSLSTAT
INTO T_ZMSLSTAT2
FOR ALL ENTRIES IN T_MAT
WHERE MATNR = T_MAT-MATNR
AND WERKS = T_MAT-WERKS
AND MONAT IN S_MONAT.
IF <FS_ZMSLSTAT2>-URSAT = 'KO'
OR <FS_ZMSLSTAT2>-URSAT = 'KD'.
<FS_ZMSLSTAT2>-URSAT = 'KD'.
* collect T_ZMSLSTAT1.
APPEND <FS_ZMSLSTAT2> TO T_ZMSLSTAT2.
ENDIF.
ENDSELECT.
ENDIF.

LOOP AT T_ZMSLSTAT2 INTO <FS_ZMSLSTAT2>.
APPEND VALUE #( MATNR = <FS_ZMSLSTAT2>-MATNR
WERKS = <FS_ZMSLSTAT2>-WERKS
URSAT = <FS_ZMSLSTAT2>-URSAT
UMGES = <FS_ZMSLSTAT2>-UMGES ) TO T_ZMSLSTAT1.
ENDLOOP.

SORT T_ZMSLWERK BY WERKS STWAE.

LOOP AT T_ZMSLSTAT1 INTO <FS_ZMSLSTAT1>.

READ TABLE T_ZMSLWERK WITH KEY WERKS = <FS_ZMSLSTAT1>-WERKS BINARY SEARCH.
MOVE-CORRESPONDING <FS_ZMSLSTAT1> TO T_ZMSLSTAT.
IF T_ZMSLWERK-STWAE = 'JPY'.
<FS_ZMSLSTAT1>-UMGES = <FS_ZMSLSTAT1>-UMGES / 100.
ENDIF.
IF SY-SUBRC = 0.
CALL FUNCTION 'CONVERT_TO_LOCAL_CURRENCY'
EXPORTING
DATE = SY-DATUM
FOREIGN_AMOUNT = <FS_ZMSLSTAT1>-UMGES
FOREIGN_CURRENCY = T_ZMSLWERK-STWAE
LOCAL_CURRENCY = 'EUR'
READ_TCURR = 'X'
IMPORTING
LOCAL_AMOUNT = <FS_ZMSLSTAT>-UMGES.

IF SY-SUBRC <> 0.
WRITE: / 'Währung unbekannt',
<FS_ZMSLSTAT1>-MATNR,
T_ZMSLWERK-STWAE.
ENDIF.
ENDIF.
APPEND T_ZMSLSTAT.
ENDLOOP.
ENDFORM.
*&---------------------------------------------------------------------*
*& Form DISPLAY_ALV
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
* --> p1 text
* <-- p2 text
*----------------------------------------------------------------------*
FORM DISPLAY_ALV .
DATA: LREF_COLUMNS TYPE REF TO CL_SALV_COLUMNS_TABLE, "#EC NEEDED
LREF_COLUMN TYPE REF TO CL_SALV_COLUMN, "#EC NEEDED
LREF_ALV TYPE REF TO CL_SALV_TABLE,
LREF_FUNCT TYPE REF TO CL_SALV_FUNCTIONS.

DATA: LV_MSG TYPE STRING, "#EC NEEDED
LREF_SALV_NOT_FOUND TYPE REF TO CX_SALV_NOT_FOUND.

TRY.
CALL METHOD CL_SALV_TABLE=>FACTORY
IMPORTING
R_SALV_TABLE = LREF_ALV
CHANGING
T_TABLE = T_OUT.

CATCH CX_SALV_MSG .
ENDTRY.
LREF_COLUMNS = LREF_ALV->GET_COLUMNS( ).

TRY.
LREF_COLUMN = LREF_COLUMNS->GET_COLUMN( 'MATNR' ).
LREF_COLUMN->SET_LONG_TEXT( TEXT-001 ).
CATCH CX_SALV_NOT_FOUND INTO LREF_SALV_NOT_FOUND.
LV_MSG = LREF_SALV_NOT_FOUND->GET_TEXT( ).
MESSAGE LV_MSG TYPE CO_E.
ENDTRY.

TRY.
LREF_COLUMN = LREF_COLUMNS->GET_COLUMN( 'UMGES' ).
LREF_COLUMN->SET_LONG_TEXT( TEXT-002 ).
CATCH CX_SALV_NOT_FOUND INTO LREF_SALV_NOT_FOUND.
LV_MSG = LREF_SALV_NOT_FOUND->GET_TEXT( ).
MESSAGE LV_MSG TYPE CO_E.
ENDTRY.

LREF_FUNCT = LREF_ALV->GET_FUNCTIONS( ).
LREF_FUNCT->SET_ALL( ABAP_TRUE ).
LREF_ALV->DISPLAY( ).

ENDFORM.

[raymond_giuseppi]

Please use the code option to get a more readable source code.

Before that

• Perform a performance analysis to identify the source of the problem, then paste only the relevant part of the code.
• Try reducing the FOR ALL ENTRIES, optimize the remaining loop with sorted tables, etc.
• Specify where you are stuck, what you have already tried, etc.

[matt]

Edit your question and this time use the CODE button in the editor, so the code is readable.

[Sandra_Rossi]

Performance issues are never troubleshooted by reading ABAP code, they require to run SAT (ABAP runtime analysis).

[VXLozano]

After use the CODE button as has been suggested to you, maybe you can put some effort in the question itself. You are plainly asking us to do your work.

You should: search the net to find ways to detect bottlenecks, check those bottlenecks in your code, solve those bottlenecks.

Once you'll have those, if you cannot find (search again) how to fix them, then it will be fine to ask for help. Properly, like:

"hey people, I'm having problems trying to improve the performance in this piece of code

insert your code here, using the CODE button

"can you, please, provide me some hints to do that? I searched for A, B, C, and tried X, Y, Z, and it's still slow.

"thanks in advance