ABAP - Keyword Documentation →  ABAP - Reference →  Processing Internal Data →  Assignments →  Assigning Structure Components →  CORRESPONDING - Component Operator → 



... { CORRESPONDING dtype|#( [DEEP]
                             [BASE ( base )]
                             struct|{itab [ duplicates]} ) }
  | { CORRESPONDING dtype|#( [BASE ( base )]
                             struct|{itab [ duplicates]}
                             mapping ) } ...


... BASE ( base ) ...


This variant of the component operator CORRESPONDINGconstructs a result with the target type specified using dtype or # from the components of a parameter struct or itab. struct and itab are general expression positions.

If the addition DEEP is specified, the assignment is made in the same way as with the addition EXPANDING NESTED TABLES of the statement MOVE-CORRESPONDING. A mapping rule mapping can be used to override the matching name assignment rule of MOVE-CORRESPONDING. If a mapping rule is specified, the addition DEEP is set implicitly. It is not allowed to be set explicitly.


struct2 = CORRESPONDING #( struct1 ).
without the addition BASE is not the same as an assignment
MOVE-CORRESPONDING struct1 TO struct2.
In MOVE-CORRESPONDING, all not identically named components in struct2 keep their value. If the result of the constructor expression is assigned, however, they are assigned the value from there. This value is initial for ignored components. This behavior can be overridden using the addition BASE.
dobj = CORRESPONDING type( ... ).
the target object is used directly (for optimization reasons) and a temporary version of the expression is not created and assigned. This is not possible when the target object and parameter are identical and a mapping rule is used. This enables, for example, the content of two components to be switched. In cases like this, a temporary copy of the target object must be created and used and an appropriate syntax warning is produced. This warning can be hidden using a pragma. If this is not detected until runtime, the information needed to create the necessary temporary copy of the target object is missing and runtime error CORRESPONDING_SELF occurs. See the executable example Reflexive Component Assignments.


Assignment of four identically named components of standard table spfli_tab to a temporarily sorted table of type flights on an operand position.

  BEGIN OF flight,
    carrid TYPE spfli-carrid,
    connid   TYPE spfli-connid,
    cityfrom TYPE spfli-cityfrom,
    cityto   TYPE spfli-cityto,
  END OF flight.
  flights TYPE SORTED TABLE OF flight WITH UNIQUE KEY carrid connid.

       FROM spfli
       INTO TABLE @DATA(spfli_tab).

cl_demo_output=>display( CORRESPONDING flights( spfli_tab ) ).

Executable Examples


... BASE ( base ) ...


The addition BASE can be used to specify a start value base for the new structure or internal table. base is a functional operand position in which a database convertible to the target type can be specified.

If the addition BASE is specified, the value of base is assigned to the target structure or target table in accordance with the general assignment rules before the remainder of the expression is evaluated. Here, the addition duplicates after itab can be used to define the behavior with respect to duplicate rows occurring in a target table.



Assignment of results of the component operator without and with addition BASE to existing structures of the same content. The value of the component that is not available in the source structure is only retained if BASE is used.

  BEGIN OF src,
    a TYPE i VALUE 1,
    b TYPE i VALUE 2,
  END OF src,
  BEGIN OF target1,
    b TYPE i VALUE 11,
    c TYPE i VALUE 12,
  END OF target1.
DATA(target2) = target1.

target1 = CORRESPONDING #( src ).
target2 = CORRESPONDING #( BASE ( target2 ) src ).

cl_demo_output=>new( )->write( target1 )->display( target2 ).