ABAP 新语法

ABAPer_Kang

已于 2023-07-10 21:06:15 修改

阅读量1k

点赞数 1

分类专栏： ABAP 文章标签：前端数据库服务器

于 2023-07-10 20:47:04 首次发布

原文链接：https://blog.csdn.net/thinksmile1992/article/details/127994809

版权

ABAP 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

5）Width/Alignment/Padding 宽度/对齐/填充

6）日期格式

8）LINE_INDEX、LINE_EXISTS

14）LINES、LINE_EXISTS、LINE_INDEX

15）将日期转换为系统格式

16）DATA(ls_data) = gt_data[ index ].

1）不用提前定义声明

* old
DATA LT_DATA TYPE TABLE OF SPFLI.
SELECT * FROM SPFLI INTO TABLE LT_DATA.

* new
SELECT * FROM SPFLI INTO TABLE @DATA(LT_DATA).

-----------------------------------------------
* old
DATA LT_DATA TYPE TABLE OF SPFLI.
DATA LS_DATA LIKE LINE OF LT_DATA.
LOOP AT LT_DATA INTO LS_DATA.
ENDLOOP.
READ TABLE LT_DATA INTO LS_DATA INDEX 1.

* new
LOOP AT LT_DATA INTO DATA(LS_DATA).
ENDLOOP.
READ TABLE LT_DATA INTO DATA(LS_DATA) INDEX 1.

READ TABLE LT_DATA ASSIGNING FIELD-SYMBOL(<ls_data>) INDEX 1.

2）内表赋值

RANGES RT_BUKRS FOR T001-BUKRS.

RT_BUKRS[] = VALUE #(
( SIGN = 'I' OPTION = 'BT' LOW = '1001' HIGH = '1099' )
( SIGN = 'I' OPTION = 'EQ' LOW = '2001' )
).

CL_DEMO_OUTPUT=>DISPLAY( RT_BUKRS[] ).

3）内表基础上附加额外数据

RANGES RT_BUKRS FOR T001-BUKRS.

RT_BUKRS[] = VALUE #(
( SIGN = 'I' OPTION = 'BT' LOW = '1001' HIGH = '1099' )
( SIGN = 'I' OPTION = 'EQ' LOW = '2001' )
).

"内表基础上附加额外数据
RT_BUKRS[] = VALUE #( BASE RT_BUKRS[]
( SIGN = 'I' OPTION = 'EQ' LOW = '3001' )
).
CL_DEMO_OUTPUT=>DISPLAY( RT_BUKRS[] ).

4）关于 CORRESPONDING

DATA:LS_TMP1 TYPE SBOOK.
DATA:LS_TMP2 TYPE SBOOK.
DATA:LS_TMP3 TYPE SBOOK.
SELECT SINGLE * FROM SFLIGHT INTO @DATA(LS_DATA) WHERE CARRID = 'AA'.

LS_TMP1-BOOKID = '99999999'.
LS_TMP1-CUSTOMID = '88888888'.
LS_TMP1-FLDATE = '20210101'.

LS_TMP2-BOOKID = '99999999'.
LS_TMP2-CUSTOMID = '88888888'.
LS_TMP2-FLDATE = '20210101'.

LS_TMP3-BOOKID = '99999999'.
LS_TMP3-CUSTOMID = '88888888'.
LS_TMP3-FLDATE = '20210101'.

LS_TMP1 = CORRESPONDING #( BASE ( LS_TMP1 ) LS_DATA ). "不指定BASE 初始值会丢失
LS_TMP2 = CORRESPONDING #( LS_DATA ). "不指定BASE 初始值会丢失
MOVE-CORRESPONDING LS_DATA TO LS_TMP3.

CL_DEMO_OUTPUT=>WRITE( LS_TMP1 ).
CL_DEMO_OUTPUT=>WRITE( LS_TMP2 ).
CL_DEMO_OUTPUT=>WRITE( LS_TMP3 ).
CL_DEMO_OUTPUT=>WRITE( LS_DATA ).
CL_DEMO_OUTPUT=>DISPLAY( ).

效果：

