Dynamic Internal Table iIlustrated with an example of creating the transpose of internal table

Build a Dynamic Internal Table in 1 – 2 – 3  Steps

To create the dynamic table using the much recommended methods in RTTS, refer this document. Create Dynamic Table using RTTS and display in ALV

The method mentioned below is now obsolete and is not preferred anymore.

To learn about field symbols and data references, continue reading.

Creating a dynamic table is not a big deal. Once you understand the concept, it is as simple as 1-2-3. So if your picture about dynamic internal table is something complicated, you need to change that mindset first before proceeding to learn about it.

Dynamic internal table is an internal table with variable rows and columns which can be defined during run time. The different attributes that can be defined at run time includes the field name, column attributes, data type, width, reference table and reference fields. There are just three main steps involved in it.

1. Create the structure of the table
2. Create the dynamic internal table with this structure
3. Populate the dynamic table.

And then you have your dynamic internal table just like any other internal table.

Pre-requisites

Before we start to create a dynamic internal table, we must have an idea of field symbols and data references. If you know them, skip this session and go directly to dynamic table creation.

Field Symbols

Field symbols are like pointers in C. (Technically, they are not the same, using this analogy just to get the picture). They just point to fields. They are like place holders or pseudonyms or alias for other fields.

When you assign a field symbol to a variable, whatever you do to that field symbol, it will be instantly reflected in the variable it points to (or in ABAP Language, the variable it is assigned to)

Syntax

Declarations
-SYMBOLS: <fs1>.
Assignment

ASSIGN f TO <fs1>.

It is like two containers that are connected with a pipe. As long as the field symbol is assigned to the object, whatever you put in the field symbol, it will flow to the data object. And whatever is in the data object can be accessed through the field symbol.

Any changes you make in <fs1> will be instantly reflected in the data object f.

<fs1> = 10.

Now variable f will have the value 10.

It can point to any object determined at run time. And for the same reason, it can adopt to any data type or size at run time depending on the object it is pointing to.

Data References

Data references are used to create data objects dynamically.

Syntax.

Declaration.

DATA <dref> TYPE REF TO DATA.

Creation at run time

CREATE DATA <dref> TYPE <type>|LIKE <obj>.

Now the data type of the object <Dref> will be <type> or the data type of object <obj>

To access the contents of the data object to which a data reference is pointing, you must deference it. This is where we need field symbols.

ASSIGN <dref>->* TO <FS>.

Now whatever statements are performed on Field symbols, it will be reflected in the object dref that we created at run time. Accessing field symbol <Fs> is equivalent to accessing data reference object dref.

Ok. So now we are all set to create dynamic table.

Dynamic Table Creation

Let’s take an example to learn the concept.

Suppose I have an internal table IT_DEMO containing three columns – vendor name (vend), Month(month), Amount Due(amt).

I need to create something like a transpose for this table dynamically. The output should look like this.

Step 1 – Create Structure.

We create structure using field catalog.

If you have used ALV, you must be familiar with field catalog and its fields.

Some of the components of field catalog structure is field name, table name, column text, output length. These are the attributes that can be defined for each field of the dynamic internal table we are creating.

Declare a structure of type lvc_s_fcat.

Declare an internal table of type lvc_t_fcat  (The line type of this internal table is  lvc_s_fcat).

Field Catalog Declaration.

gw_dyn_fcat       TYPE lvc_s_fcat,
gt_dyn_fcat         TYPE lvc_t_fcat.

** This would create structure Vendor Jan13 Feb13 Mar13 ....
DATA : gv_pos TYPE i.
DATA : fname TYPE string.

* Declaring the first column - vendor
gv_pos = gv_pos + 1.

gw_dyn_fcat-fieldname = 'VEND'.          “ Field Name
gw_dyn_fcat-outputlen = 5.                     “ Output Length
gw_dyn_fcat-tabname   = 'IT_DEMO'.    “ Internal Table Name
gw_dyn_fcat-coltext   = 'VENDOR'.        “ Header text for the column
gw_dyn_fcat-col_pos   = gv_pos.             “ Column position 
gw_dyn_fcat-key = 'X'.                            “ Key attribute is set for the field vend. 
APPEND gw_dyn_fcat TO gt_dyn_fcat.
clear gw_dyn_fcat.

 

