ABAP Dynamic Programming – Part 2

Tony CecchiniAnthony Cecchini is the President of Information Technology Partners (ITP), an SAP consulting company headquartered in Pennsylvania. ITP offers comprehensive planning, resource allocation, implementation, upgrade, and training assistance to companies. Anthony has over 20 years of experience in SAP R/3 business process analysis and SAP systems integration. His areas of expertise include SAP NetWeaver integration; ALE development; RFC, BAPI, IDoc, Dialog, and Web Dynpro development; and customized Workflow development. You can reach him at ajcecchini@itpsap.com.

 

ABAP Dynamic Programming Techniques

OK, lets pick up from last month where we attempted to accurately define what Dynamic Programming. We said … Dynamic programming is the use of special programming constructs that enable you to use selected features of data and/or operations at runtime that cannot, for various reasons, be determined at compile time.

Lets keep this definition in mind as we begin this discussion on DYNAMIC Programming Techniques.

Using a Dynamic Table Names

Let begin by creating a very simple program that will display table names to the user and when clicked on, the user is presented with the number of rows in the table. Look at the code below

REPORT ztony.
DATA: tabname  TYPE tabname,
      count    TYPE i.

START-OF-SELECTION.
WRITE: / 'EBAN', / 'MARA', / 'VBAK'.

AT LINE-SELECTION.
READ CURRENT LINE LINE VALUE INTO tabname.
SELECT COUNT(*) FROM (tabname) INTO count.
WRITE: 'The table', tabname(7), 'contains', count, 'entries.'.

We have manufactured the “Requirement” that the user will NOT KNOW THE TABLE NAME at compile time, but will at runtime. This is exactly what our definition above states will require us to make use of Dynamic Program Techniques.

The program, at the event line-selection, will take the content of the selected line and read it into the field tabname. In the SELECT statement, the name of the database table is not specified statically. Instead, the clause from (tabname), denotes that the name of the database table is to be read from the variable tabname and substituted into the SELECT statement. So when the SELECT statement is executed, the field tabname is parsed for a valid name of a database table.  If tabname doesn’t contain a valid name, an exception occurs.

OK, lets keep evolving this little program… let’s say instead of the total count of records, we actually want the rows returned. OK, now we are talking about SELECTING rows into a work-area. But wait! We don’t know which table the user will choose, so how can we TYPE the appropriate work-area? We can, trust me. First we need to learn a little about Generic Types and Field-Symbols. But, I’ll even go up a level of abstraction and ask, what the heck is a TYPE?

ABAP Types

ABAP is a hybrid programming language with a type system that reflects both the runtime-event-oriented and the object oriented programming models. Object types (e.g.,classes and interfaces) and value types (e.g., structures and tables) are integrated into one type system and share the same namespace.

Think of types as blueprints for a house. Blueprints provide descriptions of houses. Types are just descriptions of data. This analogy provides an easy way to distinguish between types and data.

Generic Types

A type is defined as “a set of properties that apply to all data of this type,” while data is a sequence of bytes in the memory of the program. A type that contains the complete description required to create data is called a concrete type. In contrast, a generic type is only a partial description of data — for example, the length is not defined within the type. Since additional information is needed to fully describe the data, you cannot create data from a generic type.

Well by using Generic Data Types like ANY, or DATA we can create DATA REFERENCES. We can construct an appropriate work area via the command CREATE DATA. It allows you to create data objects with a dynamically specified type at runtime.

But before we start coding, we need to understand another ABAP construct, the Field-Symbol (cue the music..Da..Da…Da..Daaaaa)

Field Symbols

Field symbols are a special feature of ABAP not found in most other programming languages. Their primary purpose is for accessing lines of internal tables, without the need of actually copying them. Think of field symbols like an aliases for existing data. You can assign an alias or new name to existing data (or part of it), and perform work on that data under its new name. Field symbols can be typed with generic types. Before using a field symbol, you must first declare it and give it a type. Its name must begin with “<” and end with “>”.

OK, lets look at the code below…

  REPORT ztony.

   DATA: dref    TYPE REF TO data,
         tabname TYPE tabname.

   FIELD-SYMBOLS: <row>       TYPE any,
                  <component> TYPE any.

   START-OF-SELECTION.
     WRITE: / 'EBAN', / 'MARA', / 'VBAK'.

   AT LINE-SELECTION.
     READ CURRENT LINE LINE VALUE INTO tabname.

 * dynamically create appropriate Data Structure
     CREATE DATA dref TYPE (tabname).
     ASSIGN dref->* TO <row>.

 * fetch the data
     SELECT *
     FROM (tabname) UP TO 2 ROWS
     INTO <row>.

 * display the result
       NEW-LINE.
       DO.
         ASSIGN COMPONENT sy-index OF STRUCTURE <row> TO <component>.
         IF sy-subrc <> 0.
           EXIT. " no more components
         ENDIF.
         WRITE: <component>.
       ENDDO.
     ENDSELECT.