CORRESPONDING # 跟 MOVE-CORRESPONDING 还是有区别的。

5）Width/Alignment/Padding 宽度/对齐/填充

可用于字段值补前导/后导0（或其它值）。

DATA:LV_MANTR1 TYPE MATNR VALUE '11'.
DATA:LV_MATNR2 TYPE MATNR .
DATA:LV_MATNR3 TYPE MATNR .
DATA:LV_MATNR4 TYPE MATNR .

* Width/Alignment/Padding 宽度/对齐/填充
LV_MATNR2 = |{ LV_MANTR1 WIDTH = 18 ALIGN = RIGHT PAD = '0' }|.

CALL FUNCTION 'CONVERSION_EXIT_MATN1_INPUT'
EXPORTING
INPUT = LV_MANTR1
IMPORTING
OUTPUT = LV_MATNR3
EXCEPTIONS
LENGTH_ERROR = 1
OTHERS = 2.
IF SY-SUBRC <> 0.
* Implement suitable error handling here
ENDIF.

LV_MATNR4 = |{ LV_MATNR3 ALPHA = OUT }|.

CL_DEMO_OUTPUT=>WRITE( 'LV_MANTR1:' && LV_MANTR1 ).
CL_DEMO_OUTPUT=>WRITE( 'LV_MATNR2:' && LV_MATNR2 ).
CL_DEMO_OUTPUT=>WRITE( 'LV_MATNR3:' && LV_MATNR3 ).
CL_DEMO_OUTPUT=>WRITE( 'LV_MATNR4:' && LV_MATNR4 ).

CL_DEMO_OUTPUT=>DISPLAY( ).

效果：

6）日期格式

DATA(P_DATE) = SY-DATUM.

WRITE / |{ P_DATE DATE = ISO }|. "Date Format YYYY-MM-DD
WRITE / |{ P_DATE DATE = USER }|. "As per user settings
WRITE / |{ P_DATE DATE = ENVIRONMENT }|. "Formatting setting of language environment
7）字符串内表拼接
SELECT WERKS FROM t001w INTO TABLE @DATA(gt_data).

DATA(lv_concat_lines) = concat_lines_of( table = gt_data sep = '/' ).

DATA:lt_tmp like gt_data.
SPLIT lv_concat_lines AT '/' INTO TABLE lt_tmp.

CL_DEMO_OUTPUT=>WRITE( lv_concat_lines ).
CL_DEMO_OUTPUT=>WRITE( lt_tmp[] ).

CL_DEMO_OUTPUT=>DISPLAY( ).
效果：

8）LINE_INDEX、LINE_EXISTS

SELECT * FROM SPFLI INTO TABLE @DATA(GT_DATA) WHERE carrid = 'AZ'.

"输出查询结果
CL_DEMO_OUTPUT=>WRITE( GT_DATA ).
"找到数据
DATA(LV_INDEX) = LINE_INDEX( GT_DATA[ CARRID = 'AZ' CONNID = '0788' ] ).

IF LV_INDEX NE 0 AND LINE_EXISTS( GT_DATA[ LV_INDEX ] ) .
DATA(LS_DATA) = GT_DATA[ LV_INDEX ]. "取该行数据
ENDIF.
CL_DEMO_OUTPUT=>WRITE( LS_DATA ).
"看看多条记录的时候，找到的第几条
SORT GT_DATA by CITYFROM.
DATA(LV_INDEX_tmp) = LINE_INDEX( GT_DATA[ CITYFROM = 'ROME' ] ).

CL_DEMO_OUTPUT=>WRITE( LV_INDEX_tmp ).

CL_DEMO_OUTPUT=>DISPLAY( ).

效果：

9）大括号{}的使用

跟直接&& 拼接有空格的差别。

SELECT * FROM SPFLI INTO TABLE @DATA(GT_DATA) WHERE CARRID = 'AZ'.

CL_DEMO_OUTPUT=>WRITE( GT_DATA ).
CL_DEMO_OUTPUT=>WRITE( GT_DATA[ CONNID = '0788' ] ).
CL_DEMO_OUTPUT=>WRITE( GT_DATA[ CONNID = '0788' ]-CONNID ).