*Loop through the internal table and creatinga column for every distinct month in the internal table
LOOP AT it_zdemo INTO wa_zdemo.
gv_pos = gv_pos + 1.
CONCATENATE wa_zdemo-month '13' INTO fname.
read table gt_dyn_fcat into gw_dyn_fcat with key fieldname = wa_zdemo-month.
if sy-subrc NE 0.
gw_dyn_fcat-fieldname = wa_zdemo-month.
gw_dyn_fcat-tabname   = 'IT_DEMO'.
gw_dyn_fcat-coltext   = fname.
gw_dyn_fcat-outputlen = 10.
gw_dyn_fcat-col_pos   = gv_pos.
APPEND gw_dyn_fcat TO gt_dyn_fcat.
endif.
clear gw_dyn_fcat.
ENDLOOP.

Now gt_dyn_fcat contains the structure of the table.

Step 2 – Create Dynamic Table.

Dynamic internal tables can be created using method CREATE_DYNAMIC_TABLE in class CL_ALV_TABLE_CREATE.

Importing parameter is the field catalog created in step 1 and the exporting parameter is the dynamic table. The dynamic table must have been declared as dynamic data using data reference.

DATA : gt_dyn_table  TYPE REF TO data.,

gw_line          TYPE REF TO data,
gw_line1         TYPE REF TO data,

* Create a dynamic internal table with this structure.

CALL METHOD cl_alv_table_create=>create_dynamic_table
EXPORTING
i_style_table             = 'X'
it_fieldcatalog           = gt_dyn_fcat
IMPORTING
ep_table                  = gt_dyn_table
EXCEPTIONS
generate_subpool_dir_full = 1
OTHERS                    = 2.

Now we have the dynamic table gt_dyn_table.  To access the data, we use field symbols.

We shall create two work areas gw_line and gw_line1 like line of gt_dyn_table. (or like line of <gfs_dyn_table> which is the field-symbol assigned to gt_dyn_table). The work area gw_line will be accessed by field-symbol <gfs_line> and gw_line1 will be accessed by field symbol <gfs_line1>.

IF sy-subrc EQ 0.
* Assign the new table to field symbol
ASSIGN gt_dyn_table->* TO <gfs_dyn_table>.
* Create dynamic work area for the dynamic table
CREATE DATA gw_line LIKE LINE OF <gfs_dyn_table>.
CREATE DATA gw_line1 LIKE LINE OF <gfs_dyn_table>.
ASSIGN gw_line->* TO <gfs_line>.
ASSIGN gw_line1->* TO <gfs_line1>.
ENDIF.

Note : Field symbols were declared previously with the following statement.

FIELD-SYMBOLS: <gfs_line>,<gfs_line1>,
<gfs_dyn_table> TYPE STANDARD TABLE,
<fs1>.

Step 3 – Populating the dynamic table

Each cell in the dynamic table is accessed using field symbols. We use the field symbol <fs1> to point to each component of work area <gfs_line> (alias gw_line). The values are moved to the work area, component by component through this field symbol <fs1>.

LOOP AT it_zdemo INTO wa_zdemo.
* Avoid duplicate entries for key field VEND. 
READ TABLE <gfs_dyn_table> INTO <gfs_line1> WITH KEY ('VEND') = wa_zdemo-vend.
IF sy-subrc = 0.
CONTINUE.
ENDIF.

* The component vendor of the workarea is assigned to <fs1>
ASSIGN COMPONENT 'VEND' OF STRUCTURE <gfs_line> TO <fs1>.

* The value for vendor in the current loop wa_zdemo-vend  flows to the work area through <fs1>
<fs1> = wa_zdemo-vend.
UNASSIGN <fs1>.
* Move the amount for that vendor for each month in the dynamic table. Each month in the dynamic table can be looped using the field catalog table.

LOOP AT gt_dyn_fcat INTO gw_dyn_fcat.
IF gw_dyn_fcat-fieldname = 'VEND'. “ Move amount only for month fields, not vendor
CONTINUE.
ENDIF.
READ TABLE it_zdemo WITH KEY vend = wa_zdemo-vend month = gw_dyn_fcat-fieldname INTO wa_zdemo1.
IF sy-subrc = 0.
ASSIGN COMPONENT gw_dyn_fcat-fieldname OF STRUCTURE <gfs_line> TO <fs1>.
<fs1> = wa_zdemo1-amt.
UNASSIGN <fs1>.
ENDIF.
clear : wa_zdemo1.
ENDLOOP.

* Append the dynamic work area to the dynamic table. 
APPEND <gfs_line> TO <gfs_dyn_table>.
CLEAR: <gfs_line>.
clear: wa_zdemo, wa_zdemo1.
ENDLOOP.

Now the dynamic table has been created and has been populated with the values based on the contents of the initial internal table.

Drawbacks of Dynamic Internal table

• Programs with many dynamic internal tables are less readable.
• They are less secure since errors cannot be detected by syntax check, but only at runtime
• Performance is not as good as static internal table.

Given below is the complete code for the above program.

REPORT zdynamic_table.

