After having played around with Elasticsearch for indexing PI payloads and indexing ABAP source code, and especially after seeing Kibana 4, it occurred to me that Elasticsearch would actually be great for business intelligence reporting.

As a proof of concept, I wrote a little extraction program (see below for a link to the source) to read sales data from a development system and export it to Elasticseach. It is very rudimentary and you should of course read the warnings (because it is only a proof of concept after all).

What this demonstrates, however, is how quick and easy it is to do this kind of reporting in Elasticsearch, and in fact to extract the data from SAP. (Elasticsearch really requires zero configuration to get going, as opposed to Apache Solr, which I have used in the past). There are of course many areas for improvement in this solution, one of the important ones being the need to configure the index upfront to set certain fields not to be analyzed. This would be particularly true for the customer name, if you wanted to use that for reporting, or add material description instead of using the code.

Note that it is very tempting to want to normalize the data. There might be valid reasons for that: for example, you may want to change the name of a customer or description of a material on SAP at some stage. However, just for the sake of saving a few MiB of disk space it is really not worth the effort, and you wouldn’t gain any performance advantage from it anyway.

Nonetheless, just to test it out, I set up two little queries with Kibana 4 and made them into a little dashboard showing the value of sales per month and the value of sales by the top 5 materials.

Kibana gives you some very nifty”slice-and-dice” and “drill-down” features. For example, you can select a value (like a slice of the pie chart) or drag-select a certain period of time on the above dashboard, and it will automatically filter the data by that selection.

On the other hand, Kibana gives you rather limited functionality in terms of visualizing the data (e.g. setting labels on pie chart slices does not seem possible) which your users are probably going to demand, but for that you have many options such as building a dashboard with the likes of the D3 javascript library or so. (In fact, there is an Elasticsearch blog post on just this topic). The possibilities are virtually limitless and, with a little elbow grease, you can come up with some great reports.

The source for the extract program, if you are interested, is here: https://gist.github.com/mydoghasworms/1beaf4b8d013fe7ee95a. To test it out, you will need an ECC system with some sales data, and a running Elasticsearch server, which you can easily set up by extracting the downloaded file and installing the service. You will also need to install Kibana 4, which (as opposed to the old Kibana, which ran as a plugin on the Elasticsearch server). If you need help setting it up, please drop me a comment below!

(This article has been adapted from the original here).

Hi Everyone. It has been a long time coming but I am finally posting probably the last custom object framework for a while / ever. This framework was completed back in 2014 for a specific scenario (to create an awesome proxy layer that can call any SPROXY service with dynamic results) and so I am now finally sharing this. If you ever had to create an object with a data ref as an instance variable then create setters and getters for that reference then you might want to take a look at this.

Please take note that i have just copied an old document here and I have not bothered to update it, this is because you can find the most up to date data on the README page of my Git-hub, which is also coincidentally the location you must go to if you want to get the .nugg file which contains all the objects required to use this framework.

Finally the link to Git-hub is here:

lessonteacher/boxed_data · GitHub

And as mentioned i would recommend reading that document instead of this as I have not edited this one further. Hope you enjoy reading and maybe even find the ideas useful.

Boxed Data - Dynamic Programming Wrapper Objects
Note: This page uses syntax provided by the ABAP 7.4 release, for info on that check out the following page ABAP Language News for Release 7.40

The 'Boxed Data Framework' is a set of ABAP objects which are designed to abstract and provide usability for commonly used dynamic programming scenarios in ABAP. The framework provides a number of useful capabilities that can assist with manipulating ABAP types in a generic fashion. This document will provide a very short introduction and then immediately describe the usage.

Introduction

There are a couple of key scenarios where the framework comes in handy. To start, lets imagine the case where we want to have a structure which is stored as an object. This is a relatively common case, the structure itself is abstracted away in the object and it has 'set_attribute(name,value)' or 'get_attribute(name):value' methods. This might then form the base of another set of objects which use this object to store the data internally. Of course the underlying structure can differ per object but the access is always the same through the provided methods.

This pattern is often implemented to allow abstraction of some kind of object or 'Entity' with its own structure that can be used the same way every time. In order to eliminate the requirement to create such a structure, the BoxedStructure was created. The boxed data framework allows for abstraction of any ABAP type. For complex types, the framework provides abstraction of not only the type but also the nested access or dynamic data access in a flexible way which would otherwise be quite irritating.

The following sketch shows the layout of the framework:

Usage - Elements / Basics

The following section will just work through the usages of each boxed type. The entire framework can be found in the ZDATA_WRAPPING package currently. Basic elements such as strings etc will be boxed into a type of zcl_boxed_element.

