SAP小技巧 双LOOP循环的性能优化

*&---------------------------------------------------------------------*
*& Report ZTS_INTERAL_TABLE_PROC
*&---------------------------------------------------------------------*
*&内表LT_A 字段 F1 关联内表LT_B 字段 F1. 内容联合放入内表 LT_C
*其中LT_A中F1字段按选择条件只出现一次或出现多次.
* LT_B中F1内容2次重复
*&---------------------------------------------------------------------*
REPORT zts_interal_table_proc.
PARAMETERS: p_int TYPE i DEFAULT 1000.
PARAMETERS: p_dup_a AS CHECKBOX.

INITIALIZATION.
  %_p_int_%_app_%-text = '内表条数'.
  %_p_dup_a_%_app_%-text = '内表A数据重复'.
  TYPES:BEGIN OF ty_a,
          f1(10),
          f2(10),
        END OF ty_a.
  TYPES: ty_a_tab TYPE TABLE OF ty_a.
  DATA: lt_a TYPE TABLE OF ty_a.

  TYPES:BEGIN OF ty_b,
          f1(10),
          f3(10),
        END OF ty_b.
  TYPES: ty_b_tab TYPE TABLE OF ty_b.
  DATA: lt_b TYPE TABLE OF ty_b.



  TYPES:BEGIN OF ty_c,
          f1(10),
          f2(10),
          f3(10),
        END OF ty_c.
  TYPES: ty_c_tab TYPE TABLE OF ty_c.
  DATA: lt_c TYPE TABLE OF ty_c.

START-OF-SELECTION.

*构造内表数据
  PERFORM frm_get_a_b CHANGING lt_a lt_b.
*标准表方式
  IF p_int <= 10000.
    REFRESH lt_c.
    PERFORM proc_standard_tab.
  ENDIF.
*排序表方式
  REFRESH lt_c.
  PERFORM proc_sort_tab.
  REFRESH lt_c.
*构造嵌套哈希表方式- group 构造
  PERFORM proc_hashed_tab.
*构造嵌套哈希表方法- at new 构造
  REFRESH lt_c.
  PERFORM proc_hashed_tab_2.
*按性能帮助中的方法
  REFRESH lt_c.
  PERFORM proc_standard_tab_2.
*二分法查找, 再读取.
  REFRESH lt_c.
  PERFORM proc_sort_tab_2.

*&---------------------------------------------------------------------*
*& Form FRM_GET_A
*&---------------------------------------------------------------------*
*& text
*&---------------------------------------------------------------------*
*&      --> LT_A
*&---------------------------------------------------------------------*
FORM frm_get_a_b  CHANGING ct_a TYPE ty_a_tab
                           ct_b TYPE ty_b_tab.
  DATA: lw_a TYPE ty_a.
  DATA: lw_b TYPE ty_b.
  DATA: lv_numc(9) TYPE n.
  DO p_int TIMES.
    lv_numc = sy-index.
    CLEAR lw_a.
    lw_a-f1 = 'A' && lv_numc.
    lw_a-f2 = 'B' && lv_numc.
    APPEND lw_a TO ct_a.
    IF p_dup_a = 'X'.
      APPEND lw_a TO ct_a.
    ENDIF.
    lw_b-f1 = lw_a-f1.
    lw_b-f3 = 'C' && lv_numc.
    APPEND lw_b TO lt_b.
    lw_b-f1 = lw_a-f1.
    lw_b-f3 = 'D' && lv_numc.
    APPEND lw_b TO lt_b.
  ENDDO.
ENDFORM.
*&---------------------------------------------------------------------*
*& Form PROC_SORT_TAB
*&---------------------------------------------------------------------*
*& text
*&---------------------------------------------------------------------*
*& -->  p1        text
*& <--  p2        text
*&---------------------------------------------------------------------*
FORM proc_sort_tab .
  DATA: lw_a TYPE ty_a.
  DATA: lw_b TYPE ty_b,
        lw_c TYPE ty_c.
  DATA: lt_b_sort TYPE SORTED TABLE OF ty_b WITH NON-UNIQUE KEY f1.
  GET RUN TIME FIELD DATA(t1).
  SORT lt_b BY f1.
  lt_b_sort[] = lt_b[].
  GET RUN TIME FIELD DATA(t2).
  LOOP AT lt_a INTO lw_a.
    LOOP AT lt_b_sort INTO lw_b WHERE f1 = lw_a-f1 .
      CLEAR lw_c.
      lw_c-f1 = lw_a-f1.
      lw_c-f2 = lw_a-f2.
      lw_c-f3 = lw_b-f3.
      APPEND lw_c TO lt_c.
    ENDLOOP.
  ENDLOOP.
  GET RUN TIME FIELD DATA(t3).
  DATA: lv_lines TYPE i.
  lv_lines = lines( lt_c ).
  DATA: lv_micro  TYPE i,
        lv_micro2 TYPE i,
        lv_micro3 TYPE i.
  lv_micro = t3 - t1.
  lv_micro2 = t2 - t1.
  lv_micro3 = t3 - t2.
  WRITE:/(20)'排序表:        ',lv_lines ,'总时间:', lv_micro,'微秒','构造表时间:', lv_micro2,'执行时间:', lv_micro3.