CL_DEMO_OUTPUT=>WRITE( |CONNID: { GT_DATA[ CONNID = '0788' ]-CONNID }| ).

CL_DEMO_OUTPUT=>WRITE( 'CONNID:'&& GT_DATA[ CONNID = '0788' ]-CONNID ).

CL_DEMO_OUTPUT=>DISPLAY( ).
效果：

10）内表 filter

TYPES: BEGIN OF TY_FILTER,
CITYFROM TYPE SPFLI-CITYFROM,
CITYTO TYPE SPFLI-CITYTO,
END OF TY_FILTER,

*& 需要是排序表或者哈希表
* TY_FILTER_TAB TYPE SORTED TABLE OF TY_FILTER WITH UNIQUE KEY CITYFROM CITYTO.
TY_FILTER_TAB TYPE HASHED TABLE OF TY_FILTER WITH UNIQUE KEY CITYFROM CITYTO.

*& 查询所有数据
SELECT * FROM SPFLI INTO TABLE @DATA(LT_SPLFI).
SORT LT_SPLFI by CITYFROM.

*筛选数据
DATA(LT_FILTER) = VALUE TY_FILTER_TAB(
( CITYFROM = 'NEW YORK' CITYTO ='SAN FRANCISCO' )
( CITYFROM = 'FRANKFURT' CITYTO = 'NEW YORK' ) ).

DATA(LT_RESULT) = FILTER #( LT_SPLFI IN LT_FILTER
WHERE CITYFROM = CITYFROM
AND CITYTO = CITYTO ).

*排除
DATA(LT_EXCEPT) = FILTER #( LT_SPLFI EXCEPT IN LT_FILTER
WHERE CITYFROM = CITYFROM
AND CITYTO = CITYTO ).

CL_DEMO_OUTPUT=>WRITE( LT_SPLFI ).

CL_DEMO_OUTPUT=>WRITE( LT_RESULT ).

CL_DEMO_OUTPUT=>WRITE( LT_EXCEPT ).

CL_DEMO_OUTPUT=>DISPLAY( ).

效果：

11）LET关键字

LET关键字可以使用在VALUE，SWITCH，COND等语句中；与 FOR 语句类似，LET 语句中定义的临时变量同样只能在当前语句中使用，在其他语句中使用时会检查出语法错误。

TYPES: BEGIN OF TY_DATA,
MATNR TYPE MARA-MATNR,
MTART TYPE MARA-MTART,
MATKL TYPE MARA-MATKL,
TEXT1 TYPE CHAR50,
END OF TY_DATA.

DATA LT_DATA TYPE TABLE OF TY_DATA.

LT_DATA = VALUE #(
( MATNR = 'MATRIAL-001'
MTART = 'WATR'
MATKL = '1020'
TEXT1 = 'FIRST material' )
( MATNR = 'MATRIAL-002'
MTART = 'FOOD'
MATKL = '1030'
TEXT1 = 'SECOND material' )
( MATNR = 'MATRIAL-003'
MTART = 'WATR'
MATKL = '1040'
TEXT1 = 'THIRD material' )
).

DATA(LW_LINE) = VALUE TY_DATA( LET
LW_DATA = VALUE #( LT_DATA[ MATNR = 'MATRIAL-001' ] OPTIONAL )
LV_STR = 'Date:' && SY-DATUM
IN
MATNR = LW_DATA-MATNR
MTART = LW_DATA-MTART
MATKL = LW_DATA-MATKL
TEXT1 = LV_STR
).

CALL METHOD CL_DEMO_OUTPUT=>DISPLAY( LW_LINE ).

效果：

12）GROUP BY分组循环

DATA LT_TMP TYPE TABLE OF SFLIGHT.

START-OF-SELECTION.

SELECT * FROM SFLIGHT INTO TABLE @DATA(LT_SFLIGHT)
WHERE PLANETYPE = 'A340-600'.

