Skip to Content
Author's profile photo Matthew Billingham

How to create the only buffer you’ll ever need…


This blog has been inspired by Bruno Esperança and his thought provoking The last runtime buffer you’ll ever need? The thing is, I wrote such a thing a few years ago, that’s widely used by one of my clients. There’s a few areas it could be improved

The Interface

interface zif_lookup

   public .

     constants c_dateto type fieldname value ‘DATETO’. “#EC NOTEXT

   methods lookup


       es_data type any

       eo_type type ref to cl_abap_structdescr

       e_notfound_flag type char1


       sql_error .

   methods set_key_val


       i_component type clike

       i_value type any .

   methods set_tim_val


       i_component type clike

       i_value type any .

   methods set_val_component


       i_component type clike .

   methods get_ref2_lookup


       value(rp_data) type ref to data


       sql_error .

   methods get_val_struc


       value(ro_valstruc) type ref to cl_abap_structdescr .

   methods get_notfound_flag


       value(r_notfound_flag) type flag .


Buffering in use

Well, the constructor is missing, so just showing you the interface doesn’t really help! So, imagine a class with this attribute.

DATA: buffer TYPE REF TO zif_lookup.

Then we have a method in some class that reads materials from the MARC table, with i_matnr, i_werks, exporting e_bwtty and e_mmsta.

IF buffer IS NOT bound.

  CREATE OBJECT buffer TYPE zcl_table_lookup EXPORTING

     i_table_name = ‘MARC’

     i_whole_tab = abap_false.

” The data I want to get back

  buffer->set_val_component( ‘BWTTY’ ).

  buffer->set_val_component( ‘MMSTA’ ).


” The key data

buffer->set_key_val( i_component = ‘MATNR’ i_value = i_matnr )

buffer->set_key_val( i_component = ‘WERKS’ i_value = i_werks ).

” Now look it up.

DATA: BEGIN OF looked_up,

bwtty TYPE bwtty_d,

mmsta TYPE mmsta,

END OF looked up.

buffer->lookup( IMPORTING es_data = looked_up ).

e_bwtty = looked_up-bwtty.

e_mmsta = looed_up-mmsta.

What the class ZCL_TABLE_LOOKUP does is take the supplied components through set_val_component and set_key_val, and constructs two hashed tables (using RTTS) with the key components (in this case, MATNR and WERKS) as key. The first contains data looked up, the second contains data looked up and not found.

After the first lookup, you can’t change the component fields.

If the i_whole_tab parameter is set, then the whole table will be buffered, rather than doing line by line buffering.

A couple of other implementations

I created a BW style look up, that uses the table look up above, and the same interface. It specialises into two further classes – one for looking up InfoObject master data, the other reading from a DSO.

Their constructors take an InfoObject name / DSO name, convert that to the underlying transparent tables, and instantiates a table lookup instance for this table. Oh – and for InfoObjects there’s a flag on the constructor for whether the data is time dependent.

The component setting methods similarly take InfoObject names (instead of field names). The InfoObject names are then converted to field names, and passed to the table lookup instance.

A bit about internals

I’ll concentrate on the TABLE buffer implementation, as it is that which is the engine.


There are two HASHED internal table, both with the same structure of fieldname, value and fieldtype (keyed on fieldname). The field type is simply gained via DD03L, using the table and fieldname.

The val_component (the fields which define which values will be returned) doesn’t populate the value field. Values for the key fields are held as strings.


This method is used for time dependent data.


No buffer tables are created until the first time this method runs. Using RTTS, I build a few table types and references to these a few tables based on those types. The types of these variables, I’ll leave as a exercise for the readers – they’re not difficult to work out

* Add key fields

  LOOP AT me->th_key_fields ASSIGNING <ls_field>.

    ls_component-name = <ls_field>-fieldname.

    ls_component-type ?= cl_abap_tabledescr=>describe_by_name( <ls_field>-fieldtype ).

    APPEND ls_component TO lt_tab_component.

    APPEND ls_component TO lt_ntim_component.

    APPEND <ls_field>-fieldname TO lt_key.


* Time dependent fields

  IF me->s_tim_field IS NOT INITIAL.

    ls_component-name = me->s_tim_field-fieldname.

    ls_component-type ?= cl_abap_tabledescr=>describe_by_name( me->s_tim_field-fieldtype ).

    APPEND ls_component TO lt_tab_component.

    APPEND me->s_tim_field-fieldname TO lt_key.

    ls_component-name = c_index_fld.

    ls_component-type ?= cl_abap_tabledescr=>describe_by_data( sy-tabix ).

    APPEND ls_component TO lt_ntim_component.


* Add value fields for buffer

  LOOP AT me->th_val_fields ASSIGNING <ls_field>.

    ls_component-name = <ls_field>-fieldname.

    ls_component-type ?= cl_abap_tabledescr=>describe_by_name( <ls_field>-fieldtype ).

   READ TABLE lt_tab_component TRANSPORTING NO FIELDS WITH KEY name = ls_component-name.

    IF sy-subrc IS NOT INITIAL.

      APPEND ls_component TO lt_tab_component.


    APPEND ls_component TO lt_val_component.


