Skip to content

ABAP Keyword Documentation →  ABAP - Reference →  Processing Internal Data →  Assignments →  Assigning References →  Setting Field Symbols →  ASSIGN →  ASSIGN - mem_area 

ASSIGN - dynamic_dobj

Short Reference

Other versions: 7.31 | 7.40 | 7.54


... { (name) } 
  | { dref->* }
  | { dobj INCREMENT inc }
  | { COMPONENT comp OF STRUCTURE struc } ...


1. ... (name)

2. ... dref->*
3. ... dobj INCREMENT inc
4. ... COMPONENT comp OF STRUCTURE struc


These alternatives to specifying the memory area mem_area of the statement ASSIGN dynamically are used to dynamically access data objects.

In an inline declaration of the field symbol using FIELD-SYMBOL(<fs>), its typing is performed with the generic type data.

In these variants, the ASSIGN statement sets the return code sy-subrc. If the assignment is successful, sy-subrc is set to 0; if not, it is set to 4. If the assignment is not successful, the field symbol keeps its previous state. It is therefore not enough just to evaluate the predicate expression <fs> IS ASSIGNED in a dynamic ASSIGN; sy-subrc needs to be checked as well.

Alternative 1

... (name)


In this dynamic variant of mem_area, the memory area is not specified directly, but as content of a character-like data object (name) in parentheses.

The name in name is structured in the same way as if specified directly: When executing the statement, the content of name must be the name of a data object which may contain offsets and lengths, structure component selectors, and component selectors for assigning attributes in classes or objects. The content of name does not have to be in uppercase letters.