LOOP AT LT_SFLIGHT INTO DATA(LS_SFLIGHT)
GROUP BY (
CARRID = LS_SFLIGHT-CARRID
CONNID = LS_SFLIGHT-CONNID
)
ASCENDING INTO DATA(LT_GROUP)
.
LOOP AT GROUP LT_GROUP INTO DATA(LS_GROUP).
APPEND LS_GROUP TO LT_TMP.
ENDLOOP.
CL_DEMO_OUTPUT=>WRITE( LT_TMP ).
CLEAR LT_TMP[].
ENDLOOP.
CL_DEMO_OUTPUT=>DISPLAY( )

效果：

loop at lt_data into data(ls_data) group by ( field = ls_data-field )
ascending assigning field-symbol(<group>).
loop at group <group> assigning field-symbol(<fs>).

endloop.
endloop.
动态条件分组。分组处理，不像at end of 那样需要调整字段顺序。

DATA: lv_field TYPE c VALUE 'B'.
LOOP AT <dy_table> ASSIGNING <dyn_wa> GROUP BY SWITCH string( lv_field WHEN 'A'
THEN | BELNR = <DYN_WA>-BELNR|
WHEN 'B'
THEN | BELNR = <DYN_WA>-BELNR WAERS = <DYN_WA>-WAERS | ) ASSIGNING FIELD-SYMBOL(<group>).
LOOP AT GROUP <group> ASSIGNING FIELD-SYMBOL(<fs1>).
ENDLOOP.
ENDLOOP.

13）SQL语句

SELECT * FROM spfli
WHERE LEFT( CARRID , 1 ) = 'A'
INTO TABLE @DATA(gt_data).

CL_DEMO_OUTPUT=>WRITE( gt_data ).

SELECT * FROM spfli
WHERE RIGHT( CARRID , 1 ) = 'Z'
INTO TABLE @DATA(gt_data2).

CL_DEMO_OUTPUT=>WRITE( gt_data2 ).

SELECT * FROM spfli
WHERE SUBSTRING( CARRID , 1,1 ) = 'A'
INTO TABLE @DATA(gt_data3).
CL_DEMO_OUTPUT=>WRITE( gt_data3 ).

SELECT * FROM spfli
WHERE SUBSTRING( CARRID , 2,1 ) = 'Z'
INTO TABLE @DATA(gt_data4).
CL_DEMO_OUTPUT=>WRITE( gt_data4 ).

CL_DEMO_OUTPUT=>display( ).

效果：

14）LINES、LINE_EXISTS、LINE_INDEX

LINES 计算内表总行数。

LINE_EXISTS 判断根据特定条件能否在内表中读取到记录，返回值为布尔型数据。使用此语法，可判断内表中行是否有满足条件的，无需LOOP判断，省去好多代码。

LINE_INDEX 获取内表中满足特定条件的记录所在的行数( INDEX ),如果存在多个条件值，则只会返回第一个搜索到的值的行数。

SELECT * FROM spfli INTO TABLE @DATA(lt_table) UP TO 3 ROWS.

DATA(lv_lines) = lines( lt_table ).
DATA(lv_exist) = xsdbool( line_exists( lt_table[ carrid = 'AZ' ] ) ).
DATA(lv_index) = line_index( lt_table[ carrid = 'AZ' ] ).

15）将日期转换为系统格式

*这里date= environment是用来格式化日期的，将日期转换成系统格式。
DATA(lv_string) = |Today is { sy-datum DATE = ENVIRONMENT }|.
WRITE lv_string.

16）DATA(ls_data) = gt_data[ index ].

使用此语法，可以省去read,直接读取指定行号的数据，但需要判断gt_data是否有指定index行，需要catch 异常CX_SY_ITAB_LINE_NOT_FOUND异常，否则会直接dump。

17）Select 内表

select 内表，可以对内表使用sql的语法。例如：取内表某一列的最大值，就可以直接MAX，无需排序后，读第一行。
需要append a表 to B表时，但A表字段与B表字段数量不一致时，可以使
SELECT FROM @a表 AS a
FIELDS field1
APPENDING CORRESPONDING FIELDS OF TABLE @b表.

18）前导0处理