* Create table structure and types

  lo_tablestruc = cl_abap_structdescr=>create( lt_tab_component ).

  lo_hash_table_type =

           cl_abap_tabledescr=>create( p_line_type  = lo_tablestruc

                                       p_table_kind = cl_abap_tabledescr=>tablekind_hashed

                                       p_unique     = abap_true

                                       p_key        = lt_key ).

  lo_sort_table_type =

           cl_abap_tabledescr=>create( p_line_type  = lo_tablestruc

                                       p_table_kind = cl_abap_tabledescr=>tablekind_sorted

                                       p_unique     = abap_true

                                       p_key        = lt_key ).

* Create “time key” structure and table

  IF me->s_tim_field IS NOT INITIAL.

    DELETE lt_key WHERE name EQ me->s_tim_field-fieldname.

    lo_ntim_struc = cl_abap_structdescr=>create( lt_ntim_component ).

    lo_ntim_table_type =

             cl_abap_tabledescr=>create( p_line_type = lo_ntim_struc

                                         p_table_kind = cl_abap_tabledescr=>tablekind_hashed

                                         p_unique     = abap_true

                                         p_key        = lt_key ).

    CREATE DATA me->ps_ntim_lookup  TYPE HANDLE lo_ntim_struc.

    CREATE DATA me->pth_ntim_lookup TYPE HANDLE lo_ntim_table_type.


* Create value structure types

  me->o_valstruc  = cl_abap_structdescr=>create( lt_val_component ).

* Create pointers to the lookup table, workarea and values

  CREATE DATA me->pth_lookup    TYPE HANDLE lo_hash_table_type.   ” The main buffer

CREATE DATA me->ps_lookup     TYPE HANDLE lo_tablestruc.             ” The key fields in a structure

CREATE DATA me->ps_val        TYPE HANDLE me->o_valstruc.            ” The values being read, in a structure

  CREATE DATA me->pth_lookup_nf TYPE HANDLE lo_hash_table_type.  ” The buffered “not found” values

Then we need to read the data. For a whole table buffer, it’s a simple piece of dynamic SQL. Note how pool tables are handled. It doesn’t actually matter if we get duplicates selected; it’s just less efficient.


          SELECT DISTINCT (me->t_select) FROM (me->table) INTO TABLE <lt_lookup>.

        CATCH cx_sy_dynamic_osql_error cx_sy_open_sql_db INTO lx_error.

         ” Handle the fact that you can’t use DISTINCT with pool tables


              SELECT (me->t_select) FROM (me->table) INTO TABLE <lt_lookup>.

            CATCH cx_sy_dynamic_osql_error cx_sy_open_sql_db INTO lx_error.

              RAISE sql_error. “<—- this really should be a proper class based exception. I’m sorry…



Now, we can actually get data. <ls_lookup> is constructed from ps_lookup, and contains the key values.

* See if the value is already in the table

  READ TABLE <lth_lookup> INTO <ls_lookup> FROM <ls_lookup>.

If it’s there, we’re done. <ls_lookup> with contain the key fields and value fields. Just pass the value fields back to the calling program. If it isn’t there we have to check the <lth_lookup_nf> table (ok, for whole table buffering we don’t need to; we know it’s not found if it isn’t in <lth_lookup>. With line by line buffering, we have to do a single dynamic SQL read. Here, the time dependent reads may come into play.

lt_where = me->get_where_tab( ).


   SELECT (me->t_select) FROM (me->table) INTO xs_lookup WHERE (lt_where) ORDER BY (me->orderby). ” Orderby is only set for time dependence

     IF not time dependent OR date GT date in the key.




CATCH cx_dy_dynamic_osql_error cx_sy_open_sql_db.

   raise SQL_ERROR.


If the data isn’t found, then it’s added to the not found table, otherwise it’s added to the found table.

Simple, isn’t it?


  • With the table name, we can easily get the key fields from DD03L. We still need set_key_val, or we don’t know the values to select against.
  • Put in proper exception handling. It’s pretty dire. You can tell I built this before I understood exception classes well 😳 . But I do now, honest!

Assigned Tags

      You must be Logged on to comment or reply to a post.
      Author's profile photo Jacques Nomssi Nzali
      Jacques Nomssi Nzali

      Hello Matthew,

      thanks for sharing.

      I once read user defined types are not released by the garbage collector. Did you experienced this?



      Author's profile photo Matthew Billingham
      Matthew Billingham
      Blog Post Author

      This code has been running for at least 6 years with some very large buffers, without issue, so I suspect not.

      I've never heard of that being a problem.

      Author's profile photo Otto Gold
      Otto Gold

      Generic ABAP -> security administrator's best friend 😉

      Author's profile photo Matthew Billingham
      Matthew Billingham
      Blog Post Author

      It's ok. All this goes on underneath the security layer.