Application Development Blog Posts
Learn and share on deeper, cross technology development topics such as integration and connectivity, automation, cloud extensibility, developing at scale, and security.
cancel
Showing results for 
Search instead for 
Did you mean: 
benedict-torres
Participant
Dynamic structures and data references have been well-documented and written for more than a decade already and it's one of the most flexible (albeit, also the most dangerous security-wise) components of SAP development. I would not be re-engineering the wheel but presenting it in different layers of a dynamic structure.

In addition, I wouldn't include the inline declarations yet as it defeats the purpose of dynamism in the context of learning.

We'll try to peel the onion and go from the simplest to the more complex structures using dynamic and data references. What I would try is to best explain dynamic programming to someone who is new to ABAP programming as this is a huge topic and learning it early helps develop a good framework mindset.

For those who want to create tools in the future, you must have a strong base in dynamic programming.

Disclaimer: The examples below are just simple representations and not actual codes in the system. 

Level 1. Dynamic variable. Access any variable in SAP ABAP


Strong Warning: This is highly inadvisable. This is also dangerous when used incorrectly

Usage: If you wanted to access variables in the call stack, particularly on user exits or enhancements.

With great power comes great responsibility. Use it only when necessary and avoid as much as possible.
FIELD-SYMBOLS: <lfs_vkorg> TYPE vkorg.
CONSTANTS: lc_curr_vkorg TYPE objectname VALUE '(SAPMV13H)KOMGH-VKORG'.

... Do something ...

ASSIGN (lc_curr_vkorg) TO <lfs_vkorg>.
IF <lfs_vkorg> IS ASSIGNED.
IF <lfs_vkorg> IS NOT INITIAL.

... Do something ...

ENDIF.
ENDIF.

Level 2. Dynamic Structure


Usage: This would usually go hand in hand with Dynamic tables but if not, it gives you an opportunity to create a structure out of a name or a reference (like another variable). There are multiple ways to create a dynamic structure but one of them is below
PARAMETERS: p_tab   TYPE tabname.

  
DATA: lo_structure TYPE REF TO cl_abap_structdescr,

lr_data TYPE REF TO data.




lo_structure ?= cl_abap_structdescr=>describe_by_name( p_name = p_tab ).

CREATE DATA lr_data TYPE HANDLE lo_structure.

ASSIGN lr_data->* TO FIELD-SYMBOL(<lfs_structure>).

IF <lfs_structure> IS ASSIGNED.
" Do something
ENDIF.

Another example is a dynamically generated structure without a "reference". In this example, I am generating a structure with a number of standard price field based on the parameter p_cnt. It generates the structure on runtime. This is very useful in programs where it can change the output.

One common use case is generating an ALV output based on a time range like a monthly value where the number of months is variable depending on user output.
PARAMETERS: p_cnt   TYPE i.

TYPES: BEGIN OF ty_material_price,
matnr TYPE matnr,
waers TYPE waers,
END OF ty_material_price.

DATA: go_struc TYPE REF TO cl_abap_structdescr,
go_new_struc TYPE REF TO cl_abap_structdescr,
gr_structure TYPE REF TO data,
go_tabdata TYPE REF TO data,
go_descr TYPE REF TO cl_abap_datadescr,
gv_price TYPE STPRS,
gs_mat_price TYPE ty_material_price.


go_struc ?= cl_abap_structdescr=>describe_by_data( gs_mat_price ).

DATA(components) = go_struc->get_components( ).

DO p_cnt TIMES.
go_descr ?= cl_abap_typedescr=>describe_by_data( gv_price ).
APPEND INITIAL LINE TO components
ASSIGNING FIELD-SYMBOL(<component>).
<component> = VALUE #( name = |STPRS{ sy-index }| type = go_descr ).
ENDDO.

TRY.
DATA(new_struc) = cl_abap_structdescr=>create( p_components = components ). " Structure Type Object
CREATE DATA gr_structure TYPE HANDLE new_struc.
ASSIGN gr_structure->* TO FIELD-SYMBOL(<new_structure>).
IF <new_structure> IS ASSIGNED.
" Do something
ENDIF.
CATCH cx_sy_struct_creation. " Exception when creating a structure description
ENDTRY.

