This is a test message to test the length of the message box.
Login
ABAP Quick read table with rfc
Created by Software-Heroes

ABAP Quick - Read table with RFC

Reading in a table via RFC function module is very easy, if you create a specific module for it. Reading any table can be just as easy.

It can sometimes be necessary to read data from another system via distributed landscapes or you want to distribute data from production to the other systems (test, development, etc.). There are several scenarios in which you can save your own function modules, as there are already generic variants for reading tables.

 

Advantages

The advantages of using a generic function modules are obvious:

  • Time and cost savings through no own programming
  • A standard check against the table permissions that protects sensitive data in the system
  • Limitation of data and quantities in Select

 

RFC_READ_TABLE

The classic RFC function module is the RFC_READ_TABLE, since it covers most scenarios in most cases. It has an authorization check, the output fields can be changed in number and sequence. The amount of data returned is 512 characters, minus the column separators needed.

There are many examples of the use of this function module on the Internet, so we will only give a rough idea of its use here. We would like to share with you a qucik tip for creating the Where-Clause table.


DATA:
  lt_opt   TYPE STANDARD TABLE OF rfc_db_opt,
  ls_where TYPE rsds_where.

" Create selection
IF mt_sel IS NOT INITIAL.
  CALL FUNCTION 'AIBZ_FILL_WHERE_CLAUSE'
    EXPORTING
      i_tabname       = md_table
      it_select       = mt_sel
    IMPORTING
      es_where_clause = ls_where.

  lt_opt = ls_where-where_tab.
ENDIF.

 

After filling the selection with the individual restrictions, you can use the table to generate the where condition for the RFC function module. Also very handy when using dynamic selections.

 

Problems

As long as the width of the record is sufficient (512 characters), this is not a problem. But imagine you want to read a table where a column already has 512 characters or more. This is not possible with the function module and only generates an error while reading the data.

In our example, we would like to read IDoc data and verify the content. But the data field SDATA is 1000 characters wide and can not be read with the normal RFC function module. Here we reach the limit of this function module.

 

TABLE_ENTRIES_GET_VIA_RFC

The function module also checks the authorizations when reading the table. The line width is 2048 characters and no separators are used to return the data. However, the complete structure is always returned and you can not restrict the columns.

In addition, the function module has a problem with the conversion of number fields, which ends in a program exception. Therefore, we can only recommend the block conditionally.

 

CRM_CODEX_GET_TABLE_VIA_RFC

It roughly looks like a copy of the function module TABLE_ENTRIES_GET_VIA_RFC, but has been extended with crucial functions. Thus, an offset conversion is performed before the data allocation, which numbers are no longer a problem in the transfer.

For the above example, we have therefore once created a sample code, which also includes the subsequent conversion of the data.


DATA:
  lt_sel    TYPE STANDARD TABLE OF bdsel_stat,
  lt_fields TYPE STANDARD TABLE OF bdi_mfgrp,
  lt_data   TYPE STANDARD TABLE OF bdi_entry,
  ld_subrc  TYPE sysubrc,
  ld_sdata  TYPE edi_sdata.
FIELD-SYMBOLS:
  <ls_data> TYPE edid4,
  <ls_head> TYPE e1fikpf.


" Create selection
APPEND VALUE #( zeile = |DOCNUM EQ '0000000009991234' AND SEGNAM EQ 'E1FIKPF'| ) TO lt_sel.

" Read entries from the table
CALL FUNCTION 'CRM_CODEX_GET_TABLE_VIA_RFC'
  EXPORTING
    tabname             = 'EDID4'
  IMPORTING
    rc                  = ld_subrc
  TABLES
    sel_tab             = lt_sel
    nametab             = lt_fields
    tabentry            = lt_data
  EXCEPTIONS
    internal_error      = 1
    table_has_no_fields = 2
    table_not_activ     = 3
    not_authorized      = 4
    OTHERS              = 5.
IF sy-subrc <> 0.
ENDIF.

" Map line
TRY.
    " Read the first line
    DATA(ld_line) = lt_data[ 1 ]-entry.
    DATA(ls_field) = lt_fields[ fieldname = 'SDATA' ].

    " Map field to structure
    ld_sdata = ld_line ls_field-offset.
    ASSIGN ld_sdata TO <ls_head> CASTING.

  CATCH cx_root.
ENDTRY.

 

We read the header for a FIDCC1 or FIDCC2 and map the line to the data structure. This allows us to check the content of the header and, for example, validate the company code. This works just as well for other data and tables.

 

Conclusion

Reading generic data across systems should not be a problem for you with our little tip. In most cases, use the function module RFC_READ_TABLE because it has the most flexibility. If the requested data line is too big, you can now switch to other function modules. If all else fails, individual development remains for you.


Included topics:
QuickRFCTableRFC_READ_TABLE
Comments (0)

ABAP - ALV still relevant in 2022?

Category - ABAP

Today the joking question, do we still need reports that generate ALV outputs in 2022? In this article, we want to look into this question.

07/01/2022

ABAP in Change

Category - ABAP

The programming language ABAP has been changing for years and is being modernized in various concepts. In this article, we'll look at it in detail.

06/24/2022

ABAP Quick - Clean Core

Category - ABAP

In this article something about Clean Core, what does it mean for the developer, what are the requirements and what do you have to pay attention to.

06/17/2022

ABAP Quick - Processing in a new task

Category - ABAP

This tip is about asynchronous processing in a new process and what to look out for.

01/07/2022

ABAP Quick - Convert JSON to internal

Category - ABAP

In this little tip, we'll go into how you can convert a JSON stream to an internal format and then use it properly.

12/10/2021