name can contain a chain of names consisting of component selectors. For an individual name or if the first name is followed by an object component selector (->), the specified data object is searched for according to the following hierarchy:

  • If the statement is located in a procedure, the local data objects of the procedure are scanned.

  • If the statement is located in a method, the attributes visible in the method within the class are scanned. In instance methods, the static type of me (special case of cref->(attr_name) in dynamic_access) is scanned.

  • The global data of the current program is scanned.

  • The interface work areas of the main program of the current program group declared using TABLES are scanned.

  • If the statement is located in an instance method, the dynamic type of me (special case of cref->(attr_name) in dynamic_access) is scanned.
  • If the data object is found and the name is followed by an object component selector (->), the search for the following names is continued from left to right, as described under dynamic_access.

    If the first name is followed by a class component selector (=>), the specified class is searched for, as described under dynamic_access, and the search is then continued accordingly from left to right.


    • Dynamically specifying a structure component using a structure component selector produces worse performance than using the addition COMPONENT OF STRUCTURE (see this example).
    • If an attribute of a class in a different program is specified in name using an absolute type name, then, depending on the program type, it is loaded into a new additional program group or to the current program group, if not already loaded. Any existing program constructors are not executed, however, unlike in a genuine dynamic_access.
    • For internal use only, the name in name can also have the form "(PROG)DOBJ", where "PROG" is the name of an ABAP program and "DOBJ" the name of a global data object of this program. If the program "PROG" is loaded into the same internal session as the current program when the ASSIGN statement is executed, then the data object "DOBJ" is searched for in this program and the field symbol points to this data object if the assignment was successful.
    • In an obsolete variant, the addition TABLE FIELD can be specified before name. This restricts the search to table work areas.

    Alternative 2

    ... dref->*


    When specifying a dereferenced data reference dref for mem_area using the dereferencing operator ->*, the memory area of the data object is assigned to the field symbol to which dref points. If the reference variable dref does not reference a data object, the assignment is not performed and sy-subrc is set to 4.

    Unlike all other operand positions for which the data reference dref must be fully typed for dereferencing, dref can be typed generically in the statement ASSIGN using TYPE REF TO data. Dereferencing of a data reference that does not point to a data object also raises an unhandleable exception in all cases except in the ASSIGN statement.


    Creates a local copy of a global data object g_dat in a procedure using a data reference dref and a local field symbol <l_dat>.

    DATA g_dat TYPE string VALUE '...'. 
        CLASS-METHODS meth. 
      METHOD meth. 
        DATA dref TYPE REF TO data. 
        FIELD-SYMBOLS <l_dat> TYPE any. 
        CREATE DATA dref LIKE g_dat. 
        ASSIGN dref->* TO <l_dat>. 
        <l_dat> = g_dat. 
        cl_demo_output=>display_data( <l_dat> ). 

    Alternative 3

    ... dobj INCREMENT inc


    This expression for mem_area assigns a memory area to the field symbol that has the same length as the memory area of dobj and is incremented inc times this length in reference to the memory area of dobj. inc expects a numeric data object. A data object or a field symbol must be specified directly for dobj. Offset or length specifications or the dereferencing of a data reference are not possible.


    The dynamic ASSIGN variant with INCREMENT is designed for sequential access to similar memory areas that are located at regular intervals after each other, such as consecutive structure components of the same data type. In all other cases, ASSIGN ... INCREMENT must be used with caution. Note the following in particular:

    • The assigned memory area is handled using the data type dobj if the addition CASTING is not specified in casting_spec. This means that an implicit casting of the assigned memory areas to the data type of dobj is performed.
    • The typing check also refers to dobj, but is performed only when the statement is executed.
    • The behavior of the statement can be different in Unicode systems and non-Unicode systems if dobj consumes a different number of bytes.
    • Runtime errors always occur if the following general rule is violated: If deep data objects that are in the assigned memory area do not match the typing as far as type and position are concerned.


    For information about the behavior of the ASSIGN statement with the addition INCREMENT, see the respective ABAP example. For an example of usage, see the second example for range_spec.

    Alternative 4

    ... COMPONENT comp OF STRUCTURE struc


    This expression for mem_area assigns a memory area of a component comp of a structure struc to the field symbol.

    struc is a result position. The structure can be specified as a data object or as a writable expression. If struc is specified as an expression, its result must be structured. If struc is specified as a data object, the result does not need to be structured.

    comp is a character-like or numeric expression position. The evaluation depends on the data type of comp:

    • If the field comp has a text-like type (c or string) or the type of a flat structure, which exclusively contains character-like components, the field content is interpreted as the name of the component. The name must be in uppercase letters.
    • If the field comp has a non-text-like elementary type, the content is converted to the type i and interpreted as the position of the component in the structure. If the value of comp is 0, the memory area of the entire structure is assigned to the field symbol.
    • If comp has a different type, then a syntax error or runtime error occurs.

    If an operand struc specified as a data object is not a structure or the specified component is not found, the assignment is not made and sy-subrc is set to 4.


    • Identifying a component by its name is far more performance-intensive than using its position, since far more internal processes are involved. Using COMPONENTS OF, however, always produces better performance than specifying the name after the structure component selector within a fully dynamically specified component in a parenthesized data object name (see this example).
    • If the structure struc is specified as a table expression and the corresponding row is not found, the exception CX_SY_ITAB_LINE_NOT_FOUND is raised.
    • Writable expressions can be specified for struc but no other expressions, since these can have a non-temporary result. Assigning a component of a temporary structure to a field symbol would not make sense.
    • If struc is specified, it is advisable to specify only structures as a data object and to check this in advance. Just evaluating sy-subrc is not enough to determine why an assignment was not successful.
    • In obsolete non-Unicode programs, a flat structure can be specified for comp whose components are not all character-like.


    The following source code excerpts show the dynamic assignment of the components of a structure (passed to the parameter para of a method meth) to a field symbol <comp>.

    The first implementation does not use RTTI. The statement DESCRIBE FIELD is used to check whether the passed data object is a structure. The components are then assigned to the field symbol in a DO loop.

    METHOD meth.
      "IMPORTING para TYPE data.
      DESCRIBE FIELD para TYPE DATA(dtype).
      IF dtype <> 'u' AND dtype <> 'v'.
            ASSIGN COMPONENT sy-index OF STRUCTURE para TO FIELD-SYMBOL(<comp>).
            IF sy-subrc <> 0.
          CATCH cx_sy_assign_empty_structure.
            "Skip empty generic boxes, if any

    The second implementation uses RTTI. A down cast of the type description object to the class CL_ABAP_STRUCTDESCR for the passed data object ensures that the object is a structure. A loop across the component table COMPONENTS assigns the components to the field symbol.

    METHOD meth.
      "IMPORTING para TYPE data.
      DATA struct_descr TYPE REF TO cl_abap_structdescr.
          struct_descr ?= cl_abap_typedescr=>describe_by_data( para ).
        CATCH cx_sy_move_cast_error.
      LOOP AT struct_descr->components ASSIGNING FIELD-SYMBOL(<comp_descr>).
        ASSIGN COMPONENT <comp_descr>-comp_index
               OF STRUCTURE para TO FIELD-SYMBOL(<comp>).


    Assigns a component of a row of an internal table to a field symbol.

      BEGIN OF struc, 
        col1 TYPE i, 
        col2 TYPE i, 
      END OF struc. 
    itab = VALUE #( ( col1 = 1 col2 = 2 ) 
                    ( col1 = 3 col2 = 4 ) ). 
    cl_demo_output=>display( <fs> ). 


    Field Symbols, Dynamic Structure Components - Example

    Field Symbols, ASSIGN INCREMENT - Example