lv_field = |{ lv_field ALPHA = OUT }|.//去前导0
lv_field = |{ lv_field ALPHA = IN }|.//加前导0

SHIFT lv_field LEFT DELETING LEADING '0'.//去前导0

19）VALUE

lt_data[] = value #( for wa in gt_data
where ( field1 = '01' and field2 = '02 ) ( wa ) ).

20）REPLACE

lv_string1 = 'statements'.
lv_string2 = 'asffasfa'..
write: replace( val = lv_string1
sub = 'sta'
case = abap_true
with = to_upper( lv_string2 ) "如果发现sta,用lv_string2的大写替换
occ = 2 ).
"如果occ为正，则从左边开始计数;如果occ为负，则从右数。值1、2、....表示第一，第二，事件。取值为-1、-2、....表示最后一个，倒数第二个，。

21）CASE

TRY.
CATCH cx_root INTO DATA(exc).
CASE TYPE OF exc.
WHEN TYPE cx_sy_arithmetic_error.
out->display( 'Arithmetic error' ).
WHEN TYPE cx_sy_conversion_error.
out->display( 'Conversion error' ).
WHEN OTHERS.
out->display( 'Other error' ).
ENDCASE.
ENDTRY.
抓异常，分异常类型报错。

22）SWITCH

DATA(number) = SWITCH string( sy-index
WHEN 1 THEN 'one'
WHEN 2 THEN 'two'
WHEN 3 THEN 'three'
ELSE THROW cx_overflow( ) ).
SWITCH动态赋值语句，通常根据同一变量的不同数据来动态处理，用法类似于 CASE 语句。

DATA(LV_INDICATOR) = 1.
DATA(LV_DAY) = SWITCH CHAR10( LV_INDICATOR
WHEN 1 THEN 'MONDAY'
WHEN 2 THEN 'TUESDAY'
WHEN 3 THEN 'WEDNESDAY'
WHEN 4 THEN 'THURSDAY'
WHEN 5 THEN 'FRIDAY'
WHEN 6 THEN 'SATURDAY'
WHEN 7 THEN 'SUNDAY'
ELSE '404' && '-ERROR'
).
CALL METHOD CL_DEMO_OUTPUT=>DISPLAY( LV_DAY ).

23）COND

COND动态赋值语句，可以根据不同条件来动态处理，用法类似于CASE/IF语句。

COND语句中允许使用较为复杂的判断条件，因此VALUE语句中动态赋值通常会使用COND。

DATA(LV_INDICATOR) = 7.
DATA(LV_DAY) = COND CHAR10( WHEN LV_INDICATOR = 1 THEN 'MONDAY'
WHEN LV_INDICATOR = 2 THEN 'TUESDAY'
WHEN LV_INDICATOR = 3 THEN 'WEDNESDAY'
WHEN LV_INDICATOR = 4 THEN 'THURSDAY'
WHEN LV_INDICATOR = 5 THEN 'FRIDAY'
WHEN LV_INDICATOR = 6 THEN 'SATURDAY'
WHEN LV_INDICATOR = 7 AND SY-LANGU EQ 'E' THEN 'SUNDAY'
WHEN LV_INDICATOR = 7 AND SY-LANGU EQ 'F' THEN 'DIMANCHE'
WHEN LV_INDICATOR = 7 AND SY-LANGU EQ '1' THEN '星期天'
ELSE '404' && '-ERROR'
).
CALL METHOD CL_DEMO_OUTPUT=>DISPLAY( LV_DAY ).

24）CORRESPONDING

结构赋值语句，CORRESPONDING语句允许控制组件映射关系。

在ABAP 7.40之前，主要通过 MOVE-CORRESPONDING 来传递结构化数据，
但需要保持结构内部组件名称一致，否则数据将不会被传递，
而使用 CORRESPONDING 后，该语句在保持同名组件自动进行数据传递的基础上，
MAPPING 可以允许我们将不同名称的组件映射到一起，
EXCEPT 可以规避掉我们不需要传值的一些字段

TYPES: BEGIN OF TY_DATA,
MATNR TYPE MARA-MATNR,
MTART TYPE MARA-MTART,
MATKL TYPE MARA-MATKL,
TEXT1 TYPE CHAR50,
END OF TY_DATA.

TYPES: BEGIN OF LTY_TABLE,
MATNR_C TYPE MARA-MATNR,
MTART TYPE MARA-MTART,
MATKL TYPE MARA-MATKL,
TEXT1 TYPE CHAR50,
END OF LTY_TABLE.

DATA LT_DATA TYPE TABLE OF TY_DATA.
DATA LT_TABLE TYPE TABLE OF LTY_TABLE.

LT_DATA = VALUE #( ( MATNR = 'Material-001'
MTART = 'WATR'
MATKL = '1020'
TEXT1 = 'First Material' )
( MATNR = 'Material-002'
MTART = 'WATR'
MATKL = '1030'
TEXT1 = 'Second Material' ) ).