Level 3. Dynamic Table


Most of the usage of dynamism in ABAP would revolve in dynamic tables. There are countless usages, particularly in dynamic programs that revolve in the creation of dynamic table. In fact, most framework programs would have some concept of dynamic tables in the coding.

Similar to dynamic structure, there are multiple ways to create a dynamic table but just to continue with the dynamic structure to dynamic table creation, below is a good example of how to create one.
  PARAMETERS: p_tab   TYPE tabname.

DATA: lo_structure TYPE REF TO cl_abap_structdescr,
lo_table TYPE REF TO cl_abap_tabledescr,
lr_data TYPE REF TO data,
lr_table_data TYPE REF TO data.

FIELD-SYMBOLS: <lfs_table> TYPE STANDARD TABLE.


lo_structure ?= cl_abap_structdescr=>describe_by_name( p_name = p_tab ).
CREATE DATA lr_data TYPE HANDLE lo_structure.

lo_table ?= cl_abap_tabledescr=>create(
p_line_type = lo_structure " Line Type
* p_table_kind = tablekind_std " Table Category (STANDARD, SORTED, HASHED)
* p_unique = abap_false " Uniqueness of the Key
* p_key = " Key table
* p_key_kind = keydefkind_default " Key category
).

CREATE DATA lr_table_data TYPE HANDLE lo_table.


ASSIGN lr_data->* TO FIELD-SYMBOL(<lfs_structure>).
ASSIGN lr_table_data->* TO FIELD-SYMBOL(<lfs_table_data>).

IF <lfs_table_data> IS ASSIGNED.
" Do something
ENDIF.

Following the dynamic structure example #2, we can also use the structure to create an internal table out of the dynamic structure.
PARAMETERS: p_cnt   TYPE i.

TYPES: BEGIN OF ty_material_price,
matnr TYPE matnr,
waers TYPE waers,
END OF ty_material_price.

DATA: go_struc TYPE REF TO cl_abap_structdescr,
go_new_struc TYPE REF TO cl_abap_structdescr,
gr_structure TYPE REF TO data,
gr_table TYPE REF TO data,
go_descr TYPE REF TO cl_abap_datadescr,
gv_price TYPE STPRS,
gs_mat_price TYPE ty_material_price.

FIELD-SYMBOLS: <new_table> TYPE STANDARD TABLE.

go_struc ?= cl_abap_structdescr=>describe_by_data( gs_mat_price ).

DATA(components) = go_struc->get_components( ).

DO p_cnt TIMES.
go_descr ?= cl_abap_typedescr=>describe_by_data( gv_price ).
APPEND INITIAL LINE TO components
ASSIGNING FIELD-SYMBOL(<component>).
<component> = VALUE #( name = |STPRS{ sy-index }| type = go_descr ).
ENDDO.

TRY.
DATA(new_struc) = cl_abap_structdescr=>create( p_components = components ). " Structure Type Object
CREATE DATA gr_structure TYPE HANDLE new_struc.
ASSIGN gr_structure->* TO FIELD-SYMBOL(<new_structure>).
IF <new_structure> IS ASSIGNED.
" Do something
ENDIF.

DATA(new_table) = cl_abap_tabledescr=>create( p_line_type = new_struc ).
CREATE DATA gr_table TYPE HANDLE new_table.
ASSIGN gr_table->* TO <new_table>.
IF <new_table> IS ASSIGNED.
" Do something
ENDIF.

CATCH cx_sy_table_creation. " Exception when Creating a Table Type
CATCH cx_sy_struct_creation. " Exception when creating a structure description
ENDTRY.

Level 4. Accessing dynamic fields in the dynamic structure


The entire dynamic table is useless if you cannot access the fields in the structure. The fields from dynamic structures and tables are ambiguous on design time and can only be generated in run time.

That said, you can access them using the ASSIGN COMPONENT command or the ASSIGN command. It will try to access the field or component in run time. Both achieves the same result.
    CREATE DATA gr_structure TYPE HANDLE new_struc.