*Author ; Susmitha Susan Thomas

TYPES : BEGIN OF gfirst_typ,
vend(6) TYPE c,
month(5) TYPE c,
amt TYPE i.
TYPES : END OF gfirst_typ.

DATA : it_zdemo TYPE TABLE OF gfirst_typ.
DATA : wa_zdemo LIKE LINE OF it_zdemo,
wa_zdemo1 LIKE LINE OF it_zdemo.

DATA : gv_pos TYPE i.
DATA : fname TYPE string.

* Dynamic Table Declarations


DATA : gt_dyn_table  TYPE REF TO data,
gw_line       TYPE REF TO data,
gw_line1       TYPE REF TO data,
gw_dyn_fcat         TYPE lvc_s_fcat,
gt_dyn_fcat         TYPE lvc_t_fcat.

* Field Symbols Declarations

FIELD-SYMBOLS: <gfs_line>,<gfs_line1>,
<gfs_dyn_table> TYPE STANDARD TABLE,
<fs1>.

* Populate the initial input table. Usually this input table contents will be populated at run time, which raises the requirement of dynamic table. The table contents are filled here for illustration purpose.


wa_zdemo-vend = 'V100'.
wa_zdemo-month = 'JAN'.
wa_zdemo-amt = 100.
APPEND wa_zdemo TO it_zdemo.

wa_zdemo-vend = 'V100'.
wa_zdemo-month = 'FEB'.
wa_zdemo-amt = 200.
APPEND wa_zdemo TO it_zdemo.

wa_zdemo-vend = 'V200'.
wa_zdemo-month = 'FEB'.
wa_zdemo-amt = 200.
APPEND wa_zdemo TO it_zdemo.

wa_zdemo-vend = 'V300'.
wa_zdemo-month = 'FEB'.
wa_zdemo-amt = 150.
APPEND wa_zdemo TO it_zdemo.

wa_zdemo-vend = 'V200'.
wa_zdemo-month = 'MAR'.
wa_zdemo-amt = 250.
APPEND wa_zdemo TO it_zdemo.

wa_zdemo-vend = 'V300'.
wa_zdemo-month = 'MAR'.
wa_zdemo-amt = 300.
APPEND wa_zdemo TO it_zdemo.

wa_zdemo-vend = 'V100'.
wa_zdemo-month = 'APR'.
wa_zdemo-amt = 200.
APPEND wa_zdemo TO it_zdemo.



wa_zdemo-vend = 'V100'.
wa_zdemo-month = 'MAY'.
wa_zdemo-amt = 100.
APPEND wa_zdemo TO it_zdemo.

wa_zdemo-vend = 'V200'.
wa_zdemo-month = 'MAY'.
wa_zdemo-amt = 50.
APPEND wa_zdemo TO it_zdemo.

wa_zdemo-vend = 'V300'.
wa_zdemo-month = 'MAY'.
wa_zdemo-amt = 125.
APPEND wa_zdemo TO it_zdemo.

wa_zdemo-vend = 'V400'.
wa_zdemo-month = 'MAY'.
wa_zdemo-amt = 475.
APPEND wa_zdemo TO it_zdemo.



Write : / 'Initial Internal Table'.

WRITE :/.
write :/(6) 'Vendor'.
write : (12) 'Month' .
write : (3) 'Amt' .
LOOP AT it_zdemo INTO wa_zdemo.
WRITE :/ wa_zdemo-vend, wa_zdemo-month, wa_zdemo-amt.
ENDLOOP.



** This would create structure Vendor Jan13 Feb13 Mar13 etc ....


gv_pos = gv_pos + 1.
gw_dyn_fcat-fieldname = 'VEND'.
gw_dyn_fcat-outputlen = 5.
gw_dyn_fcat-tabname   = 'IT_DEMO'.
gw_dyn_fcat-coltext   = 'VENDOR'.
gw_dyn_fcat-col_pos   = gv_pos.
gw_dyn_fcat-key = 'X'.
gw_dyn_fcat-key_sel = 'X'.
APPEND gw_dyn_fcat TO gt_dyn_fcat.

clear gw_dyn_fcat.

* Loop through the internal table creating a column for every distinct month in the internal table

LOOP AT it_zdemo INTO wa_zdemo.
gv_pos = gv_pos + 1.
CONCATENATE wa_zdemo-month '13' INTO fname.
read table gt_dyn_fcat into gw_dyn_fcat with key fieldname = wa_zdemo-month.
if sy-subrc NE 0.
gw_dyn_fcat-fieldname = wa_zdemo-month.
gw_dyn_fcat-tabname   = 'IT_DEMO'.
gw_dyn_fcat-coltext   = fname.
gw_dyn_fcat-outputlen = 10.
gw_dyn_fcat-col_pos   = gv_pos.
APPEND gw_dyn_fcat TO gt_dyn_fcat.
endif.
clear gw_dyn_fcat.
ENDLOOP.