ENDFORM.

FORM proc_sort_tab_2 .
  DATA: lw_a TYPE ty_a.
  DATA: lw_b TYPE ty_b,
        lw_c TYPE ty_c.
  DATA: lt_b_sort TYPE SORTED TABLE OF ty_b WITH NON-UNIQUE KEY f1.
  GET RUN TIME FIELD DATA(t1).
  SORT lt_b BY f1.

  GET RUN TIME FIELD DATA(t2).
  LOOP AT lt_a INTO lw_a.
    READ TABLE lt_b TRANSPORTING NO FIELDS WITH KEY f1 = lw_a-f1 BINARY SEARCH.
    IF sy-subrc = 0.
      LOOP AT lt_b INTO lw_b FROM sy-tabix.
        IF lw_b-f1 <> lw_a-f1.
          EXIT.
        ENDIF.
        CLEAR lw_c.
        lw_c-f1 = lw_a-f1.
        lw_c-f2 = lw_a-f2.
        lw_c-f3 = lw_b-f3.
        APPEND lw_c TO lt_c.
      ENDLOOP.
    ENDIF.
  ENDLOOP.
  GET RUN TIME FIELD DATA(t3).
  DATA: lv_lines TYPE i.
  lv_lines = lines( lt_c ).
  DATA: lv_micro  TYPE i,
        lv_micro2 TYPE i,
        lv_micro3 TYPE i.
  lv_micro = t3 - t1.
  lv_micro2 = t2 - t1.
  lv_micro3 = t3 - t2.
  WRITE:/(20)'二分查找优化循环: ',lv_lines ,'总时间:', lv_micro,'微秒','构造表时间:', lv_micro2,'执行时间:', lv_micro3.
ENDFORM.
*&---------------------------------------------------------------------*
*& Form PROC_HASHED_TAB
*&---------------------------------------------------------------------*
*& text
*&---------------------------------------------------------------------*
*& -->  p1        text
*& <--  p2        text
*&---------------------------------------------------------------------*
FORM proc_hashed_tab .
  DATA: lw_a TYPE ty_a.
  DATA: lw_b TYPE ty_b,
        lw_c TYPE ty_c.
  DATA: BEGIN OF lw_b_h,
          f1(10),
          items  TYPE ty_b_tab,
        END OF lw_b_h.
  DATA: lw_items TYPE ty_b.
  DATA: lt_b_h LIKE HASHED TABLE OF lw_b_h WITH UNIQUE KEY f1.
  GET RUN TIME FIELD DATA(t1).
  LOOP AT lt_b INTO DATA(lw_gp) GROUP BY ( f1 = lw_gp-f1 ).
    CLEAR lw_b_h.
    lw_b_h-f1 = lw_gp-f1.
    LOOP AT GROUP lw_gp INTO lw_b.
      APPEND lw_b TO lw_b_h-items.
    ENDLOOP.
    INSERT lw_b_h INTO TABLE lt_b_h.
  ENDLOOP.

  GET RUN TIME FIELD DATA(t2).
  LOOP AT lt_a INTO lw_a.
    READ TABLE lt_b_h INTO lw_b_h WITH TABLE KEY f1 = lw_a-f1.
    LOOP AT lw_b_h-items INTO lw_items.
      CLEAR lw_c.
      lw_c-f1 = lw_a-f1.
      lw_c-f2 = lw_a-f2.
      lw_c-f3 = lw_items-f3.
      APPEND lw_c TO lt_c.
    ENDLOOP.
  ENDLOOP.

  GET RUN TIME FIELD DATA(t3).
  DATA: lv_lines TYPE i.
  lv_lines = lines( lt_c ).
  DATA: lv_micro  TYPE i,
        lv_micro2 TYPE i,
        lv_micro3 TYPE i.
  lv_micro = t3 - t1.
  lv_micro2 = t2 - t1.
  lv_micro3 = t3 - t2.
  WRITE:/(20)'哈希表-GROUP构造:',lv_lines ,'总时间:', lv_micro,'微秒','构造表时间:', lv_micro2,'执行时间:', lv_micro3.