So lets break this code Down. First, a variable dref with type REF TO DATA is declared, which can hold a reference to any data object. At this point we have not TYPED the Data yet. We just create the reference. I can hear you asking what a reference actually means, so… a reference is a data description that holds a reference to data. It simply points to the data, like a data signpost. We also declare our field symbols.

DATA: dref    TYPE REF TO data.
FIELD-SYMBOLS: <row>       TYPE any,
               <component> TYPE any.

Next, a work area with line type tabname is created dynamically by the ABAP command CREATE DATA. Here we have TYPED the data to the contents of the field tabname, which is filled by the user when they click on the table they want. So if they clicked on EBAN, the Data Reference dref is typed to the structure EBAN.

CREATE DATA dref TYPE (tabname).

The reference dref is referring to this work area. It cannot be accessed directly. Instead, a field symbol <row> is assigned to the work area referred by dref. This now allows us to safely fetch the data from the table tabname into <row> because it is guaranteed that the database table is type-compatible with the work area. I limit the selection to only 2 rows, but you get the idea. Please remember I am inside a SELECT-ENDSELECT loop so I am only selecting one row at a time.

ASSIGN dref->* TO <row>.
SELECT *
     FROM (tabname) UP TO 2 ROWS
     INTO <row>.

Now, that I have FETCHED a row and can access it via the Field-Symbol <row>, we can use a DO Loop to Loop over all components of <row>, and display the fetched data contents.

       DO.
         ASSIGN COMPONENT sy-index OF STRUCTURE <row> TO <component>.
         IF sy-subrc <> 0.
           EXIT. " no more components
         ENDIF.
         WRITE: <component>.
       ENDDO.
     ENDSELECT.

OK, I can hear you saying, Tony, in other blogs you have written you have cautioned us from using the SELECT_ENDSELECT construct as it does not perform well, and besides, this output is messy! You are correct! An array select is the preferred way of selecting rows into an internal table. So …..

Dynamically Created Internal Tables

It is possible to create not only a structures with a dynamically specified type, but also internal tables with a dynamically specified line type. With this feature, we can rewrite our last example. Here we use an array fetch instead of a SELECT -ENDSELECT  loop. Look at the code below.

  REPORT ztony.

   DATA: tabname TYPE tabname,
         dref    TYPE REF TO data,
         alv    TYPE REF TO cl_gui_alv_grid.

   FIELD-SYMBOLS: <itab> TYPE ANY TABLE.

   START-OF-SELECTION.
     WRITE: / 'EBAN', / 'MARA', / 'VBAK'.

   AT LINE-SELECTION.
     READ CURRENT LINE LINE VALUE INTO tabname.

 * dynamically create appropriate internal table
     CREATE DATA dref TYPE TABLE OF (tabname).
     ASSIGN dref->* TO <itab>.

 * fetch the data
     SELECT *
     FROM (tabname) up to 100 rows
     INTO TABLE <itab>.

 * display the result
     CREATE OBJECT alv
       EXPORTING
         i_parent = cl_gui_container=>screen0.

     CALL METHOD alv->set_table_for_first_display
       EXPORTING
         i_structure_name = tabname
       CHANGING
         it_outtab        = <itab>.

The array fetch will reduce the execution time significantly because multiple round-trips to the database interface will be avoided.

Instead of displaying our result set as a list, we show it via an ALV grid control. To do so, we first create an instance of the class cl_gui_alv_grid and assign the entire screen as its parent. Then, the set_table_for_first_display method is called, submitting the dynamically specified table name tabname and the result set <itab> to the grid control.

Stay tuned, as we continue to look at Dynamic Programming, we will learn how to code Dynamic Where Clauses for our select statements, how to code Dynamic joins, Dynamic updates, and Class based Exception handling. Don’t forget to take a look at  ABAP Dynamic Programming – Part 1 for an introduction to the concept of Dynamic Programming.

Take a look at these videos for some good Dynamic Programming Tutorial examples on field symbols and how they are used with internal tables.

 

ITP logo

If you enjoyed this blog, ABAP Dynamic Programming – Part 2, please fill out the form below to sign up for our newsletter. We deliver SAP Technical tips & tricks, SAP news, and the current month’s BLOG right to your inbox!

Related Posts

Comments (3)

[…] is written to the ABAP List by the method WRITE_STRUCT of the class LCL_UTIL. (Refer back to the ABAP Dynamic Programming blog on field symbols if you need a reminder of how some of this code […]

[…] now have discussed all the important concepts needed for dynamic programming in ABAP. We began with techniques for accessing data dynamically, starting with generic types and proceeding… Next, we explored techniques for executing operations dynamically using various forms of […]

[…] now have discussed all the important concepts needed for dynamic programming in ABAP. We began with techniques for accessing data dynamically, starting with generic types and proceeding… Next, we explored techniques for executing operations dynamically using various forms of […]

Comments are closed.

Pin It on Pinterest

Share This

If you enjoyed this post, why not share it with your friends!