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.
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
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.
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.
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.
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.
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.