ENDFORM.
*&---------------------------------------------------------------------*
*& Form PROC_STANDARD_TAB
*&---------------------------------------------------------------------*
*& text
*&---------------------------------------------------------------------*
*& -->  p1        text
*& <--  p2        text
*&---------------------------------------------------------------------*
FORM proc_standard_tab .
  DATA: lw_a TYPE ty_a.
  DATA: lw_b TYPE ty_b,
        lw_c TYPE ty_c.
  GET RUN TIME FIELD DATA(t1).
  LOOP AT lt_a INTO lw_a.
    LOOP AT lt_b INTO lw_b WHERE f1 = lw_a-f1.
      CLEAR lw_c.
      lw_c-f1 = lw_a-f1.
      lw_c-f2 = lw_a-f2.
      lw_c-f3 = lw_b-f3.
      APPEND lw_c TO lt_c.
    ENDLOOP.
  ENDLOOP.
  GET RUN TIME FIELD DATA(t2).
  DATA: lv_lines TYPE i.
  lv_lines = lines( lt_c ).
  DATA: lv_micro TYPE i.
  lv_micro = t2 - t1.
  WRITE:/(20)'标准表:        ',lv_lines ,'总时间:',lv_micro,'微秒'.
ENDFORM.

FORM proc_standard_tab_2 .
  DATA: lw_a TYPE ty_a.
  DATA: lw_b TYPE ty_b,
        lw_c TYPE ty_c.
  GET RUN TIME FIELD DATA(t1).
  SORT lt_a BY f1.
  SORT lt_b BY f1.

  GET RUN TIME FIELD DATA(t2).
  DATA: i TYPE i.
  i = 1.
  LOOP AT lt_a INTO lw_a.
    LOOP AT lt_b INTO lw_b FROM i.
      IF lw_b-f1 <> lw_a-f1.
        i = sy-tabix.
        EXIT.
      ENDIF.
      lw_c-f1 = lw_a-f1.
      lw_c-f2 = lw_a-f2.
      lw_c-f3 = lw_b-f3.
      APPEND lw_c TO lt_c.
    ENDLOOP.
  ENDLOOP.
  GET RUN TIME FIELD DATA(t3).
  DATA: lv_lines TYPE i.
  lv_lines = lines( lt_c ).
  DATA: lv_micro  TYPE i,
        lv_micro2 TYPE i,
        lv_micro3 TYPE i.
  lv_micro = t3 - t1.
  lv_micro2 = t2 - t1.
  lv_micro3 = t3 - t2.
  WRITE:/(20)'按index优化:',lv_lines ,'总时间:', lv_micro,'微秒','构造表时间:', lv_micro2,'执行时间:', lv_micro3..
ENDFORM.


FORM proc_hashed_tab_2.
  DATA: lw_a TYPE ty_a.
  DATA: lw_b TYPE ty_b,
        lw_c TYPE ty_c.
  DATA: BEGIN OF lw_b_h,
          f1(10),
          items  TYPE ty_b_tab,
        END OF lw_b_h.
  DATA: lw_items TYPE ty_b.
  DATA: lt_b_h LIKE HASHED TABLE OF lw_b_h WITH UNIQUE KEY f1.
  GET RUN TIME FIELD DATA(t1).
  SORT lt_b BY f1.
  LOOP AT lt_b INTO lw_b.
    AT NEW f1.
      CLEAR lw_b_h.
      lw_b_h-f1 = lw_b-f1.
    ENDAT.
    APPEND lw_b TO lw_b_h-items.
    AT END OF f1.
      INSERT lw_b_h INTO TABLE lt_b_h.
    ENDAT.
  ENDLOOP.
  GET RUN TIME FIELD DATA(t2).
  LOOP AT lt_a INTO lw_a.
    READ TABLE lt_b_h INTO lw_b_h WITH TABLE KEY f1 = lw_a-f1.
    LOOP AT lw_b_h-items INTO lw_items.
      CLEAR lw_c.
      lw_c-f1 = lw_a-f1.
      lw_c-f2 = lw_a-f2.
      lw_c-f3 = lw_items-f3.
      APPEND lw_c TO lt_c.
    ENDLOOP.
  ENDLOOP.

  GET RUN TIME FIELD DATA(t3).
  DATA: lv_lines TYPE i.
  lv_lines = lines( lt_c ).
  DATA: lv_micro  TYPE i,
        lv_micro2 TYPE i,
        lv_micro3 TYPE i.
  lv_micro = t3 - t1.
  lv_micro2 = t2 - t1.
  lv_micro3 = t3 - t2.
  WRITE:/(20)'哈希表-AT NEW构造:',lv_lines ,'总时间:', lv_micro,'微秒','构造表时间:', lv_micro2,'执行时间:', lv_micro3..
ENDFORM.