ASSIGN gr_structure->* TO FIELD-SYMBOL(<new_structure>).
IF <new_structure> IS ASSIGNED.

gv_field = |STPRS{ p_cnt }|.

"Option 1
ASSIGN <new_structure>-(gv_field) TO FIELD-SYMBOL(<stprs2>).
IF <stprs2> IS ASSIGNED.
<stprs2> = 10.
ENDIF.

"Option 2
ASSIGN COMPONENT gv_field OF STRUCTURE <new_structure> TO FIELD-SYMBOL(<stprs>).
IF <stprs> IS ASSIGNED.
<stprs> = 20.
" Do something

BREAK-POINT.

ENDIF.
UNASSIGN <stprs>.

" Do something
ENDIF.

Level 5. Dynamic SELECT statement


Continuing with the theme of the dynamic table, we can select dynamically and create dynamic tables. This can also be achieved differently but this is basically one example on how to achieve a dynamic select statement.

Strong Warning: While this is very useful, make sure that you secure your code for any injections by adding authorization checks on your dynamic programs. 
PARAMETERS: p_tab   TYPE tabname,
p_matnr TYPE matnr.

TYPES: BEGIN OF ty_list,
name TYPE tabname,
r_str TYPE REF TO data,
r_tbl TYPE REF TO data,
END OF ty_list.

DATA: lt_list TYPE STANDARD TABLE OF ty_list.

DATA: lo_structure TYPE REF TO cl_abap_structdescr,
lo_table TYPE REF TO cl_abap_tabledescr,
lt_fields TYPE STANDARD TABLE OF fieldname,
lt_CONDTAB TYPE STANDARD TABLE OF hrcond,
lt_where TYPE STANDARD TABLE OF string,
lr_data TYPE REF TO data,
lr_table_data TYPE REF TO data.

FIELD-SYMBOLS: <lfs_table> TYPE STANDARD TABLE.


lo_structure ?= cl_abap_structdescr=>describe_by_name( p_name = p_tab ).
CREATE DATA lr_data TYPE HANDLE lo_structure.

lo_table ?= cl_abap_tabledescr=>create(
p_line_type = lo_structure " Line Type
* p_table_kind = tablekind_std " Table Category (STANDARD, SORTED, HASHED)
* p_unique = abap_false " Uniqueness of the Key
* p_key = " Key table
* p_key_kind = keydefkind_default " Key category
).

CREATE DATA lr_table_data TYPE HANDLE lo_table.


ASSIGN lr_data->* TO FIELD-SYMBOL(<lfs_structure>).
ASSIGN lr_table_data->* TO FIELD-SYMBOL(<lfs_table_data>).

lt_condtab = VALUE #( ( field = 'MATNR' opera = 'EQ' low = p_matnr ) ).

IF <lfs_table_data> IS ASSIGNED.

IF p_tab EQ 'MARA'.
lt_fields = VALUE #( ( 'MATNR' ) ).

CALL FUNCTION 'RH_DYNAMIC_WHERE_BUILD'
EXPORTING
dbtable = p_Tab
TABLES
condtab = lt_condtab
where_clause = lt_where
EXCEPTIONS
empty_condtab = 1
no_db_field = 2
unknown_db = 3
wrong_condition = 4
OTHERS = 5.

SELECT (lt_fields)
FROM (p_tab)
WHERE (lt_where)
INTO CORRESPONDING FIELDS OF TABLE @<lfs_table_data>.

" Do something

ENDIF.

ENDIF.

Level 6. Reference Variables (DATA)


As you would have noticed, this has been used in the above examples already. There's no limit on the creation of dynamic objects with the usage of data references.

For example, you can create an internal table with data references. In the sample below, you can create a typed internal table with data references to dynamic structures and tables.
  TYPES: BEGIN OF ty_list,
name TYPE tabname,
r_str TYPE REF TO data,
r_tbl TYPE REF TO data,
END OF ty_list.

DATA: lt_list TYPE STANDARD TABLE OF ty_list.