** Create a dynamic internal table with this structure.

CALL METHOD cl_alv_table_create=>create_dynamic_table
EXPORTING
i_style_table             = 'X'
it_fieldcatalog           = gt_dyn_fcat
IMPORTING
ep_table                  = gt_dyn_table
EXCEPTIONS
generate_subpool_dir_full = 1
OTHERS                    = 2.

IF sy-subrc EQ 0.
* Assign the new table to field symbol
ASSIGN gt_dyn_table->* TO <gfs_dyn_table>.
* Create dynamic work area for the dynamic table
CREATE DATA gw_line LIKE LINE OF <gfs_dyn_table>.
CREATE DATA gw_line1 LIKE LINE OF <gfs_dyn_table>.
ASSIGN gw_line->* TO <gfs_line>.
ASSIGN gw_line1->* TO <gfs_line1>.
ENDIF.




* Populate the dynamic table

LOOP AT it_zdemo INTO wa_zdemo.


* Avoid duplicate entries for key field PART.
READ TABLE <gfs_dyn_table> INTO <gfs_line1> WITH KEY ('VEND') = wa_zdemo-vend.
IF sy-subrc = 0.
CONTINUE.
ENDIF.


ASSIGN COMPONENT 'VEND' OF STRUCTURE <gfs_line> TO <fs1>.
<fs1> = wa_zdemo-vend.
UNASSIGN <fs1>.


LOOP AT gt_dyn_fcat INTO gw_dyn_fcat.
IF gw_dyn_fcat-fieldname = 'VEND'.
CONTINUE.
ENDIF.
READ TABLE it_zdemo WITH KEY vend = wa_zdemo-vend month = gw_dyn_fcat-fieldname INTO wa_zdemo1.
IF sy-subrc = 0.
ASSIGN COMPONENT gw_dyn_fcat-fieldname OF STRUCTURE <gfs_line> TO <fs1>.
<fs1> = wa_zdemo1-amt.
UNASSIGN <fs1>.
ENDIF.
clear : wa_zdemo1.
ENDLOOP.
APPEND <gfs_line> TO <gfs_dyn_table>.
CLEAR: <gfs_line>.
clear: wa_zdemo, wa_zdemo1.
ENDLOOP.

WRITE :/.

Write : / 'Dynamic Internal Table'.
WRITE :/.
LOOP AT gt_dyn_fcat INTO gw_dyn_fcat.
WRITE (10) : gw_dyn_fcat-coltext.
ENDLOOP.
WRITE :/.
LOOP AT <gfs_dyn_table> INTO <gfs_line>.
LOOP AT gt_dyn_fcat INTO gw_dyn_fcat.
ASSIGN COMPONENT gw_dyn_fcat-fieldname OF STRUCTURE <gfs_line> TO <fs1>.
WRITE : <fs1>.
ENDLOOP.
WRITE :/      .
ENDLOOP.

Output

Just a minor addition to the above program. Now if you want to display this as an ALV grid, you need to create another field catalog. Since the field catalog created above is not compatible with the field catalog passed as parameter for ALV display.

data : gw_alv_fieldcat     type slis_fieldcat_alv,
gt_alv_fieldcat     type slis_t_fieldcat_alv.

data:    lv_pos type i.


loop at gt_dyn_fcat into gw_dyn_fcat.
lv_pos = lv_pos + 1.
gw_alv_fieldcat-fieldname     = gw_dyn_fcat-fieldname.
gw_alv_fieldcat-tabname       = gw_dyn_fcat-tabname.
gw_alv_fieldcat-seltext_l     = gw_dyn_fcat-coltext.
gw_alv_fieldcat-outputlen     = gw_dyn_fcat-outputlen.
gw_alv_fieldcat-col_pos       = lv_pos.
gw_alv_fieldcat-do_sum        = gw_dyn_fcat-do_sum.
gw_alv_fieldcat-emphasize     = gw_dyn_fcat-emphasize.
gw_alv_fieldcat-key           = gw_dyn_fcat-key.
gw_alv_fieldcat-no_out        = gw_dyn_fcat-no_out.
append gw_alv_fieldcat to gt_alv_fieldcat.
endloop.

call function 'REUSE_ALV_GRID_DISPLAY'
exporting
i_callback_program = sy-repid
it_fieldcat        = gt_alv_fieldcat
i_default          = 'X'
i_save             = 'A'
tables
t_outtab           = <gfs_dyn_table>.