ABAP性能实例七例
一、SQL Interface
1.Select ... Where vs. Select + Check
用Select … Where語句效率比Select + Check語句要高，例如：
SELECT * FROM SBOOK INTO SBOOK_WA
WHERE CARRID = 'LH' AND
CONNID = '0400'.
ENDSELECT.
SELECT * FROM SBOOK INTO SBOOK_WA.
CHECK: SBOOK_WA-CARRID = 'LH' AND
SBOOK_WA-CONNID = '0400'.
ENDSELECT.
2.Test Existence
檢查滿足某個（些）條件的記錄是否存在時，使用Select Single效率最高；例如：
SELECT SINGLE * FROM SBOOK
WHERE CARRID = 'LH'.
SELECT * FROM SBOOK INTO SBOOK_WA
WHERE CARRID = 'LH'.
EXIT.
ENDSELECT.
3.Select aggregates
需要對數據庫某列求最大，最小，和，平均值或者記錄數量時，請使用聚集函數來代替Select … Where + Check的方法，這樣效率高而且網絡流量小。
DATA: MAX_MSGNR type t100-msgnr.
SELECT MAX( MSGNR ) FROM T100 INTO max_msgnr
WHERE SPRSL = 'D' AND
ARBGB = '00'.
4.Select with select list
取數時請使用Select + 指定的列名稱 into，而不要使用Select * into。顯示的指定列名稱只取出需要的列，不會像Select *會取出相應表的所有的列。
SELECT DOMNAME FROM DD01L
INTO DD01L_WA-DOMNAME
WHERE DOMNAME LIKE 'CHAR%'
AND AS4LOCAL = 'A'.
ENDSELECT.
SELECT * FROM DD01L INTO DD01L_WA
WHERE DOMNAME LIKE 'CHAR%'
AND AS4LOCAL = 'A'.
ENDSELECT.
5.Column Update
盡可能的使用字段（column updates）更新來代替行記錄（single-row updates）更新數據庫表，這樣可以減少網絡負載。
UPDATE SFLIGHT
SET SEATSOCC = SEATSOCC - 1.
6.Index and Buffer Support
6.1.Select with index support
Select語句在Where條件中盡量使用索引字段
6.2.Select with buffer support
對于最常用的只讀的數據讀取，使用SAP Buffering，不要使用BYPASSING BUFFER，例如：
SELECT SINGLE * FROM T100 INTO T100_WA
BYPASSING BUFFER
WHERE SPRSL = 'D'
AND ARBGB = '00'
AND MSGNR = '999'.
7.Array Operations (internal tables)
7.1.Select ... Into Table t
使用Into Table版本的Select 語句要比使用 Append 的方式速度更快，例如：
SELECT * FROM T006 INTO TABLE X006.
DATA T006_WA TYPE T006.
CLEAR X006.
SELECT * FROM T006 INTO T006_WA.
APPEND T006_WA TO X006.
ENDSELECT.
7.2.Array Insert VS Single-row Insert
向數據庫中插入數據時，使用內表代替單行操作，減少應用服務與數據庫的交互次數，能夠有效地減少系統負荷。
INSERT CUSTOMERS FROM TABLE TAB.
LOOP AT TAB INTO TAB_WA.
INSERT INTO CUSTOMERS VALUES TAB_WA.
ENDLOOP.
7.3.Select-Endselect vs. Array-Select
對于只需要使用一次的數據，使用Select-Endselect-loop來代替Select Into Table。內表需要更多的內存空間。例如：
SELECT * FROM T006 INTO X006_WA.
ENDSELECT.
SELECT * FROM T006
INTO TABLE X006.
LOOP AT X006 INTO X006_WA.
ENDLOOP.
注：個人認為還是取出數據到內表的方式要好，犧牲存儲空間，換取時間上的性能。
二、Context
1.Supply/Demand vs. SELECT
三、Internal Tables
1. Using explicit work areas（顯示的使用工作區）
顯示的指定工作區可以避免不必要的Move操作。見下列內表操作的語句：
APPEND wa TO itab. INSERT wa INTO itab. COLLECT wa INTO itab. MODIFY itab FROM wa. READ TABLE itab INTO wa. LOOP AT itab INTO wa.
ITAB = WA.
APPEND ITAB.
2.Linear search vs. binary search
如果內表的數據超過20條，由于線性檢索會遍歷整個內表，這將會非常耗時。將內表排序并使用Binary Search，或者使用SORTED TABLE類型的內表。如果內表有n條記錄，線性查找的次數為O( n )，Binary Search的查找次數為O( log2( n ) ).
READ TABLE ITAB INTO WA WITH KEY K = 'X'
BINARY SEARCH.
?
READ TABLE ITAB INTO WA
WITH KEY K = 'X'.
3.Dynamic vs. static key access
動態鍵值的讀取比靜態鍵值的讀取要慢，
READ TABLE ITAB INTO WA
WITH KEY K = 'X'.
READ TABLE ITAB INTO WA
WITH KEY (NAME) = 'X'.
4.Secondary indices
If you need to access an internal table with different keys repeatedly, keep your own secondary indices. With a secondary index, you can replace a linear search with a binary search plus an index access.
READ TABLE SEC_IDX INTO SEC_IDX_WA
WITH KEY DATE = SY-DATUM
BINARY SEARCH.
IF SY-SUBRC = 0.
READ TABLE ITAB INTO WA
INDEX SEC_IDX_WA-INDX.
" ...
ENDIF.
READ TABLE ITAB INTO WA
WITH KEY DATE = SY-DATUM.
IF SY-SUBRC = 0.
" ...
ENDIF.
5.Key access to multiple lines
LOOP ... WHERE比 LOOP/CHECK更快，因為LOOP ... WHERE只處理滿足特定條件的數據。如果LOOP ... WHERE和FROM i1 and/or TO i2條件一起使用，性能會更好。
LOOP AT ITAB INTO WA WHERE K = 'X'.
" ...
ENDLOOP.
LOOP AT ITAB INTO WA.
CHECK WA-K = 'X'.
" ...
ENDLOOP.
6.Sorted and Hashed Tables
6.1.Single Read: Sorted vs. hashed tables
數據在SORTED TABLE類型的內表中按照Binary Search方式組織，檢索數據的時間維度為(O (log n))。
數據在HASDED TABLE類型內表中按照hash-algorithm組織，檢索數據的時間維度為(O (1))。
HASHED TABLE為單條記錄的存取進行了優化，它沒有索引(index)，而SORTED TABLE優化為loop操作的部分順序數據的存取。
DO 250 TIMES.
N = 4 * SY-INDEX.
READ TABLE HTAB INTO WA WITH TABLE KEY K = N.
IF SY-SUBRC = 0.
" ...
ENDIF.
ENDDO.
DO 250 TIMES.
N = 4 * SY-INDEX.
READ TABLE STAB INTO WA WITH KEY K = N.
IF SY-SUBRC = 0.
" ...
ENDIF.
ENDDO.
注：根據實測，Hashed Table的Read Table操作比Sorted Table + Binary Search大約快1倍。
6.2.Part. seq. access: Hashed vs. sorted
Hashed tables優化為單條記錄的存取，數據在內表中沒有特定的順序，內表沒有索引（sy-tabix）,而且它必須是UNIQUE KEY。
SORTED TABLE內表中數據按照Key字段升序排序。
LOOP AT STAB INTO WA WHERE K = SUBKEY.
" ...
ENDLOOP.
LOOP AT HTAB INTO WA WHERE K = SUBKEY.
" ...
ENDLOOP.
7.Building unique standard tables(如何建立有唯一主鍵的標準內表)
如果內表的記錄數量較少（<20），或者在填充內表的同時你需要訪問它，那么使用Read/Insert比較合適。但是，如果你內表數據量很大，并且你只需要讀取已經填充的內表，那么使用后面三步法。
REFRESH ITAB2.
LOOP AT ITAB1 INTO WA.
READ TABLE ITAB2 WITH KEY K = WA-K
BINARY SEARCH
TRANSPORTING NO FIELDS.
IF SY-SUBRC <> 0.
INSERT WA INTO ITAB2
INDEX SY-TABIX.
ENDIF.
ENDLOOP.
ITAB2[] = ITAB1[].
SORT ITAB2 BY K.
DELETE ADJACENT DUPLICATES FROM ITAB2
COMPARING K.
?
8.Building unique sorted/hashed tables
9.Modifying single lines
使用"MODIFY itab ... TRANSPORTING f1 f2 ..."語句更新一個內表的行可以提高效率，內表的table line越長，那么效率提高越多。該語句對于擁有復雜行類型的內表效率提升最明顯。
WA-DATE = SY-DATUM.
MODIFY ITAB FROM WA INDEX 1.
WA-DATE = SY-DATUM.
MODIFY ITAB FROM WA INDEX 1 TRANSPORTING DATE.
10.Using the Assigning Comand
10.1.Modifying a set of lines directly（批量修改內表數據）
使用"LOOP ... ASSIGNING ..."可以直接修改內表中的數據，而不需要先將內表數據復制到相應工作區，然后再更新回去。
LOOP AT ITAB INTO WA.
I = SY-TABIX MOD 2.
IF I = 0.
WA-FLAG = 'X'.
MODIFY ITAB FROM WA.
ENDIF.
ENDLOOP.
?
Field-Symboles:<WA> like ITAB.
LOOP AT ITAB ASSIGNING <WA>.
I = SY-TABIX MOD 2.
IF I = 0.
<WA>-FLAG = 'X'.
ENDIF.
ENDLOOP.
10.2.Filling nested internal tables（填充嵌套的內表）
采用自底向上的策略填充嵌套內表，需要多付出很多次move操作的時間，嵌套中內部inner內表的內容會被moved到上一層的數據結構中。
相反，采用自頂向下的策略，首先填充外部outer內表，再采用"LOOP ... ASSIGNING"可以直接更新內部內表，這樣，inner tables的內容只會被移動一次。
DO 50 TIMES.
CLEAR WA.
DO 10 TIMES.
APPEND N TO WA-INTTAB.
ADD 1 TO N.
ENDDO.
APPEND WA TO ITAB.
ENDDO.
DO 50 TIMES.
APPEND INITIAL LINE TO ITAB.
ENDDO.
LOOP AT ITAB ASSIGNING <F>.
DO 10 TIMES.
APPEND N TO <F>-INTTAB.
ADD 1 TO N.
ENDDO.
ENDLOOP.
11.Building condensed tables
COLLECT使用一種HASH算法，因此它不依賴內表的記錄數而且不需要維護表索引sy-tabix，如果你需要最終的內表是排序的，那么在所有數據都Collect完以后再排序內表。
如果內表的記錄數量較少，可以使用READ/INSERT的方法，也可以取得較好的效率，但是如果數據量大于1000，那么還是使用Collect效率更好些。
注意：在使用Collect填充一個內表時，不要混合使用其他操作內表的語句，例如 (APPEND, INSERT, MODIFY, SELECT * INTO TABLE and/or SELECT * APPENDING TABLE)。如果你將Collect與這些語句混合使用操作操作內表，那么Collect就不會使用HASH算法，在這種情況下，COLLECT會重新排序為一個普通的線性搜索，性能會顯著的降低為O(n).
LOOP AT ITAB1 INTO WA1.
READ TABLE ITAB2 INTO WA2 WITH KEY K = WA1-K BINARY SEARCH.
IF SY-SUBRC = 0.
ADD: WA1-VAL1 TO WA2-VAL1,
WA1-VAL2 TO WA2-VAL2.
MODIFY ITAB2 FROM WA2 INDEX SY-TABIX TRANSPORTING VAL1 VAL2.
ELSE.
INSERT WA1 INTO ITAB2 INDEX SY-TABIX.
ENDIF.
ENDLOOP.
?
LOOP AT ITAB1 INTO WA.
COLLECT WA INTO ITAB2.
ENDLOOP.
SORT ITAB2 BY K.
12. Array Operations
12.1. Appending tables
使用"APPEND LINES OF itab1 TO itab2" 將itab1的所有行添加到內表itab2。
LOOP AT ITAB1 INTO WA.
APPEND WA TO ITAB2.
ENDLOOP.
APPEND LINES OF ITAB1 TO ITAB2.
12.2.Inserting tables
使用"INSERT LINES OF itab1 INTO itab2 INDEX idx" 語句將內表itab1從內表itab2的索引idx處插入。 I = 250.
LOOP AT ITAB1 INTO WA.
INSERT WA INTO ITAB2 INDEX I.
ADD 1 TO I.
ENDLOOP.
I = 250.
INSERT LINES OF ITAB1 INTO ITAB2
INDEX I.
12.3.Deleting duplicates（刪除內表中重復的記錄）
使用 "DELETE ADJACENT DUPLICATES" 語句刪除重復記錄。
READ TABLE ITAB INDEX 1 INTO PREV_LINE.
LOOP AT ITAB FROM 2 INTO WA.
IF WA = PREV_LINE.
DELETE ITAB.
ELSE.
PREV_LINE = WA.
ENDIF.
ENDLOOP.
DELETE ADJACENT DUPLICATES FROM ITAB
COMPARING K.
12.4.Deleting a sequence of lines（刪除內表中連續的數據）
使用 "DELETE itab FROM ... TO ..." 刪除一批連續數據。
DO 101 TIMES.
DELETE ITAB INDEX 450.
ENDDO.
DELETE ITAB FROM 450 TO 550.
12.5.Copying internal tables（內表復制）
內表可以像其他對象一樣，使用MOVE語句進行內表的復制。
如果內表有Header Line，那么使用itab[]存取內表。
REFRESH ITAB2.
LOOP AT ITAB1 INTO WA.
APPEND WA TO ITAB2.
ENDLOOP.
ITAB2[] = ITAB1[].
12.6.Comparing internal tables（內表比較）
內表可以像其他對象一樣在邏輯表達式中進行比較，如果兩個內表相同，那么它們：
- 有相同的行記錄數量
- 每對相應的行相同
如果內表有Header Line，那么可以使用itab[]方式訪問內表本身。
DESCRIBE TABLE: ITAB1 LINES L1,
ITAB2 LINES L2.
IF L1 <> L2.
TAB_DIFFERENT = 'X'.
ELSE.
TAB_DIFFERENT = SPACE.
LOOP AT ITAB1 INTO WA1.
READ TABLE ITAB2 INTO WA2 INDEX SY-TABIX.
IF WA1 <> WA2.
TAB_DIFFERENT = 'X'. EXIT.
ENDIF.
ENDLOOP.
ENDIF.
IF TAB_DIFFERENT = SPACE.
" ...
ENDIF.
IF ITAB1[] = ITAB2[].
" ...
ENDIF.
13.Sorting internal tables
內表中指定的排序鍵限制越嚴格，程序運行得就越快。所以，盡可能的指定約束越多的排序鍵值。
SORT ITAB.
SORT ITAB BY K.
14.Simple Algorithms
14.1.Joining internal tables（內表連接Join）
如果ITAB1有n1條記錄，ITAB2有n2條記錄, 那么straightforward算法連接ITAB1和ITAB2需要O( n1 * log2( n2 ) )次運算，而parallel cursor approach僅需要O( n1 + n2 ) 次運算。 parallel cursor算法假定ITAB2為從表且只包含在主表ITAB1中才有的記錄. If this assumption does not hold, the parallel cursor algorithm gets slightly more complicated, but its performance characteristics remain the same.
LOOP AT ITAB1 INTO WA1.
READ TABLE ITAB2 INTO WA2
WITH KEY K = WA1-K BINARY SEARCH.
IF SY-SUBRC = 0.
" ...
ENDIF.
ENDLOOP.
<Naive join>
?
DATA: I TYPE I.
I = 1.
LOOP AT ITAB1 INTO WA1.
READ TABLE ITAB2 INTO WA2 INDEX I.
IF SY-SUBRC <> 0. EXIT. ENDIF.
IF WA2-K = WA1-K.
" ...
ENDIF.
ENDLOOP.
注：經過本人測試，這段程序是錯誤的，不能成立，不知道正確的應該如何。
<More sophisticated: use parallel cursors>
14.2.Nested loops
如果ITAB1有n1條記錄，ITAB2有n2條記錄,那么嵌套loop的straightforward算法需要的時間為O(n1 * n2),而parallel cursor approach 需要的時間是O(n1 + n2).
parallel cursor算法假定 ITAB2僅包含ITAB1才有的記錄。如果假定不成立， parallel cursor算法顯得比較復雜，但是性能特性卻保持不變。
LOOP AT ITAB1 INTO WA1.
LOOP AT ITAB2 INTO WA2
WHERE K = WA1-K.
" ...
ENDLOOP.
ENDLOOP.
<Straightforward nested loop>
I = 1.
LOOP AT ITAB1 INTO WA1.
LOOP AT ITAB2 INTO WA2 FROM I.
IF WA2-K <> WA1-K.
I = SY-TABIX.
EXIT.
ENDIF.
" ...
ENDLOOP.
ENDLOOP.
< More sophisticated loop: parallel cursors >
14.3.Intersection of internal tables
數據源表 ITAB1 和ITAB2都是STANDARD TABLES，假定ITAB1比ITAB2包含更多的記錄。 否則，需要使用 "DESCRIBE TABLE ... LINES ..."語句計算內表包含的記錄數。假定2個內表中的記錄都遵從主鍵K唯一。
算法在計算中需要使用一個有唯一主鍵K的臨時內表,該內表是ITAB1數據的復制，匹配的數據被復制到ITAB3,以下兩個示例的區別在于臨時內表分別為SORTED TABLE和HASHED TABLE，對于LOOP中的READ語句，HASHED TABLE比SORTED TABLE更快。
STAB1 = ITAB1.REFRESH ITAB3.
LOOP AT ITAB2 ASSIGNING <WA>.
READ TABLE STAB1 FROM <WA>
TRANSPORTING NO FIELDS.
IF SY-SUBRC = 0.
APPEND <WA> TO ITAB3.
ENDIF.
ENDLOOP.
FREE STAB1.
<Using a sorted table temporarily >
HTAB1 = ITAB1.
REFRESH ITAB3.
LOOP AT ITAB2 ASSIGNING <WA>.
READ TABLE HTAB1 FROM <WA>
TRANSPORTING NO FIELDS.
IF SY-SUBRC = 0.
APPEND <WA> TO ITAB3.
ENDIF.
ENDLOOP.
FREE HTAB1.
<Using a hashed table temporarily>
四、Typing
1.Typed vs. untyped Parameters<類型化與非類型化參數>
如果你在源程序中指定了參數的類型，那么ABAP/4編譯器能夠徹底的對代碼進行優化。另外，使用錯誤順序參數的風險更少。
PERFORM UP1 USING 10 M6-DIMID M6-ZAEHL M6-ISOCODE M6-ANDEC M6-PRIMARY.FORM UP1 USING
REPEAT
DIMID
ZAEHL
ISOCODE
ANDEC
PRIMARY.
* Identical source code left and right:
DO REPEAT TIMES.
T006_WA-DIMID = DIMID.
T006_WA-ZAEHL = ZAEHL.
T006_WA-ISOCODE = ISOCODE.
T006_WA-ANDEC = ANDEC.
T006_WA-PRIMARY = PRIMARY.
ENDDO.
ENDFORM.
PERFORM UP2 USING 10 M6-DIMID M6-ZAEHL M6-ISOCODE M6-ANDEC M6-PRIMARY.
FORM UP2 USING
REPEAT TYPE I
DIMID LIKE T006-DIMID
ZAEHL LIKE T006-ZAEHL
ISOCODE LIKE T006-ISOCODE
ANDEC LIKE T006-ANDEC
PRIMARY LIKE T006-PRIMARY.
* Identical source code left and right:
DO REPEAT TIMES.
T006_WA-DIMID = DIMID.
T006_WA-ZAEHL = ZAEHL.
T006_WA-ISOCODE = ISOCODE.
T006_WA-ANDEC = ANDEC.
T006_WA-PRIMARY = PRIMARY.
ENDDO.
ENDFORM.
2.Typed vs untyped Field-Symbols
如果你在源程序中指定了類型化的field-symbols，那么ABAP/4編譯器能夠更好的對代碼進行優化
FIELD-SYMBOLS: <F> TYPE ANY.DATA: I1 TYPE I, I2 TYPE I.
ASSIGN I1 TO <F>.
I2 = <F>.
FIELD-SYMBOLS: <I> TYPE I.
DATA: I1 TYPE I, I2 TYPE I.
ASSIGN I1 TO <I>.
I2 = <I>.
五、If, Case……
1.If vs. Case
Case語句比IF語句更清晰并且稍微快些
2.Comparison of I and C
C和C類型比較 比 C與I比較的速度更快
3.While vs. Do
While語句比Do-Exit語句更容易理解，并且執行的更快
4.Case vs. Perform i Of ...
六、Field Conversion
1.Field Types I and P
在需要使用整數的時候（例如SY-TABIX）使用I類型
2.Literals Type C and Type I
3.Constants Type F
使用正確類型的常量.
DATA:
FLOAT TYPE F.
FLOAT = '3.1415926535897932'.
CONSTANTS:
PI TYPE F VALUE '3.1415926535897932'.
DATA:
FLOAT TYPE F.
FLOAT = PI.
4.Arithmetic
在算術運算的時候使用數字類型變量。類型N僅僅用在不需要計算的純數字字符串中，例如：電話號碼，日期或時間的部分內容。
DATA:
N1(15) TYPE N VALUE '123456789012345',
N2(15) TYPE N VALUE '543210987654321',
N3(15) TYPE N.
N3 = N1 + N2.
DATA:
P1 TYPE P VALUE '123456789012345',
P2 TYPE P VALUE '543210987654321',
P3 TYPE P.
P3 = P1 + P2.
5.Mixed Types
不要混合使用數據類型，除非絕對必要。
DATA: F1 TYPE I VALUE 2,
F2 TYPE P DECIMALS 2 VALUE '3.14',
F3 TYPE F.
F3 = F1 * F2.
DATA: F1 TYPE F VALUE 2,
F2 TYPE F VALUE '3.14',
F3 TYPE F.
F3 = F1 * F2.
七、Character/String Manipulation
1.fixed and unfixed length strings
字符串連接運算Concatenate需要掃描固定長度字符（fixed character fields）從第一個非空字符到最后。由于依賴于字符字段的長度，字符串string操作可能更快些。
*data c1(200) type c.
*data c2(200) type c.
*data c3(400) type c.
c1 = 'mysap'.
c2 = '.com'.
concatenate c1 c2 into c3.
*data string1 type string.
*data string2 type string.
*data string3 type string.
string1 = 'mysap'.
string2 = '.com'.
concatenate string1 string2 into string3.
八、ABAP Objects
1.Methods vs Subroutines
調用本地方法PERORM和調用本地子程序CALL性能上沒有差異。
2.Methods vs Function Modules
調用全局類（Global Classes）比調用Function Modules要快
call function 'FUNCTION1'.
call method CL_PERFORMANCE_TEST=>M1.
3.Local Methods vs global Methods
調用全局方法不比調用本地方法要慢多少.
call method C1=>M1. “Local
call method CL_PERFORMANCE_TEST=>M1. “Global
轉載于:https://www.cnblogs.com/hanmos/archive/2013/03/05/2943999.html
總結
以上是生活随笔為你收集整理的ABAP性能实例七例的全部內容，希望文章能夠幫你解決所遇到的問題。