Data references can also be passed via methods or function modules with a well-structured reference variable. If you really need to call dynamic data, the best approach is via Reference variables.
 PARAMETERS: p_tab   TYPE tabname.

CLASS lcl_main DEFINITION.

PUBLIC SECTION.

CLASS-METHODS: set_data CHANGING o_tbl TYPE REF TO data.

ENDCLASS.

TYPES: BEGIN OF ty_list,
name TYPE tabname,
r_str TYPE REF TO data,
r_tbl TYPE REF TO data,
END OF ty_list.

DATA: lt_list TYPE STANDARD TABLE OF ty_list.

DATA: lo_structure TYPE REF TO cl_abap_structdescr,
lo_table TYPE REF TO cl_abap_tabledescr,
lr_data TYPE REF TO data,
lr_table_data TYPE REF TO data.

FIELD-SYMBOLS: <lfs_table> TYPE STANDARD TABLE.


lo_structure ?= cl_abap_structdescr=>describe_by_name( p_name = p_tab ).
CREATE DATA lr_data TYPE HANDLE lo_structure.

lo_table ?= cl_abap_tabledescr=>create(
p_line_type = lo_structure " Line Type
* p_table_kind = tablekind_std " Table Category (STANDARD, SORTED, HASHED)
* p_unique = abap_false " Uniqueness of the Key
* p_key = " Key table
* p_key_kind = keydefkind_default " Key category
).

CREATE DATA lr_table_data TYPE HANDLE lo_table.


ASSIGN lr_data->* TO FIELD-SYMBOL(<lfs_structure>).
ASSIGN lr_table_data->* TO FIELD-SYMBOL(<lfs_table_data>).

IF <lfs_table_data> IS ASSIGNED.
lcl_main=>set_data(
CHANGING
o_tbl = lr_table_data
).
ENDIF.

CLASS lcl_main IMPLEMENTATION.

METHOD set_data.
FIELD-SYMBOLS: <lfs_data> TYPE STANDARD TABLE.

ASSIGN o_tbl->* TO <lfs_data>.
IF <lfs_data> IS ASSIGNED.
" Do something
ENDIF.

ENDMETHOD.

ENDCLASS.

Level 7. Dynamic Methods


One of the best ways to teach a new developer ABAP OO concepts, particularly polymorphism in some aspects, is the usage of Class Interfaces.

A good example of its usage is when you wanted to run different logic depending in configuration. For example, you have a program that can either send to excel or rest service or to flat file in the local server while making it configurable, the best practice way to standardize is the usage of Class Interfaces.
    DATA: lo_adapter    TYPE REF TO zif_adapter,
ls_data TYPE ty_data.

IF ms_adapter-s_adapter-call_class IS NOT INITIAL.
TRY.
CREATE OBJECT lo_adapter TYPE (ms_adapter-s_adapter-call_class).
IF lo_adapter IS BOUND.

lo_adapter->send( CHANGING is_data = ls_data ).

ENDIF.

CATCH cx_sy_dyn_call_illegal_method.
CATCH cx_sy_create_object_error.
ENDTRY.
ENDIF.

Classes with interfaces
" Class #1. Send via Email 
CLASS zcl_email definition
public
final
create public .

PUBLIC SECTION.

INTERFACES: zif_adapter.

PROTECTED SECTION.
PRIVATE SECTION.

ENDCLASS.

CLASS lcl_main IMPLEMENTATION.


METHOD zif_adapter~send.
" Send via email
ENDMETHOD.


ENDCLASS.

" Class #2. Send via FTP
CLASS zcl_ftp definition
public
final
create public .

PUBLIC SECTION.

INTERFACES: zif_adapter.

PROTECTED SECTION.
PRIVATE SECTION.

ENDCLASS.

CLASS lcl_main IMPLEMENTATION.


METHOD zif_adapter~send.
" Send to ftp server
ENDMETHOD.


ENDCLASS.

Again, there are more to dynamic programming that can be written in a blog post but this is a good start for new developers trying to learn ABAP
1 Comment