LT_TABLE = CORRESPONDING #( LT_DATA
MAPPING MATNR_C = MATNR
EXCEPT MATKL ).

"CALL METHOD CL_DEMO_OUTPUT=>DISPLAY( LT_DATA ).
"CALL METHOD CL_DEMO_OUTPUT=>DISPLAY( LT_TABLE ).
CALL METHOD CL_DEMO_OUTPUT=>WRITE( LT_DATA ).
CALL METHOD CL_DEMO_OUTPUT=>WRITE( LT_TABLE ).
CALL METHOD CL_DEMO_OUTPUT=>DISPLAY( ).

效果：

在 MAPPING 语句中，需要注意两边的字段类型，以免类型不兼容而导致程序 dump。

使用DEEP处理深层结构数据，相当于MOVE CORRESPONDING [ EXPANDING NESTED TABLES ]。

TYPES: BEGIN OF LTY_PROD_MAT,
MATNR TYPE MATNR,
MTART TYPE MTART,
MATKL TYPE MATKL,
BISMT TYPE BISMT,
END OF LTY_PROD_MAT.

DATA: BEGIN OF LS_PROD_MATS,
SECTION TYPE CHAR10,
T_MATERIALS TYPE TABLE OF LTY_PROD_MAT,
END OF LS_PROD_MATS.

TYPES: BEGIN OF LTY_SALES_MAT,
MATNR TYPE MATNR,
BISMT TYPE BISMT,
MTART TYPE MTART,
MATKL TYPE MATKL,
END OF LTY_SALES_MAT.

DATA: BEGIN OF LS_SALES_MATS,
SECTION TYPE CHAR10,
T_MATERIALS TYPE TABLE OF LTY_SALES_MAT,
END OF LS_SALES_MATS.

SELECT MATNR MTART MATKL BISMT FROM MARA
INTO CORRESPONDING FIELDS OF TABLE LS_SALES_MATS-T_MATERIALS
UP TO 3 ROWS.

LS_PROD_MATS = CORRESPONDING #( DEEP LS_SALES_MATS ).

"CALL METHOD CL_DEMO_OUTPUT=>DISPLAY( LS_SALES_MATS-T_MATERIALS ).
"CALL METHOD CL_DEMO_OUTPUT=>DISPLAY( LS_PROD_MATS-T_MATERIALS ).
CALL METHOD CL_DEMO_OUTPUT=>WRITE( LS_SALES_MATS-T_MATERIALS ).
CALL METHOD CL_DEMO_OUTPUT=>WRITE( LS_PROD_MATS-T_MATERIALS ).
CALL METHOD CL_DEMO_OUTPUT=>DISPLAY( ).

效果：

使用BASE保留初始数据，为内表赋值时相当于
MOVE CORRESPONDING [ KEEPING TARGET LINES ]，
为结构赋值时类似于VALUE [ BASE ]

TYPES: BEGIN OF TY_DATA,
MATNR TYPE MARA-MATNR,
MTART TYPE MARA-MTART,
MATKL TYPE MARA-MATKL,
TEXT1 TYPE CHAR50,
END OF TY_DATA.

DATA LT_DATA TYPE TABLE OF TY_DATA.
DATA LT_TABLE TYPE TABLE OF TY_DATA.