A boxed type can be constructed as a normal object(note the use of # is abap 7.4)

If the type is not known, the zcl_boxed_packer=>box() method should be used

Of course the types can be boxed directly from the variable.

Note that this will create a copy of the data to box it which is then subsequently accessed through the reference in the object. The meaning of this is that the object will change but the originating variable will remain unchanged.

Printing the values shows the output, note that the boxed data objects have a 'to_string()' method, although some output is a little more useful than others

Finally to illustrate by example, this allows types to be boxed and used in a dynamic way might otherwise be annoying.

The base boxed data object provides common functionality to set and get the values. Note that the types can always be exported to their relevant type or a type of data ref can be returned. In all cases when setting a value the types must be convertable between each other. If the types dont match the set_value() or get_value() methods will always fail.

Usage - Structures

The boxed class for working with structures is zcl_boxed_struct. This class is a subclass of the boxed data base class and contains all the above functionality, however, it also has some more methods specific to structures.

For the purpose of this section the following will be the example structure. It is an address structure with a phone structure inside that.

Once again, the boxed type can be constructed, or it can be packed using the boxed packer. The usual case is the use of the packer as often the types are unknown since that is the real purpose of this framework, however, it is always possible to construct the object directly.

Notice that a cast is used when boxing the data with the packer, this is often required to allow access to the structures additional methods. Such as, the set_attribute() method.

The get_attribute() method returns an attribute as a boxed data type so in the example below, the to_string() method is available.

Both the set_attributes() and get_attributes() methods perform a move-corresponding statement.

Of course it is possible to use the base boxed data get_value() method, which would have actually worked in the above example in place of the get_attributes( ) method, but it is important to understand the distinction. The get_attributes method will move to a structure with corresponding field names whereas the get_value() method shown below requires the exact address_line type.

Note that we have not used the phone structure yet. Working with this structure when embedded in another structure will definitely be more painful than using the basic syntax e.g. 'ls_address-phone-number'. But if you can imagine, if we did not know the types at compile time, this would be an unenjoyable process of 'assign component 'phone' of structure ls_address to <fs_phone>'. Subsequently another assignment would then be needed to 'assign component 'number' of structure <fs_phone> to <fs>'. That is the real power of the Boxed Data Framework. Lets see the comparisons together, notice that we will introduce the resolve_path() method here.

When the type is known there would be no significant value, other than for generic type access, to use a boxed struct here but we see that the path can be expressed using the zcl_box_path syntax in the resolve_path() method. If we imagine that we dont know the actual type(although we do in this case) then with dynamic programming the standard syntax can be punishing (7.4 makes it actually a little neater than before with the inline field-symbol() declaration).

As seen, the resolve_path() method can provide access to the attributes, however, note that the return of this method is a type of the abstract class zcl_boxed_data it is then possible to perform a cast if additional functions of the nested boxed type are required.

Usage - Table Types

Table types can be boxed and obviously that means interacting with them will require some special functionality.The boxed type that is created when working with table types is zcl_boxed_tableset. Working with these objects mean that there are some relative limitations imposed by the framework. For example it is easy natively to work with ABAP table types whereas you need to work through the provided objects such as the zif_boxed_iterator to iterate over a collection of boxed data. Of course the underlying representation of the contents of the boxed tableset is a generic table, which means that key access is preferred, in fact... index access is not provided out of the box for ABAP dynamic tables. It is provided by the framework, however, but it must be understood that indexed retrievals are not as efficient as key retrievals and in some cases where a hashed or sorted table has been boxed an index retrieval could return quite a confusing result.

We will continue to use the structure provided in the above structure examples in order to show the boxing of tables. The below example has a table which is already loaded with addresses.

The boxed tableset objects are created the same way the structures were created in the previous section, either using the tableset object constructor or by using the zcl_boxed_packer object

Looping on a table requires the use of the iterator and its various functions

Note: a cast is required because the next() method returns a boxed data object not a boxed structure. Of course the contents of the table does not have to be structures as line types, so the generic result is required

An alternative is the use of the find() statement which will find and return the first matching result. The condition must be a valid ABAP dynamic table condition, however, the '|' symbols may be used in place of the ''' symbol as it would need to be escaped (though you can use it if you wish).

If more than one result is expected, the find_all() method can be used. It will return a zcl_boxed_tableset object.

Of course we may need to delete entries from our table, the remove() and remove_value() methods perform this function. In either case the underlying line type is used for the deletion, so where remove() takes a boxed data object the remove_value() takes a structure or other type which represents the line type of the table object.

It would be relatively uninteresting if we couldnt find an item by index, so the following example removes index 2.

It is possible to insert() a boxed data object or use insert_value() to insert a structure to a tableset. The following example inserts the structure value, note that currently it either appends or inserts depending on the table type, ie hashed, sorted or standard table.

A boxed structure can be inserted with the insert() method, the following example is identical to the above except that it boxes the structure then inserts it.

Considering the examples provided, it is evident that there is a requirement to be able to get the line type of a table. The get_line() method will return an empty boxed data object that can be used. The below example does this, it requires a cast once again as the line type can be any type in a tableset.

Finally, in the event that the table needs to be cleared, the method clear() is provided.

Usage - Path Resolution
In order to provide even greater access to complex types, and even to be able to generically access dynamic attributes within complex types like structures, the Box Path object and relative syntax was created. Using the resolve_path() method, as seen previously, attributes can be accessed from deeply nested structures, tables and in some cases attributes can be retrieved using the wildcard '*-' prefix.

For the purposes of the discussion the following structure will be used.

The structure is then populated in the following code.

Data can be retrieved using the resolve_path() statement from nested structures. The same syntax is provided as would be seen when accessing the data in ABAP.

Dynamic where conditions can be added to find data that is within tables. Note that the first match is returned and the search for the relevant attributes occurs via a breadth first search.

It is also possible to do a wildcard search by using the '*-' prefix, note that if a table is empty this would not return a value. If the result is not found the result will be not bound.

Note that the above returns the first street number! this is because during the BFS the first field found is the 'number' in the address_line structure. It is important to understand this distinction. To resolve, demonstrating the wildcard further, the path could be extended to apply a more specific relation.

The following is a final example.

Usage - Mappings and Bindings^*

Mappings are currently implemented. Unfortunately I have no examples here to provide. Bindings were an upcomming feature that likely will not ever be complete.

Custom program to Convert Amount from one currency to another currency

As most of the technical consultants know that how to convert the amount from one currency to another currency.

But in this blog I would like to give you a brief overview of calculating accurate Converted amount and Exchange rate values. I Hope It may useful for you while ABAP Coding.

Prerequisites

• Basic knowledge on ABAP.

Technical code explanation:

  1. Initially the input file must contain four mandatory parameters

• Conversion Date
• From Currency
• From Amount
• To Currency (To what currency we would like to convert the input amount)

  2. Output file structure

• Conversion Date
• From Currency
• From Amount
• To Currency
• To Amount
• Exchange Rate

  3. Read data from the input excel file using FM: TEXT_CONVERT_XLS_TO_SAP.

  4. Loop over all the input file records and pass the relevant input values to the standard SAP FM: CONVERT_TO_LOCAL_CURRENCY and consider only          the below output parameters:

• Exchange rate
• Foreign factor
• Local factor

Note: Don’t consider the Converted amount (Local amount) directly from the FM: CONVERT_TO_LOCAL_CURRENCY. Instead there was a small logic to calculate the actual accurate CONVERTED AMOUNT by following the below logic:

*-Below is the logic to determine the Exact values of Conv. amt and Exc. Rate
IF lv_excrate IS NOT INITIAL.
IF lv_excrate GE 0.
lv_excrate_actual = lv_excrate / ( foreign / locfact ).
ELSE.
lv_excrate = lv_excrate * -1.
lv_excrate_actual = ( 1 / lv_excrate ) / ( foreign / locfact ).
ENDIF.

IF lv_excrate_actual NE 0.
converted_amt_actual = lr_ipfile->from_amt * lv_excrate_actual.
ENDIF.
ENDIF.

  5. The above logic is used to calculate accurate Converted Amount and Exchange rate values even the exchange rate was maintained in either of the                below blocks and even the input amount is Negative.

  6. Technical coding part is as shown below, copy and paste the below logic in your systems and try to see the acurate results.

REPORT  zrhramtconversion.

TYPE-POOLS: slis,truxs.
*-Structure declarations
TYPES: BEGIN OF ty_ipfile,
conv_date TYPE char8,
from_curr TYPE fcurr_curr,
from_amt TYPE dec11_4,
to_curr TYPE tcurr_curr,
to_amt TYPE maxbt,
exc_rate TYPE p DECIMALS 5,
message TYPE char255,
END OF ty_ipfile.

DATA:BEGIN OF lt_title OCCURS 2,
title(200),
END OF lt_title.

*-Declarations
DATA: lv_outfile TYPE string,
lv_msg TYPE string.

DATA: lt_ipfile TYPE TABLE OF ty_ipfile,
lv_date TYPE datum,
lt_outfile TYPE TABLE OF ty_ipfile.

DATA: lr_ipfile TYPE REF TO ty_ipfile.

DATA: converted_amt_actual TYPE p DECIMALS 3,
lv_amount TYPE p DECIMALS 3.

DATA: lv_excrate TYPE tkurs,
lv_excrate_actual TYPE ckrate,
foreign TYPE i,
locfact TYPE i,
excratex(8) TYPE p,
fixrate TYPE tcurr-ukurs,
derive TYPE tcurr-kurst.

*-Selection screen
SELECTION-SCREEN BEGIN OF BLOCK rad1
WITH FRAME TITLE title.

PARAMETERS:  p_ipf    LIKE rlgrap-filename OBLIGATORY,  "Input File Path
p_outfl  AS CHECKBOX USER-COMMAND c1,    "Checkbox for output file
p_outf    TYPE string MODIF ID id1.        "Output File Path

SELECTION-SCREEN END OF BLOCK rad1.

INITIALIZATION.
title = text-001.

AT SELECTION-SCREEN OUTPUT.
LOOP AT SCREEN.
IF p_outfl <> 'X'.
CLEAR p_outf.
IF screen-group1  = 'ID1' .
screen-invisible = '1'.
screen-input    = '0'.
screen-output    = '0'.
ENDIF.
MODIFY SCREEN.
ENDIF.
ENDLOOP.

*-Input file F4 Functionality
AT SELECTION-SCREEN ON VALUE-REQUEST FOR p_ipf.
PERFORM fetch_file CHANGING p_ipf.

*-Directory browse for Output file
AT SELECTION-SCREEN ON VALUE-REQUEST FOR p_outf.
*-F4 help for getting directory in which output file should be downloaded
CALL METHOD cl_gui_frontend_services=>directory_browse
CHANGING
selected_folder      = p_outf
EXCEPTIONS
cntl_error          = 1
error_no_gui        = 2
not_supported_by_gui = 3
OTHERS              = 4.
IF sy-subrc <> 0.
MESSAGE ID sy-msgid TYPE sy-msgty NUMBER sy-msgno
WITH sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4.
ENDIF.

START-OF-SELECTION.

IF p_ipf IS NOT INITIAL.
*-Read data from XLS to Internal Table
PERFORM read_file TABLES lt_ipfile USING p_ipf.
ELSE.
MESSAGE text-002 TYPE 'E'.
ENDIF.

*-Loop Input file, Calculate the converted amounts and
*                                Fill the Output file
LOOP AT lt_ipfile REFERENCE INTO lr_ipfile.
CLEAR lv_date.
lv_date = lr_ipfile->conv_date.
CLEAR: sy-msgty,sy-msgid,sy-msgno,
sy-msgv1,sy-msgv2,sy-msgv3,sy-msgv4.

CALL FUNCTION 'CONVERT_TO_LOCAL_CURRENCY'
EXPORTING
date              = lv_date
foreign_amount    = lr_ipfile->from_amt
foreign_currency  = lr_ipfile->from_curr
local_currency    = lr_ipfile->to_curr
rate              = 0
type_of_rate      = 'M'
read_tcurr        = 'X'
IMPORTING
exchange_rate    = lv_excrate
foreign_factor    = foreign
local_amount      = lv_amount
local_factor      = locfact
exchange_ratex    = excratex
fixed_rate        = fixrate
derived_rate_type = derive
EXCEPTIONS
no_rate_found    = 1
overflow          = 2
no_factors_found  = 3
no_spread_found  = 4
derived_2_times  = 5
OTHERS            = 6.

IF sy-subrc = 0.
lr_ipfile->message = text-011.

*-Below is the logic to determine the Exact values of Conv. amt and Exc. Rate
IF lv_excrate IS NOT INITIAL.
IF lv_excrate GE 0.
lv_excrate_actual = lv_excrate / ( foreign / locfact ).
ELSE.
lv_excrate = lv_excrate * -1.
lv_excrate_actual = ( 1 / lv_excrate ) / ( foreign / locfact ).
ENDIF.

IF lv_excrate_actual NE 0.
converted_amt_actual = lr_ipfile->from_amt * lv_excrate_actual.
ENDIF.
ENDIF.

lr_ipfile->to_amt = converted_amt_actual.
lr_ipfile->exc_rate = lv_excrate_actual.

ELSE.

IF lv_date IS INITIAL OR
lr_ipfile->from_amt IS INITIAL OR
lr_ipfile->from_curr IS INITIAL OR
lr_ipfile->to_curr IS INITIAL.
CONCATENATE text-012 text-013 INTO lr_ipfile->message
SEPARATED BY space.
ELSE.

*-Formatting the message to a required format
CALL FUNCTION 'FORMAT_MESSAGE'
EXPORTING
id        = sy-msgid
lang      = sy-langu
no        = sy-msgno
v1        = sy-msgv1
v2        = sy-msgv2
v3        = sy-msgv3
v4        = sy-msgv4
IMPORTING
msg      = lv_msg
EXCEPTIONS
not_found = 1
OTHERS    = 2.
IF sy-subrc <> 0.
*        MESSAGE ID sy-msgid TYPE sy-msgty NUMBER sy-msgno
*                        WITH sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4.
ENDIF.

*-Filling Error message to the Output messages
IF lv_msg IS NOT INITIAL.
CONCATENATE text-012 lv_msg INTO lr_ipfile->message
SEPARATED BY space.
ENDIF.
ENDIF.
ENDIF.

CLEAR: lv_excrate_actual,converted_amt_actual,
lv_excrate,foreign,locfact,lv_msg.
ENDLOOP.

END-OF-SELECTION.
*-Assign updated input file to output file
lt_outfile[] = lt_ipfile[].
IF p_outf IS NOT INITIAL.
*-Output File path
CONCATENATE p_outf text-003 sy-datum sy-uzeit '.xls' INTO lv_outfile.
*-Fill Header for the Output file
PERFORM file_header .
*-Download the Output to Output File
PERFORM download.
ENDIF.

*-ALV Grid Output
PERFORM display.

*&---------------------------------------------------------------------*
*&      Form  FETCH_FILE
*&---------------------------------------------------------------------*
*      text
*----------------------------------------------------------------------*
*      <--P_P_IPF  text
*----------------------------------------------------------------------*
FORM fetch_file  CHANGING p_p_ipf.
CALL FUNCTION 'F4_FILENAME'
IMPORTING
file_name = p_p_ipf.
ENDFORM.                    " FETCH_FILE
*&---------------------------------------------------------------------*
*&      Form  READ_FILE
*&---------------------------------------------------------------------*
*      text
*----------------------------------------------------------------------*
*      -->P_LT_GRANT  text
*      -->P_P_IPF  text
*----------------------------------------------------------------------*
FORM read_file  TABLES  p_lt_ipfile USING  p_ipf.

DATA: ls_truxs TYPE truxs_t_text_data.

CALL FUNCTION 'TEXT_CONVERT_XLS_TO_SAP'
EXPORTING
i_line_header        = 'X'
i_tab_raw_data      = ls_truxs
i_filename          = p_ipf
TABLES
i_tab_converted_data = p_lt_ipfile
EXCEPTIONS
conversion_failed    = 1
OTHERS              = 2.

IF sy-subrc <> 0.
MESSAGE ID sy-msgid TYPE sy-msgty NUMBER sy-msgno
WITH sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4.
ENDIF.

ENDFORM.                    " READ_FILE
*&---------------------------------------------------------------------*
*&      Form  FILE_HEADER
*&---------------------------------------------------------------------*
*      text
*----------------------------------------------------------------------*
*  -->  p1        text
*  <--  p2        text
*----------------------------------------------------------------------*
FORM file_header.
lt_title-title = text-004.
APPEND lt_title.
lt_title-title = text-005.
APPEND lt_title.
lt_title-title = text-006.
APPEND lt_title.
lt_title-title = text-007.
APPEND lt_title.
lt_title-title = text-008.
APPEND lt_title.
lt_title-title = text-009.
APPEND lt_title.
lt_title-title = text-010.
APPEND lt_title.
ENDFORM.                    " FILE_HEADER
*&---------------------------------------------------------------------*
*&      Form  DOWNLOAD
*&---------------------------------------------------------------------*
*      text
*----------------------------------------------------------------------*
*  -->  p1        text
*  <--  p2        text
*----------------------------------------------------------------------*
FORM download.

CALL METHOD cl_gui_frontend_services=>gui_download
EXPORTING
filename                = lv_outfile
filetype                = 'DBF'
write_field_separator  = 'X'
fieldnames              = lt_title[]
CHANGING
data_tab                = lt_outfile[]
EXCEPTIONS
file_write_error        = 1
no_batch                = 2
gui_refuse_filetransfer = 3
invalid_type            = 4
no_authority            = 5
unknown_error          = 6
header_not_allowed      = 7
separator_not_allowed  = 8
filesize_not_allowed    = 9
header_too_long        = 10
dp_error_create        = 11
dp_error_send          = 12
dp_error_write          = 13
unknown_dp_error        = 14
access_denied          = 15
dp_out_of_memory        = 16
disk_full              = 17
dp_timeout              = 18
file_not_found          = 19
dataprovider_exception  = 20
control_flush_error    = 21
not_supported_by_gui    = 22
error_no_gui            = 23
OTHERS                  = 24.
IF sy-subrc <> 0.
MESSAGE ID sy-msgid TYPE sy-msgty NUMBER sy-msgno
WITH sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4.
ENDIF.

ENDFORM.                    " DOWNLOAD
*&---------------------------------------------------------------------*
*&      Form  DISPLAY
*&---------------------------------------------------------------------*
*      text
*----------------------------------------------------------------------*
*  -->  p1        text
*  <--  p2        text
*----------------------------------------------------------------------*
FORM display.

*-Declaration for ALV Grid
DATA : gr_table TYPE REF TO cl_salv_table.
DATA : gr_functions TYPE REF TO cl_salv_functions_list.
DATA : gr_columns TYPE REF TO cl_salv_columns_table,
gr_column  TYPE REF TO cl_salv_column_table.

CLEAR : gr_table.
TRY.
CALL METHOD cl_salv_table=>factory
EXPORTING
list_display = if_salv_c_bool_sap=>false
IMPORTING
r_salv_table = gr_table
CHANGING
t_table      = lt_outfile.
CATCH cx_salv_msg.                "#EC NO_HANDLER
ENDTRY.

IF gr_table IS BOUND.
*-Get functions
gr_functions = gr_table->get_functions( ).

*-Enable Buttons in Tool Bar
gr_functions->set_all( if_salv_c_bool_sap=>true ).

*-Get the columns from table
gr_columns = gr_table->get_columns( ).
IF gr_columns IS BOUND.
gr_columns->set_optimize( if_salv_c_bool_sap=>true ).

CALL METHOD gr_columns->set_column_position
EXPORTING
columnname = 'CONV_DATE'
position  = 1.

CALL METHOD gr_columns->set_column_position
EXPORTING
columnname = 'FROM_CURR'
position  = 2.

CALL METHOD gr_columns->set_column_position
EXPORTING
columnname = 'FROM_AMT'
position  = 3.

CALL METHOD gr_columns->set_column_position
EXPORTING
columnname = 'TO_CURR'
position  = 4.

CALL METHOD gr_columns->set_column_position
EXPORTING
columnname = 'TO_AMT'
position  = 5.

CALL METHOD gr_columns->set_column_position
EXPORTING
columnname = 'EXC_RATE'
position  = 6.

CALL METHOD gr_columns->set_column_position
EXPORTING
columnname = 'MESSAGE'
position  = 7.

TRY.
gr_column ?= gr_columns->get_column( 'CONV_DATE' ).
gr_column->set_short_text( 'Conv. Date' ).
gr_column->set_medium_text( 'Conv. Date' ).
gr_column->set_long_text( 'Conversion date' ).
CATCH cx_salv_not_found.                "#EC NO_HANDLER
ENDTRY.

TRY.
gr_column ?= gr_columns->get_column( 'FROM_CURR' ).
gr_column->set_short_text( 'From Curr' ).
gr_column->set_medium_text( 'From Curr' ).
gr_column->set_long_text( 'From Currency' ).
CATCH cx_salv_not_found.                "#EC NO_HANDLER
ENDTRY.

TRY.
gr_column ?= gr_columns->get_column( 'FROM_AMT' ).
gr_column->set_short_text( 'From Amt' ).
gr_column->set_medium_text( 'From Amt' ).
gr_column->set_long_text( 'From Amount' ).
CATCH cx_salv_not_found.                "#EC NO_HANDLER
ENDTRY.

TRY.
gr_column ?= gr_columns->get_column( 'TO_CURR' ).
gr_column->set_short_text( 'To Curr' ).
gr_column->set_medium_text( 'To Curr' ).
gr_column->set_long_text( 'To Currency' ).
CATCH cx_salv_not_found.              "#EC NO_HANDLER
ENDTRY.

TRY.
gr_column ?= gr_columns->get_column( 'TO_AMT' ).
gr_column->set_short_text( 'To Amt' ).
gr_column->set_medium_text( 'To Amt' ).
gr_column->set_long_text( 'To Amount' ).
CATCH cx_salv_not_found.              "#EC NO_HANDLER
ENDTRY.

TRY.
gr_column ?= gr_columns->get_column( 'EXC_RATE' ).
gr_column->set_short_text( 'Exc. Rate' ).
gr_column->set_medium_text( 'Exc. Rate' ).
gr_column->set_long_text( 'Exchange Rate' ).
CATCH cx_salv_not_found.              "#EC NO_HANDLER
ENDTRY.

TRY.
gr_column ?= gr_columns->get_column( 'MESSAGE' ).
gr_column->set_short_text( 'O/P Msg' ).
gr_column->set_medium_text( 'O/P Msg' ).
gr_column->set_long_text( 'Output Message' ).
CATCH cx_salv_not_found.              "#EC NO_HANDLER
ENDTRY.

ENDIF.

CALL METHOD gr_table->display.
ENDIF.
ENDFORM.                    " DISPLAY

  7. Selection texts:

  8. Text Symbols:

  9. Execution process:

      Go to SE38 and execute the program “ZRHRAMTCONVERSION”.

  10. Provide the Input file path as per required.

        C:\Users\raghub\Desktop\Converstion Folder\Conv_Input_File.xls

  11. Provide the Output file path as per required.

  12. Click on Execute, to see the results

  13. Output Results:

  14. Output file downloaded like this:

  15. Downloaded output file is as shown below:

A long time, I come across the following situation in many projects:

• Copyof transactions: FBL1N, FBL3NandFBL5N;
• CreateunnecessaryZ reports in FI;
• Creating incorrect append (BSEG);

Although there is great material in SDN, enough for a good development, I realize thatthere is alwaysthe same dilemma. Many times I myself was the spreader of it was not possible to include a new field in FB02, for example. SoI decided tocentralizeall thissubject in ablog, and I hopetohelpeveryone!

To make it easierI willseparate thesubjecttopics:

1 - Create new fields in transactions FBLXN

     There are two ways:

• FIBF and EXIT

               Create new product:

              You need copy the FM SAMPLE_INTERFACE_00001650:

               Create new event 1650 for FM (Copy):

               Eachrow processedin reports (FBL1N, FBL3N and FBL5N) will pass throughFM Z.

               The function module has the I_POSTAB parameter that will receive the amounts already filled by the standard.

               Simply fill out thenew field in the parameter E_POSTAB.

               Observation: check with SY-TCODE which transaction it is being processed.

               OR

• BADI:

               Implements the standard definition FI_ITEMS_CH_DATA.

               In CHANGE_ITEMS method simply fill the new field (parameter CT_ITEMS):

               The big difference is that the BTE processing is done line to line and BADI the standard "delivery" all report list.

     The two formsis necessary create the new fields in the structures RFPOS and RFPOSX.         

     You need to runRFPOSXEXTENDviaSE38program (all environments).

     I advise you to include the execution of the program RFPOSXEXTEND in taskof yourrequest.

     ID = R3TR and TYPE = XPRA.

2 - Changedynamic selectionFBLXN

     Yes, it is possible! Don`t worry!

     First step,you must identify thelogical databaseused by thestandardin the transaction.

     Expand the logical database in SE36:

     Choose option: Copy (F7)

     There is only one lock of this procedure is allowed only include some fields tables for each transaction.

     Basically the tables are displayed in the table list in transaction SE36.

     Obs.: Check SAPNote 310886.

     For example FBL1N:

   In this case, the new field it was included in BSIK. Just click on thechosentable.

   Complementingthe issue, you can also includestandardfields thatare not deliveredbydefault.

   It is possible create new box, for example, 04 Test.

   This way you will get a new box of courses in the dynamic selection in the transaction.

   Choose the new field andwhich foldershould be included.

3 - Change screen using coding block

     Thisis the most criticalof allitem, especially because I myselfwasthe propagatorofthis idea was not possible.

     First step. Create new fields in Structure CI_COBL.

     Attention: BSEG activationamong otherimportant tables.

     Transaction OXK3:

     The next steps arecustomizing. 4 basic steps.

     1 - Identify which release keys should display the fields in the transaction. Setting should be made in OB41, enabling the visualization of fields.

     Example: ZZBSEG (Workflow).

     2 - Identify the status-field groups that need to be modified in OBC4 (OB14), determining in ledger account level visualization of the field.

     3 - Identify the types of release, account type and operating class, in the OB32 transaction to determine which types of accounts fields must be displayed.

     4 - Make the setting in the table TCOBX via SM30 to determine the modification group for the field you can modify the field information.                     

     RESTRICTION:   

• In the coding block of the system you can create your own fields.
• The new coding fields can then be used in FI General Ledger accounts, MM Inventory Management and MM Purchasing, and are also updated in the line items created in the Controlling applications.
• The new coding fields cannot be used for account type D or K.
• SAPNote 1607020.

4 - Change functions in transactions FBLXN

     Under construction...

Don’t get too excited about the editable SALV solution out of the box, but I think we have a solution.

Recently Paul Hardy published a blog International Editable SALV day as the 8^th anniversary of the first SALV Editable question and so far no out of the box solution. To those who hasn’t read the previous so many discussion, out of box solution means a single method to make it editable. As of ABAP 740 SP05, there isn’t any new method in SALV OM which does the same thing or at least sounds like SET_EDITABLE.

I developed an work around in November 2008 and got lot of criticism for that. You can see the solution and read the comments - Power of ABAP Objects: Overcome the Restrictions of SALV Model

Based on the comments, customers should never use these type of workarounds. Obviously,  SAP must not use the work around as they say Editable is not intended purpose of SALV OM. But, look what I found >> Standard SAP (yes, standard SAP) has used the almost similar approach to make SALV editable which I used in my solution.

Standard SAP Application

I was replying to some query on CL_SALV_TREE and I did a where used on the adapter object and stumbled upon this function group FOT_RFD_MONI. Usually the adapter is used by only CL_SALV* Classes and my test program. But, suddenly I see a new program popping up in the where used list and that kept me thinking what is this program doing here?

This standard SAP application is developed using this approach – almost same as the approach used in my solution. (Note, that I’m not calling it a workaround anymore ):

• Inherit the class from the Model class
• Create a method in the inherited class to gain access to the Adapter object – E.g. Grid, Fullscreen, Tree
• Gain access of the underlying object – Grid or Tree

Class definition

Class Implementation

Use of method to make Grid editable / non-editable

Redefined Solution

So, based on this design, I simplified my version of the approach. Created a custom class where I have couple of helper methods to gain access to the adapter and then the underlying object – either Grid or Tree.

• GET_GRID would be used to get the CL_GUI_ALV_GRID object
• GET_TREE would be used to get the CL_GUI_ALV_TREE object

Utility Class

To get the CL_GUI_ALV_GRID:

Local class LCL_SALV_MODEL_LIST which is inherited from CL_SALV_MODEL_BASE. Previously, I used the CL_SALV_MODEL_LIST to inherit my helper class, which wouldn't provide me the instance for the TREE. Thus, moved higher in the class hierarchy.

To get the CL_GUI_ALV_TREE:

Updated version of the ON_USER_COMMAND method in the original solution Power of ABAP Objects: Overcome the Restrictions of SALV Model

Questions are ...

These also raises to these questions:

• Is SAP not planning to have SET_EDITABLE method in OM as they have started using this approach?
• Would SAP now provide support if customer uses the same approach and run into issues?
• If no, than how come SAP approved this design to exist it in customer’s system?
• If yes, As you can see, the application was created in somewhere 2011 by SAP. So, the developer must be aware of the existence of my solution. Shouldn't I get at least a some credit? Not that I want, but would be good to have,

Please share your thoughts...

updated on 23-Jun-15 at 8:30 AM CST to add the missing local class

I have long thought about writing a Lisp interpreter in ABAP, after coming across an article by Peter Norvig entitled "(How to Write a (Lisp) Interpreter (in Python))". In that article, he shows how to construct a Lisp interpreter in what amounts to only a few lines of Python. Anthony Hay is someone, also inspired by Norvig's article, who did the same thing in C++ with his article entitled "Lisp interpreter in 90 lines of C++". (In the article he does point out that the 90 lines are for the core of the interpreter, not the built-in functions).

Well, taking the lead of their work, especially getting some insight from Hay, I have built a Lisp interpreter in ABAP now, though obviously it was never going to be in just 90 lines. In fact, doing most things in 90 lines of ABAP or less is somewhat of a Zumutung.

Before looking at the result though, let me give you a little background on Lisp.

Lisp: An executive summary

Lisp, which is an acronym for "LISt Processing", is one of the oldest high-level computer languages, dating back to 1958, with only Fortran being older. You could say that Lisp is the oldest surviving computer language, as (I think) no-one uses Fortran anymore, except perhaps hobbyists. Correction: I have just read up a bit on Fortran and it seems there are still people using it for scientific applications. My apologies, Fortran lovers <3

In spite of being a product of the late 50s, Lisp implemented some way-ahead-of-its-time concepts, some which have started to appear in mainstream languages like Java only recently (the introduction of closures, for example), and some which have yet to make their appearance*(1).

Lisp, which is often regarded as a functional language (though not limited to that) is incredibly powerful and, due to its association with Artificial Intelligence, has been used widely by academia. However, it has found a very loyal following among a large contingency of IT specialists. Today it exists primarily in two dialects: Common Lisp and Scheme.

With the resurgence of interest in functional programming (consider also the recent SCN article on Functional Programming in ABAP), Lisp is getting a lot more attention these days, and this is a good thing.

Here is an example of List code:

(defundouble (x) (* x 2))

This defines a function called "double", which takes one argument, x, which it multiplies by two. (I have to warn you upfront though, that this is Common Lisp, and the Scheme syntax for defining a function, which we will use, is slightly different - read on).

Lisp code consists of parenthesized lists. A function call is constructed of a list in which the first element is the name of the function, and the elements following that are its arguments. In the example above, "defun" is the name of a function that creates a function, the first parameter is the name of the function, the second is a list of the arguments the function will receive, and the last is the body that will be evaluated when the function is called.

To call our function, we would write the following:

(double 7)

which, if it were evaluated, would give us 14. It may seem weird at first, especially when putting mathematical operators at the beginning of an expression, like (* 3 7), but it does become easier as you carry on.

An interesting aspect of Lisp is that code and data are represented in the same way. (Lists are just data after, all). This makes Lisp what is called a "homoiconic" language, and has some interesting implications, namely that if your code can emit data, it can potentially also emit other code, and this is in fact something that people do with Lisp: they write programs that construct other programs*(2).

There are numerous reasons to learn Lisp, and Eric S. Raymond, a well-known open source pundit, makes the following alluring statement:

LISP is worth learning for a different reason — the profound enlightenment experience you will have when you finally get it. That experience will make you a better programmer for the rest of your days, even if you never actually use LISP itself a lot.

A Lisp interpreter in ABAP

Now I will show you the Lisp interpreter I have built in ABAP. It's not exactly a piece of art, more the result of some late-night slogging away at the keyboard, lots of testing and troubleshooting and prayer. It's not coding poetry, but it's functional (if you can excuse the terrible pun), and I think it's pretty cool.

Although Norvig's (and therefore Hay's) interpreters clearly lean toward the Scheme persuasion, I at some point diverged and started using the book "Common Lisp: A Gentle Introduction to Symbolic Computation" as a reference for my implementation, primarily because I changed at one point from representing lists as internal tables of cells to using linked lists (cons cells). This is because, even though there are some performance gains to using tables, e.g. determining the size of a list, I ended up copying parts of tables everywhere, and this leads to greater memory consumption. The result is that I have adopted the Common Lisp approach to some things (e.g. false is represented by nil).

Apart from the pure fun in doing this, the great thing about implementing your own Lisp is that you are not bound to any particular standard. For example, for historical reasons, there are some weird names for functions dealing with lists, such as CAR (which retrieves the first element of a list) and CDR, which returns the remainder of the list, both important constructs. If I wanted, I could rename them HEAD and TAIL (and maybe I will).*(3)

The great thing about creating a Lisp interpreter for ABAP is that now you have an interactive means to write code on your ABAP application server, which opens up all sorts of possibilities. Imagine coding business rules in Lisp, for example.

Trying it out

To try out the interpreter, you will have to download the source from the following GitHub repo and install it on your system: mydoghasworms/abap-lisp · GitHub. By my own convention, the source files starting with 'ZUSR' must go into a type '1' (report) program, and the 'ZLIB' programs into a type 'I' (Include) program*(4). At minimum you will need ZLIB_LISP, which contains the interpreter, and ZUSR_LISP_REPL, which is just a simple REPL (Read-Eval-Print Loop) front-end to the interpreter which consists of s single input and output field. (Sorry, no fancy multi-line inputs and script parsing at this point; hopefully in the future).

When you run ZLIB_LISP_REPL, you will get the following:

Now type in a number in the INPUT field and press Enter. The REPL responds with the number, because that is an expression on its own and a number will just evaluate to itself.

That's not very impressive. Now enter something different, like 'a':

The interpreter responds correctly by telling us that the symbol 'a' is not defined. Let's define it with some value:

(definea 22)

The REPL will respond with the defined symbol, which is 'a'. If you enter 'a' now, it will respond with 22.

Now let's define a function called 'abs' to calculate the absolute value of a number. (I told you earlier that the syntax is somewhat different in Scheme. I wasn't lying):

(defineabs (lambda (n) ((if (> n 0) + -) n)))

The built-in function 'lambda' creates a function which we can call, and by using that as input to the value portion of the built-in 'define' function, we assign a name to it that we can reference later. The body of the function makes use of a few built-in functions, namely 'if', '>' (greater than), '+' (add) and '-' (minus).

Let us try and execute the new function:

(abs -22)

If everything went well, the interpreter should respond with 22.

We could have written the 'abs' function as follows and produced the same result:

(defineabs (lambda (n) (if (< n 0) (- n) n)))

The first way, however, demonstrates an interesting feature: In the first definition of the 'abs' function, the invocation of 'if' evaluates to a function, which is either '+' or '-', that is then subsequently applied to the input, n. This technique of determining the function to call based on some criteria within an expression is a powerful construct, and not something you would necessarily be used to from imperative or object-oriented programming. Needless to say, a transition to Lisp (and functional programming for that matter) involves a big mind-shift.

Let's carry on: here is an example of a recursive function to calculate a factorial:

(definefact (lambda (n) (if (<= n 1) 1 (* n (fact (- n 1))))))

Run it with a few numbers and see what happens. If you run it with 2000, for example, you will probably notice a significant delay. With an input of 3000, you will cause a CX_SY_ARITHMETIC_OVERFLOW exception. (At least I assume that the ABAP kernel manages the same data types consistently across platforms).*(5)

Lastly, let's play around with lists a little. Create a list and assign it to a symbol with the following:

(definemylist (list1234) )

You can check the result by evaluating the symbol 'mylist'. Now, to get the first element of the list:

(car list)

and to get the remainder (i.e. the rest of the list starting after the first element:

(cdr list)

To try out some more examples and see some code showing the interpreter in action, look at the ZUSR_LISP_TESTS program.

A short reference

The following is a short reference of the built-in functions available in the interpreter. Some are available as symbols which map to native procedures which, like the functions you define, can be passed around in expressions. The other list are just symbols that are directly evaluated by the interpreter and by contrast, can not be passed around in expressions*(6).

These are the functions you can use in the current interpreter:

*meaning you can use it as an argument or return-value. I'm not sure what the correct term is

There are also two other built-in values: nil and true. Anything that is not nil can be considered true. nil is essentially the same as an empty list, and this is more of a Common Lisp thing. Scheme also has a true keyword.

Where to from here? (Caution: Rough edges!)

While there is a certain thrill in creating a Fibonacci function and watching it execute, knowing that the code is being parsed, built into an abstract syntax tree and evaluated in ABAP, you quickly grow tired of it. What would make an interpreter like this really useful, is if you can interact with the rest of the system, by accessing the database or particularly consuming classes and function modules. It should be fairly straightforward to extend the list of built-in types in the interpreter and provide a set of built-in functions to achieve this.

At the moment, the interpreter lacks the notion of a string type, as well as other syntactic shortcuts (like prepending a symbol or list with a single quote, which is the shortcut for quoting something without the need to use QUOTE). That is definitely on the list. (Sorry, another bad pun).

There are other aspects to consider, such as the performance. Many applications in functional programming involve making use of recursive functions, and for this reason, many implement what is called "Tail Call Optimization", which eliminates the need for a growing stack*(7). Inherently, this implementation makes use of the stack in ABAP, so perhaps another approach would be to realize the evaluation of functions using other ABAP constructs.

Also, I have not done a lot of negative testing, especially on the parsing side, so don't be surprised if you come across problems. For now I assume all input is valid. (Feel free to raise an issue on the GitHub repo though. It would warm my heart to know that someone is actually playing with this).

Further Reading

Lisp makes an interesting topic of study, and there are many wonderful resources on the internet. I haven't delved so much into all the technical aspects, so I am not going to try and recommend any books I have not read myself. Instead, because I love sensationalism, I have spent a lot of time reading blogs by people who rave about Lisp. One of the best reads I can recommend is an article by Paul Graham entitled "Revenge of the Nerds".

While on the subject of futuristic, ahead-of-their-time languages, I could not finish this article without pointing you to REBOL, a language developed by Carl Sassenrath, one of the brains behind Amiga in the 90s. It's not Lisp, but it embodies some of its spirit. You can almost think of it as "Lisp without the parentheses" (though I'm sure that hardly does it justice; it is probably the best thought-out language on the planet). It does a fantastic job of looking like an ordinary procedural language, but with the power of Lisp. REBOL is not developed so much anymore, but it's spiritual successor, the Red Language is what you need to keep your eye on. If robots ever take over the world, the AI would be written in Red.

*Footnotes

(1) See the link to the Paul Graham article somewhere in this post, where these features are listed.

(2) You have probably done this too before in ABAP if you have used the GENERATE SUBROUTINE POOL statement to generate code on the fly, which is a technique that was used more frequently in the past before the availability of more dynamic statements in ABAP. I can assure you though, that it is very rudimentary compared to what Lisp has to offer.

(3) The explanation is that on the hardware on which Lisp was initially implemented, CAR stood for "Contents of the Address portion of the Register" and CAR stood for "Contents of the Decrement portion of the Register", i.e. references to assembly instructions.

(4) In hindsight, ZBIN would be more applicable to executable programs; it's more Unix-like

(5) It should be noted that the interpreter makes use of the types provided by ABAP, so there is no support for big numbers like in other languages. But in 40 years of SAP, I don't think anyone has complained of not being able to count a gazillion dollars.

(6) I just followed the lead of Norvig and Hay on this. In some cases it is obvious that if the function is independent of context, it is easy to use as a procedure. This may warrant a little closer inspection though.

(7)though admittedly ABAP seems to have no problem with sky-high stacks, probably because an application server is normally configured with a lot of memory.

From time to time the issue of text-symbols usage keeps popping-up in my daily work, so I decided to write a short blog about why I think it is better to avoid using text-symbols as literals in your code.

You have a report / function module / class where you need to use a text that has to be translatable. One way of doing this is to define a text-symbol.

Now the tricky part is that you can define / use a text-symbol in two ways and it will behave differently when you want to change it:

1. You can create a text-symbol by using Goto --> Text elements and reference it in your code via text-ccc(E.g.:text-001)OR
2. You can create a literal, reference the text-symbol via a 3-characters ID and use forward navigation (double click on it) to create the text-symbol (E.g.:l_string = ‘Hello world!’(001))

When you choose the second option to create and reference a text symbol, keep in mind the followings:

• If you modify the literal, you always need to use forward navigation to transfer the new value into the text-symbol. Otherwise, the value in use will be the old one.
  
  E.g.: You change
  l_string = ‘Hello world!’(001) into
  l_string = ‘Hello ABAP!’(001) and you forget to use forward navigation to replace the text-symbol's old value with the new one.
  If you output l_string’s value you will see it’s actually ‘Hello world!’ instead of what you might have expected, that is ‘Hello ABAP!’.
  
  
• If you modify the text-symbols via Goto --> Text elements, the text-symbol will have a value which differs from the literal used in your code. The value that is actually in use is the one from the text-symbol.
  
  E.g.: You go to Goto --> Text elements and you change the value of the text-symbol 001 from ‘Hello world!’ to ‘Hello ABAP!’. In your code, you are still usingl_string = ‘Hello world!’(001).
  If you output l_string’s value you will see it is ‘Hello ABAP!’ which, at a first glance, might seem awkward because in your code you have ‘Hello world!’.

Therefore, in order to avoid a mismatch between the actual value in use (which is always the text-symbol) and the value of the literal, reference text-symbols as text-ccc in your code.