LT_DATA = VALUE #( ( MATNR = 'Material-001'
MTART = 'WATR'
MATKL = '1020'
TEXT1 = 'First Material' )
( MATNR = 'Material-002'
MTART = 'WATR'
MATKL = '1030'
TEXT1 = 'Second Material' ) ).

CALL METHOD CL_DEMO_OUTPUT=>WRITE( LT_DATA ).

LT_TABLE = VALUE #( ( MATNR = 'Material-001'
MTART = 'FOOD' )
( MATNR = 'Material-002'
MTART = 'WATR') ).

CALL METHOD CL_DEMO_OUTPUT=>WRITE( LT_TABLE ).

LT_TABLE = CORRESPONDING #( BASE ( LT_TABLE ) LT_DATA EXCEPT MATKL ).

CALL METHOD CL_DEMO_OUTPUT=>WRITE( LT_TABLE ).
CALL METHOD CL_DEMO_OUTPUT=>DISPLAY( ).

效果：

CORRESPONDING中可以从两个内表中引入数据，FORM子句后的内表结构需要定义为排序表或哈希表
该语法不能与DEEP/BASE关键字同时使用，但是可以使用MAPPING/EXCEPT
如下例所示，以表1为基表，根据USING定义的关联条件去表2查找数据，如果查找到，
则将表2的该条数据复写到表1对应的记录上并返回，否则直接返回表1的数据
MAPPING/EXCEPT作用于表2数据复写到表1对应记录的过程中，特定条件下可以用来实现读取数据
并更新内表的操作，但是需要定义非标准表，有一定的局限性

TYPES:BEGIN OF LTY_DATA,
INDEX TYPE CHAR4,
TEXT1 TYPE CHAR10,
TEXT2 TYPE CHAR10,
END OF LTY_DATA.

DATA: LT_TMP1 TYPE SORTED TABLE OF LTY_DATA WITH UNIQUE KEY INDEX,
LT_TMP2 TYPE SORTED TABLE OF LTY_DATA WITH UNIQUE KEY INDEX,
LT_DATA TYPE TABLE OF LTY_DATA.

LT_TMP1 = VALUE #( ( INDEX = '0001' TEXT1 = 'X' )
( INDEX = '0004' TEXT1 = 'X' )
( INDEX = '0009' TEXT1 = 'X' )
( INDEX = '0021' TEXT1 = 'X' ) ).

LT_TMP2 = VALUE #( ( INDEX = '0001' TEXT2 = 'Y' )
( INDEX = '0002' TEXT2 = 'Y' )
( INDEX = '0003' TEXT2 = 'Y' )
( INDEX = '0004' TEXT2 = 'Y' ) ).

LT_DATA = CORRESPONDING #( LT_TMP1 FROM LT_TMP2 USING INDEX = INDEX )."from后表的数据传递给前表，按照using后条件操作”
CALL METHOD CL_DEMO_OUTPUT=>WRITE( LT_DATA ).
LT_DATA = CORRESPONDING #( LT_TMP1 FROM LT_TMP2 USING INDEX = INDEX EXCEPT TEXT1 )."可以使用mapping和except”
CALL METHOD CL_DEMO_OUTPUT=>WRITE( LT_DATA ).
CALL METHOD CL_DEMO_OUTPUT=>DISPLAY( ).

效果：

25）语法变化对比

ABAPer_Kang

关注

1
点赞
踩
10

收藏

觉得还不错? 一键收藏
1
评论
ABAP 新语法

使用此语法，可以省去read,直接读取指定行号的数据，但需要判断gt_data是否有指定index行，需要catch 异常CX_SY_ITAB_LINE_NOT_FOUND异常，否则会直接dump。LT_DATA = CORRESPONDING #( LT_TMP1 FROM LT_TMP2 USING INDEX = INDEX )."from后表的数据传递给前表，按照using后条件操作”与 FOR 语句类似，LET 语句中定义的临时变量同样只能在当前语句中使用，在其他语句中使用时会检查出语法错误。
复制链接

扫一扫