Logical unit of work (LUW) in SAP:

The objective of this document is aimed at explaining the concept of logical unit of work in SAP. I assume that this will be a good read for my fellow readers.

Why logical units of work?

The main purpose of the logical unit of work is to ensure data consistency in the R/3 systems. Let us consider that there is a complex R/3 transaction that involves a series of dialog steps; during the execution of one such dialog step at the middle of the transaction the data involved will lack completeness & will therefore be inconsistent. When talking about of logical unit of work we must note the following points initially.

1. Database LUW also known as DB LUW, each dialog step has its own DB LUW that is used to ensure data consistency.
2. SAP LUW consists of several dialog steps and all the changes to database are written in a single DB LUW. We must note that the database changes are always written in the final database LUW.
3. Therefore to summarize a complex R/3 transaction may span across several dialog steps each having its own DB LUW, however all the changes are written to the database in the final DB LUW of the SAP LUW after a commit work is executed by the system or rolled back with no changes written to the database due to errors.

What is a database LUW?

A database LUW is work unit consisting of database operations (INSERT, UPDATE, MODIFY & DELETE) that it used to make the database changes.  The final database LUW of a SAP LUW is used to make the changes to the database, the changes to the database is not made until after the database commit. The database LUW is executed in a special kind of work process called the update work process.

What is a SAP LUW?

A SAP LUW is a logical unit work that spans over several dialog steps. Let us consider a complex R/3 transaction of n screens; where each screen has its own DB LUW involving database operations and are logically related to each other. It is important that the changes to the database for this complex transaction must be made all at once or it must be rolled back all for the data consistency; that is where the SAP LUW becomes critical in maintaining a logical relationship between several DB LUWs (dialog phases) & making all the changes to the database in the final DB LUW. SAP LUW uses the bundling technique to achieve the same. There are several possibilities of bundling technique and one of them is bundling the database changes using a function module call in the UPDATE TASK.

Bundling in SAP LUW:

A CALL FUNCTION…IN UPDATE TASK is one of the bundling techniques to achieve all the database changes in the last DB LUW of the SAP LUW. The open SQL statements for database changes are placed in the function module instead of placing them in the code, using the addition UPDATE TASK ensures that the function module is not executed until COMMIT WORK is found in the program. At COMMIT WORK the function module calls with UPDATE TASK are executed in a special work process called update work process and the changes to the database is executed in the final DB LUW of the SAP LUW.

R/3 transactions using update function modules.

Let us consider there is one R/3 transaction calling another R/3 transaction and as well as calling some update function module. There is some typical behavior that can be noted for this particular scenario.

• (a)    The called transaction begins in a new SAP LUW in comparison to the calling transaction. It implies that there are two different SAP LUWs now.
• (b)   A new update key is generated for the new SAP LUW that is used to identify all the update function modules.
• (c)    If the called R/3 transaction does not have a COMMIT WORK then the update function modules will not be executed i.e. both the calling transaction & the called transaction must have their own COMMIT WORK.
• (d)   The update function modules are called only after the system has executed a COMMIT WORK.
• (e)   Let us consider there is an importing parameter -IM_X  for the update function module; now the same function module is called at several places in the program like shown below –

DATA: gv_x TYPE i.

gv_x = 1.

CALL FUNCTION UPD_FUNC IN UPDATE TASK

EXPORTING

         IM_X = gv_x.

gv_x = 2.

CALL FUNCTION UPD_FUNC IN UPDATE TASK

EXPORTING

         IM_X = gv_x.

gv_x = 3.

COMMIT WORK.

What will be the value of gv_x at the COMMIT WORK?

No, the value of gv_x will not be 3; when commit is executed by the system the value of gv_x that will be passed is dependent at the point of function call therefore during the first call the value of gv_x will be 1 & during the second call the value of gv_x will be 2.

Introduction

In this blog I want to show you some concepts of a solution for a "Dependency Injection"(DI)-approach which is used in one of my recent projects. It consists of a DI-Framework written in ABAP and an integration-pattern to get the framework working in a large component-based ABAP-application. The DI-framework is custom-made to fit the needs of the chosen design-approach. I will focus on the parts which helps you to organize your DI-container in a component based software design.

I won't give you an introduction to DI but rather explain an implementation approach to fit into the abap world. If you're looking to understand the basics of DI you should read "The issue with having many small classes" and "Dependency Injection for ABAP" or even the wikipedia page for DI would be a good start.

Getting to the requirements

In my recent project I was looking for a flexible solution of managing my OO-instances that build up my applications. While a factory pattern only describes how to design a factory for access by a client, it doesn't describe how the factory should internally manage instances that it produces. Most of the time you will put a lot of "create object" statements into your factory to set up your application. By this your application-"set up" will be fixed.

Also if you follow the SOLID-Principals in your software-design you will soon face problems described in the blog "The issue with having many small classes". You have a lot of small classes and you have to write code for instance-creation and management in your factory-classes. This could become annoying.

Another drawback is that it's hard to reuse your factory since your application-"set up" is fixed and you can't replace certain classes for special purposes.

So the solution is to combine the factory pattern with a DI-framework. The DI-framework handles the instance management and the factory-pattern provides a way to access certain instances. The benfit is, that you keep the framework-code inside the factory and out of your business code. Someone who uses your factory doesn't even have to know about the DI-framework.

So in the end the framework fulfills the following reqirements

• Quick/easy to set up
• Debugging possibilities
• Support for all DDIC-Datatypes
• No dependencies in business code (i.e. not forcing to inherit some class)
• Class creation (with "create object" or factory methods)
• Class configuration (constructor-based or with setter-methods)
• Modularization to match a component based architecture
• Support for "where-used list"
• Replacing classes in a given setup

Quick Example

I will first start to give you a quick introduction into the DI-framework and how the basic usage is.

The following class-diagram shows the setup for the examples ("zif_*" for interfaces; "zcl_*" for classes).

"zcl_service_a" needs some other classes to get its job done. "zcl_persistence_a" implements some kind of database access and "zcl_calulate_a" provides some kind of calculation.

If you want to use "zif_service_a" you first have to instantiate "Persistence A" and "Calculate A". Then you can create "Service A".

The ABAP code would look like this (In ABAP NW740 syntax)

  DATA(lo_persistence) = NEW lcl_persistence_a( ).  DATA(lo_calculate) = NEW lcl_calculate_a( ).  DATA(lo_service) = NEW lcl_service_a(                                        io_pers = lo_persistence                                        io_calc = lo_calculate ).

This is quite simple. You could put that into your factory and you would be fine. But if your component grows and involves more and more classes the task of putting them together gets annoying. Especially if you tend to create small classes.

On the other hand it gets difficult to reuse your setup (the way you put your classes together). If you want to use your service in a slightly different context and want to replace i.e. the calculate-implementation by your own you have to copy the whole factory and replace the line where you create the calculate-instance. Some nicer approach would be to say: "do everything as is, but instead of your calculate implementation take mine".

With the DI framework you would do something like this. In the first step you would create the DI-container:

  " Create DI-Container  DATA(lo_container) = zcl_di_container=>create_instance_default( ).

Then you would register all your classes in the container, so the container has a bulk of classes to work on.

  " Register classes into container  lo_container->register_classname( iv_classname = 'ZCL_SERVICE_A' ).  lo_container->register_classname( iv_classname = 'ZCL_PERSISTENCE_A' ).  lo_container->register_classname( iv_classname = 'ZCL_CALCULATE_A' ).

Now you can query the container to get an instance of your "Service A":

  DATA lo_service TYPE REF TO zif_service_a.  lo_container->get_instance_value(    CHANGING cv_target_value = lo_service ).
" Use your instance
lo_service->do_something( ... ).

The container analyzes the type of the variable "lo_service". Since it is "zif_service_a" the container looks for a registered class that matches this interface. This would be "zcl_service_a". It analyzes the constructor of this class and looks for classes that match the type of the specific parameters. So it will first create instances of "zcl_persistence_a" and "zcl_calculate_a" before it creates an instance of "zcl_service_a". The instance will be copied into the variable "lo_service".

The construction and analyzing process is done recursively and it can detect possible inifinite recursions. You can even use other datatypes on your parameters like int, string, structure or tables, which also have to be registered in the container.

Replacing classes

The code above would be placed into some kind of factory. While the registration code would be placed into the constructor, the querying code would be placed into the factory methods.

CLASS zcl_factory_a IMPLEMENTATION.  METHOD constructor.    ao_container = zcl_di_container=>create_instance_default( ).    ao_container->register_classname( iv_classname = 'ZCL_SERVICE_A' ).    ao_container->register_classname( iv_classname = 'ZCL_PERSISTENCE_A' ).    ao_container->register_classname( iv_classname = 'ZCL_CALCULATE_A' ).  ENDMETHOD.  METHOD get_service_a.    " ** RETURNING VALUE(ro_service_a) TYPE REF TO zif_service_a.    ao_container->get_instance_value( CHANGING cv_target_value = ro_service_a ).  ENDMETHOD.
ENDCLASS.

If you want to replace a specific class you can do it by inheriting the factory-class and register your own implementation. I.e. if you want to replace the implementation "ZCL_SERVICE_A" of interface "ZIF_SERVICE_A" by your own implementation "ZCL_SERVICE_A_BETTER" you can do this:

CLASS lcl_factory_a_better IMPLEMENTATION. " INHERITING FROM zcl_factory_a  METHOD constructor.    super->constructor( ).    ao_container->register_classname( i_var_classname = 'ZCL_SERVICE_A_BETTER' ).  ENDMETHOD.
ENDCLASS.

The container acts like a stack and every new registered datatype or class would be put on top of this stack. If you query for a specific type the container checks for matches from top to bottom. The first match will be returned and used. Since your own class ZCL_SERVICE_A_BETTER is registered last it is on top of the stack. So it will be the first matching type for the interface "zif_service_a" and will be selected. By this way you can replace specific classes.

Debugging

If your container contains a large amount of classes you may want to check if instances are bound to the correct parameters. The di-framework provides a possibility to trace the querying of the container. The trace is rendered into a graph. The following picture shows the graph from the small example above:

You can see that both parameters of the constructor from "zcl_service_a" are bound to the correct classes.

Namespaces

Another concept realized in this DI-framework are namespaces. In an application that consists of different components each component would need its own container. That's because you can't put every class of every component into a single container. This would result in conflicts between different components which implement shared interfaces.

Another option is to use namespaces. Each component uses the same container-data-core but uses a different namespace within this container. The namespaces are isolated from each other so that conflicts are avoided. If you want to use a class of another namespace you can set an alias to the other namespace.

The following example shows the concept of namespaces and aliases.The following class-diagram shows "Service B":

You can see that "Service B" uses "Service A". Furthermore it implements "zif_calculate" which is also implemented by "Service A". The code to set up the DI-container for this scenario would be the following:

  DATA(lo_ctx_data) = NEW zcl_di_context_data( ).

The instance of "lo_ctx_data" is the core of each container. It contains the registered classes and datatypes. If you have different container-instances which share this instance of "lo_ctx_data"  they will all act on the same container data.

If you create a container you can set up a default namespace. If you register classes they will all be placed into the containers default namespace. "Service A" would be set up in the following way:

  DATA(lo_container_a) = /abk/cl_di_container=>create_instance_default(                                       i_var_namespace = 'urn:a'                                       i_obj_context_data = lo_ctx_data ).  " Register classes into container  lo_container_a->register_classname( iv_classname = 'ZCL_SERVICE_A' ).  lo_container_a->register_classname( iv_classname = 'ZCL_PERSISTENCE_A' ).  lo_container_a->register_classname( iv_classname = 'ZCL_CALCULATE_A' ).

"Service B" is set up in the following way. It will reuse the previously created instance  of "lo_ctx_data":

  DATA(lo_container_b) = /abk/cl_di_container=>create_instance_default(                                       i_var_namespace = 'urn:b'                                       i_obj_context_data = lo_ctx_data ).  " Register classes into container  lo_container_b->register_classname( iv_classname = 'ZCL_SERVICE_B' ).  lo_container_b->register_classname( iv_classname = 'ZCL_PERSISTENCE_B' ).  lo_container_b->register_classname( iv_classname = 'ZCL_CALCULATE_B' ).  lo_container_b->register_alias(                                  iv_typename = 'ZIF_SERVICE_A'                                  iv_query_namespace = 'urn:a' ).

If you retrieve "Service B" ...

  DATA lo_service TYPE REF TO zif_service_b.  lo_container_b->get_instance_value( CHANGING cv_target_value = lo_service ).

... you will get an instance constructed like in the following picture:

(Click for a larger image)

You can see two namespaces. "urn:a" for "Service A" and "urn:b" for "Service B". "Service B" has a registered "alias" which connects the two namespaces on the type "zif_service_a". So just the type "zif_service_a" of namespace "urn:a" is visible in namespace "urn:b". So you can see that the namespaces are clearly isolated to each other and the querying and construction is restricted to its namespace unless you set an explicit alias.

DI-Modules

The last concept I want to show are modules. Modules are a descriptive way to set up a container. You can describe five different aspects with a module:

1. Module-Name
2. Default-Namespace
3. Import dependent modules
4. Public module items
5. Container registration

The following code shows an example for a module for "Service A":

CLASS zcl_module_a IMPLEMENTATION.  METHOD zif_di_factory_module~get_modulename.    rv_module_name = 'Service A'.  ENDMETHOD.  METHOD zif_di_factory_module~get_default_namespace.    rv_namespace = 'urn:a'.  ENDMETHOD.  METHOD zif_di_factory_module~register_imports.    " nothing  ENDMETHOD.  METHOD zif_di_factory_module~register_interface.    io_container_mng->register_alias(      iv_typename = 'zif_service_a'      iv_query_namespace = 'urn:a' ).  ENDMETHOD.  METHOD zif_di_factory_module~register_classes.    io_container_mng->register_classname( iv_classname = 'ZCL_SERVICE_A' ).    io_container_mng->register_classname( iv_classname = 'ZCL_PERSISTENCE_A' ).    io_container_mng->register_classname( iv_classname = 'ZCL_CALCULATE_A' ).  ENDMETHOD.
ENDCLASS.

Modules can hold several namespaces. But there is always one namespace that acts as default namespace. Every class or datatype is registered with the default-namespace unless a namespace is explicitly provided on registration.

A module can build a relationship to another module in order to get access to public services (registered classes) provided by the other module. This is done in the "register_import"-Method. I.e. in the previous section "Service B" imports a service from "Service A". In terms of modules this would be setup by a relationship between these modules. So "Service B" would import module "Service A". In the module declaration of "Service B" you would find this method implementation:

  METHOD zif_di_factory_module~register_imports.    io_registry_imports->register_factory_module( NEW zcl_module_a( ) ).  ENDMETHOD.

The method "register_interface" describes which registered types of the module should be public and imported into another namespace once the module is imported elsewhere. The method receives the DI-container of the foreign module and can register aliases into the foreign container. The aliases should point to the modules own namespace. By this namespaces of two modules get connected and dedicated registered types are accessible in the foreign container. So this method describes some sort of public interface of the module.

The final method "register_classes" fills up the own default-namespace with classes and datatypes. Every class and datatype has to be registered there, which should be considered on construction of instances by the DI-framework for this module. Into this method you can also place factory classes which are not DI based. So you don't have to use the feature of importing modules to get access to instances of another components.

If you want to use a module you can do it with this line:

  DATA(lo_container) = zcl_di_factory_generic=>get_instance( io_init_module = NEW zcl_module_b( ) )->get_di_container( ).

Now you can retrieve your instance like shown in the previous examples:

  DATA lo_service TYPE REF TO zif_service_b.  lo_container->get_instance_value( CHANGING cv_target_value = lo_service ).

The benefits of using modules are that ...

• you have a managed way how different components are connected to each other.
• you don't have to care about creating and managing the DI-container.
• every module is only imported once. So if n modules import the same module its content is not registered n times but just once.
• since the module-class is used in a descriptive way, you can dynamicly replace modules.

Finally the DI-implementation provides a code generator which makes module creation a bit easier. So there is a configuration for the SAP "Service Implementation Workbench" (SIW) that can create the module-code and wraps it into a nice factory-class to provide a type-safe access to the DI-container and hiding the DI aspects from users. The SIW generates your factory and module-code and you just have to fill the five module-methods. In the end you have a nice working DI-based factory-class.

Finally

This blog could not handle every aspect of this DI-framework. But I hope I could show you the intended design approach to fit in a large component based application.

Please let me know what you think!

Edit (6.1.2013): Some parts in section DI-Modules

Performance analysis of long running programs in ABAP:

The objective of this blog is to show how to analyze long running programs in ABAP. Customers often complain about some custom reports in ABAP are taking a hell lot of time during the production execution and as a consequence they frequently request to look into the performance killers and the bottlenecks.

Recently, we had a severe performance issue with one such reports in ABAP – a custom report for purchasing contracts. Customer anticipated that the report is running very slow and hence it could not be moved to the production environment. Our team of developers had the job to optimize it. They used the R/3 transaction SAT to understand the bottlenecks and the performance killers.

Starting with SAT:

We have the following report that runs for a long time. The screen-shot of the report is given below

Now we will analyze the performance of this report using the transaction code SAT. Let us run this R/3 transaction, the initial screen of SAT is displayed. Here we are creating a new variant called PERFO_VAR that will contain all the restrictions for the performance measurement.

The variant will have the following characteristics to measure the performance –

1.     Choose Per Call Position radio-button – This implies that it enables call per aggregation. This option is generally used for performance trace.

  The Statements tab will look like the screen-shot below:

After the creation of the variant; we will start the measurement of the transaction. Please see the screen-shot.

Once the measurement is finished; we will go to the evaluate tab to see the results & analyze. W.r.t performance analysis it is best to use the tools – Hit List & Profile to analyze the performance killers.

If we look closely at the Hit List ALV, we can see which entries took most of the time. The entry 1 consumed 79.65% of the net time. The entry 2 consumed 15.93% of the net time.  The entry 3 consumed 4.21% of the net time. Hence the first 3 entries sum up to 99.79% of the net time. We will have a detailed look at these 3 entries to understand why they took so much time. One important thing to note at this point in time is that we are mostly interested in the net time; the net time is the time spent on the specific modularization unit; whereas gross time is the total time spent on the lower level modularization units.

Example:

Perform f_send_files

   -> the net time = 0.05%; time spent spent to call the subroutine (considering this specific modularization unit only).

   -> the Gross time = 95.64;   time spent to call all the related lower level modularization units.

Thanks to Thomas Zloch for correcting...:)

Detailed Analysis with SAT:

Now in the Hit List, when we double click on the 1st entry; we navigate to the code & oops this what we see –

Now in the Hit List, when we double click on the 2nd entry; we navigate to the code & oops this what we see –

Now in the Hit List, when we double click on the 3rd entry; we navigate to the code & oops this what we see –

Therefore it is clear that WAIT/SLEEP& WAIT for RFC takes the most of the time in report. They are the major performance killers.

Conclusion:

SAT is a very useful transaction to do the following things –

1.       Performance Analysis.

2.       ABAP Trace Analysis

3.       Trace Parallel process

4.       User Trace.

It is an extension of commonly used SE30. It is more sophisticated tool & very useful for analyzing production performance issues quickly & neatly.

ANST – also known as the Automated Notes Search Tool, is a powerful application that searches SAP notes for a specific problem based on the issue in your system.

The tool is available if you have upgraded your system to one of the following SAP basis support packages (seeKnowledge Base Article 1818192):

Software Component Release Package name

  ________________________________________________________________________

SAP Basis component

SAP_BASIS 700 SAPKB70028

SAP_BASIS 701 SAPKB70113

SAP_BASIS 702 SAPKB70213

SAP_BASIS 731 SAPKB73106

The transaction to start the tool is named ANST_SEARCH_TOOL.

NEW! By following the instructions in note 1915529, you can utilizethe shorter transaction ANST.  The functionality is exactly the same as ANST_SEARCH_TOOL, but the shorter transaction name makes it more convenient.

We have been sharing the news about this great tool through multiple channels.

SCN Blogs

Our Newest blog shows how ANST can help you solve billing problems.  A special thanks to Tobias Dolgener for sharing.

http://scn.sap.com/community/erp/sd/billing/blog/2013/12/06/the-power-of-tools--how-anst-can-help-you-to-solve-problems-yourself

Have an idea for new features or functionalities? Drop a comment in the following blog!

http://scn.sap.com/community/software-support-and-maintenance/blog/2013/09/10/the-future-of-sap-automated-note-search-tool

Demos/Training

We have a training system set up for you to learn how to use the tool. 

Access with S-user ID here

Videos

Here’s an ECC example, where a note to solve a problem is found in less than 2 minutes

User Groups/Events

Most recently, we have been presenting to various global user groups to help spread the word about the Automated Notes Search Tool.

Here are just some of the locations that we have presented. (Photos added if available)

Christoph Haberl presented ANST to DSAG Vienna.

Arvin Chiu presented at  the ASUG British Columbia chapter meeting

Miguel Alfaro  and Lloyd Goveia presented at the ASUG Ontario chapter meeting.

Mark Richardson blogged about it on SCN.  Thanks Mark!

Felipe Fonseca and Tomas Black presented at the Grand Opening event in Sao Leopaldo, Brazil

Carlos Martinez Escribano  presented to the AUSAPE (Spain SAP User Group)

Preetpal Singh presented at SAP TechEd in Bangalore. 

Enterprise Support Academy

For those of you interested in a more personal approach, we have Meet the Expert sessions on the Automated Notes Search Tool scheduled through the SAP Enterprise Support Academy.  You can register for a session (s-user ID login required) here

Upon entering the site, type in Automated in the search box and you will find the session information.

Here is the current schedule:

 
22.01.2014 16:00 - 17:00 CET (CET) EMEA English

22.01.2014 10:00 - 11:00 CET (CET) EMEA German   

Select the one that’s best for you and register to learn more.  These Meet the Expert sessions are all recorded, so if you can't make the date, look in the replay library!

Social Media

SAP Product Support is on Twitter and Facebook! 

Stay connected with us via our 2 Twitter channels:

http://twitter.com/SAPSupportCE and http://twitter.com/SAP_Gsupport

Like us on Facebook at http://facebook.com/sapproductsupport

Customers Spreading the Word

Nicolas Busson  started using the tool and has been kind enough to share his thoughts on it with the community on SCN.  Thanks Nicolas!

In the Business Trends 2013 wrap up, Somnath Manna  shares how the ANST is a hidden gem for any SAP functional consultant.  Very true!

Recap

There is a plethora of information available to help you start using the Automated Notes Search Tool, and SAP Product Support has experts that can help you along the way. 

Are you using ANST? Add a comment below and tell us about your experience with it.

If not, what’s stopping you?  We want to know!

Object Oriented ABAP is taking slow phase in adoption for Pure ABAPers(Not working in Webdynpro or other object oriented space); even I took a yearlong to completely do my work in OO.

Even I was in a situation when one of my clients questioned, why you code in OO as he was not able to understand. I was dumbstruck and the thought provoked me to write this for guys who are in dilemma on how to move to OO.

I have seen many blogs on ABAP OO which will be a good start for learning (explaining concepts and examples) but still faced few challenges in moving to ABAP OO like where and how to start, just putting down my thoughts about the problems which faced little longer and ways I overcame

Few road blocks in using ABAP OO

o    Understanding concepts of OO who has no previous knowledge on OO

o    How to implement the same in our regular work in RICEF objects.

o    How to use major advantages of OO

This blog is for experienced developers, who are familiar with OO concepts but lazy in implementing the same in ABAP. Before I talk about any of these stuff, I would like to tell how to get familiarize with classes. (Note: This blog only provides approach and not any examples)

For newbies to ABAP OO, can get familiarize with these links?

http://help.sap.com/saphelp_nw2004s/helpdata/en/c3/225b5654f411d194a60000e8353423/frameset.htm

http://wiki.scn.sap.com/wiki/display/ABAP/ABAP+Objects+Getting+Started

I will show a small example report getting some entries from MARA and using CL_SALV_TABLE to display the same in ALV in four ways here

·         Traditional way of writing

·         OO way (only using Static methods) – To get the hang of class and method concept

·         OO way (Only Instance methods) – To get the hang of class and method concept

·         My IDEAL way in OO

·         New Trend of and completely moving your report to OO.

Traditional way of writing the code:

REPORT  ysdnblog_classic.
PARAMETERS : p_rows TYPE count DEFAULT '100'.
START-OF-SELECTION.
  DATA : it_mara TYPE STANDARD TABLE OF mara.
  PERFORM get_data CHANGING it_mara.
  PERFORM display USING it_mara.
*&---------------------------------------------------------------------*
*&      Form  GET_DATA
*&---------------------------------------------------------------------*
FORM get_data  CHANGING ch_mara TYPE mara_tt.
  SELECT * FROM mara INTO TABLE ch_mara  UP TO p_rows ROWS .
ENDFORM.                    " GET_DATA
*&---------------------------------------------------------------------*
*&      Form  DISPLAY
*&---------------------------------------------------------------------*
FORM display  USING    i_mara TYPE mara_tt.
  DATA : lr_table TYPE REF TO cl_salv_table.
  cl_salv_table=>factory(  IMPORTING    r_salv_table   = lr_table
                           CHANGING     t_table        =   i_mara )    .
  lr_table->display( ).
ENDFORM.                    " DISPLAY

OO way (only using Static methods) – To get the hang of class and method concept

Let’s start with classes and don’t go in to boring part of explaining what is a STATIC or INSTANCE method (Please google or go through about this stuff). Major developers who are new to OO, first question is whether my method should be INSTANCE or STATIC? Let’s save this question to the last.

First to get the hang of the OO ABAP from traditional ABAP using STATIC methods only and above report looks like this: (suggest continuing writing couple of reports/objects)

REPORT  ysdnblog_class_static.
PARAMETERS : p_rows TYPE count DEFAULT '100'.
*----------------------------------------------------------------------*
*       CLASS lcl_main DEFINITION
*----------------------------------------------------------------------*
*
*----------------------------------------------------------------------*
CLASS lcl_main DEFINITION.
  PUBLIC SECTION.
    CLASS-METHODS : get_data  ,
                    display.
  PRIVATE SECTION.
    CLASS-DATA it_mara TYPE mara_tt.
ENDCLASS.                    "lcl_main DEFINITION
*----------------------------------------------------------------------*
*       CLASS lcl_main IMPLEMENTATION
*----------------------------------------------------------------------*
*
*----------------------------------------------------------------------*
CLASS lcl_main IMPLEMENTATION.
  METHOD get_data.
    SELECT * FROM mara INTO TABLE lcl_main=>it_mara  UP TO p_rows ROWS .
  ENDMETHOD.                    "GET_DATA
  METHOD display.
    DATA : lr_table TYPE REF TO cl_salv_table.
    cl_salv_table=>factory(  IMPORTING    r_salv_table   = lr_table
                             CHANGING     t_table        =   lcl_main=>it_mara  )    .
    lr_table->display( ).
  ENDMETHOD.                    "display
ENDCLASS.                    "lcl_main IMPLEMENTATION

START-OF-SELECTION.

  lcl_main=>get_data( ).

  lcl_main=>display( ).

OK... I hope by now you got hang of what a traditional report looks in CLASS/METHODS.

OO way (Only Instance methods) – To get the hang of class and method concept

What’s next? Let’s see the same program with instance methods. Additional steps would be declaration of an object and instantiate it to use in your program.

REPORT  ysdnblog_class_instance.
PARAMETERS : p_rows TYPE count DEFAULT '100'.
*----------------------------------------------------------------------*
*       CLASS lcl_main DEFINITION
*----------------------------------------------------------------------*
CLASS lcl_main DEFINITION.
  PUBLIC SECTION.
    METHODS :   get_data  ,
                display.
  PRIVATE SECTION.
    DATA it_mara TYPE mara_tt.
ENDCLASS.                    "lcl_main DEFINITION
*----------------------------------------------------------------------*
*       CLASS lcl_main IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS lcl_main IMPLEMENTATION.
  METHOD get_data.
    SELECT * FROM mara INTO TABLE me->it_mara  UP TO P_rows ROWS .
  ENDMETHOD.                    "GET_DATA
  METHOD display.
    DATA : lr_table TYPE REF TO cl_salv_table.
    cl_salv_table=>factory(  IMPORTING    r_salv_table   = lr_table
                             CHANGING     t_table        =   me->it_mara  )    .
    lr_table->display( ).
  ENDMETHOD.                    "display
ENDCLASS.                    "lcl_main IMPLEMENTATION

START-OF-SELECTION.

data : lr_main TYPE REF TO lcl_main.

create OBJECT lr_main.
  lr_main->get_data( ).
  lr_main->display( ).

In the above example we declare an object reference of type LCL_MAIN and have to command CREATE OBJECT to create a reference for further usage of the same in program. (The same LCL_MAIN can be declared with different names (many references) and initiated based on the requirement needs)

Please do some live programs either using with any of the above ways to really get initial kick start of OO.

My IDEAL way in OO

MY IDEAL way of writing the above program would be as below.

REPORT  ysdnblog_class_ideal.
parameters : p_rows type count default '100'.
*----------------------------------------------------------------------*
*       CLASS lcl_main DEFINITION
*----------------------------------------------------------------------*
CLASS lcl_main DEFINITION.
  PUBLIC SECTION.
    CLASS-METHODS : start.
  PRIVATE SECTION.
    METHODS : get_data  ,
              display.
    CLASS-DATA : lr_main TYPE REF TO lcl_main.
    DATA it_mara TYPE mara_tt.
ENDCLASS.                    "lcl_main DEFINITION
*----------------------------------------------------------------------*
*       CLASS lcl_main IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS lcl_main IMPLEMENTATION.
  METHOD start.
    CREATE OBJECT lr_main.
    lr_main->get_data( ).
    lr_main->display( ).
  ENDMETHOD.                    "start
  METHOD get_data.
    SELECT * FROM mara INTO TABLE me->it_mara  UP TO P_rows ROWS .
  ENDMETHOD.                    "GET_DATA
  METHOD display.
    DATA : lr_table TYPE REF TO cl_salv_table.
    cl_salv_table=>factory(  IMPORTING    r_salv_table   = lr_table
    CHANGING     t_table        =   me->it_mara  )    .
    lr_table->display( ).
  ENDMETHOD.                    "display
ENDCLASS.                    "lcl_main IMPLEMENTATION

START-OF-SELECTION.

  lcl_main=>start( ).

Here we call the START method only once for a program and so I made it as a static method and one static object (LR_MAIN referencing the same class ) for dealing with rest of the business logic.  (There can be many better ways as well.. )

New Trend of and completely moving your report to OO:

The new way of writing the reports includes t-code to launch your report. Let’s start with T-code creation as below and select 3^rd option METHOD OF A CLASS (OO TRANSACTION).

Next step navigates to below screen and un check the box OO TRANSACTION MODEL enabling another field LOCAL IN PROGRAM

Now provide your program name and local class name and method for the below program. Program looks like below

REPORT  ysdnblog_class_new.

SELECTION-SCREEN : BEGIN OF SCREEN 200.
PARAMETERS p_rows TYPE count DEFAULT '100'.
SELECTION-SCREEN : END OF SCREEN 200.

*----------------------------------------------------------------------*
*       CLASS lcl_main DEFINITION
*----------------------------------------------------------------------*
CLASS lcl_main DEFINITION.
  PUBLIC SECTION.
    CLASS-METHODS : start.

  PRIVATE SECTION.
    METHODS : get_data  ,
              display.
    CLASS-DATA : lr_main TYPE REF TO lcl_main.
    DATA it_mara TYPE mara_tt.
ENDCLASS.                    "lcl_main DEFINITION
*----------------------------------------------------------------------*
*       CLASS lcl_main IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS lcl_main IMPLEMENTATION.
  METHOD start.
BREAK-POINT.
    CALL SELECTION-SCREEN 200.
    IF sy-subrc IS INITIAL.

      CREATE OBJECT lr_main.
      lr_main->get_data( ).
      lr_main->display( ).
    ENDIF.

  ENDMETHOD.                    "start
  METHOD get_data.
    SELECT * FROM mara INTO TABLE me->it_mara  UP TO p_rows ROWS .
  ENDMETHOD.                    "GET_DATA
  METHOD display.
    DATA : lr_table TYPE REF TO cl_salv_table.
    cl_salv_table=>factory(  IMPORTING    r_salv_table   = lr_table
    CHANGING     t_table        =   me->it_mara  )    .
    lr_table->display( ).
  ENDMETHOD.                    "display
ENDCLASS.                    "lcl_main IMPLEMENTATION

START-OF-SELECTION.

  lcl_main=>start( ).

Here you are taking control on when your selection screen should trigger. Things you need to observe in above program

·         Your selection screen is defined as  a screen with a different number, which is 200

·         You are explicitly triggering your selection screen 200 in the START method rather than giving control to framework. (Note the other events AT SELECTION SCREEN will work as usual.)

·         When the transaction is executed; first it triggers the method specified in the transaction

By slowly adapting to above approached you can change your coding style to OO.

There can be many other ways and this is just little knowledge sharing based on my experience. Comments and suggestions are welcome.

A not too long time ago...

I had detailed in previous blog about creating a tool to analyze the source code, or the best solution, using the ATC (Abap Test Cockpit).
I mentioned about the quality and wisdom of the team of programmers that grew up.

But what's the point of having an automatic verification code? What are the gains and benefits? And the worst?

Here in the company, we allocated 2 programmers to do this activity. They were checking the code, line by line, following our standard document.
When non conformities were found it was returned by mail to the developer to proceed with the correction: Much work, numerous requests daily, many similar errors, complex routines to analyze... Add to that the worst question of all: dealing with people. Identify errors and point it in source code is like to speak ill of the mother of the programmer. The human factor was the main cause of failure in this process because not all errors will be identified and not all errors identified will be corrected or treated. Yes, It is true!

Automating these validations reduces the human factor. There are no arguments against the machine... is 0 or 1. If not corrected it will stay there. The error has to be, at least, properly argued to be considered a false positive and "accepted"  by an approver.

Important to mention that the static validation does not identify 100% of the logic and performance problems . Rather, it is almost 0. To do this validation, the tests are crucial, better doing automated tests.  But it can identify points that cause crashes, dumps into production, so with praise. And this is the focus: No dumps into production, who is allocated in support can be allocated to to improve the system.

The image above shows month by month - from March to November 2013 - how transport request was handled with automatic release.

• Green   - no problems, all right - released by request owner
• Yellow  - False positive - released by an approver
• Red      - Urgent or no time to correct releases, authorized by boss - released by an approver
  

Approvers had a lot of work but it was decreasingly month by month. We analysed yellow request to create/change our patterns or to create rules to turn it in green requests. But the main focus was to reduce the red requests number.

The developer and support teams did not accept well the solution. The big problem: change past codes. It is impossible to change old codes without test all scenarios and without automated tests. Then we adjusted the solution to skip the verification on old codes when support team creates the request and only check modified code. But the developer team must have to change old codes when they changed an old program and have to test it all. Of course, case by case was analysed to did not delay the delivery of a project.

Attention to yellow requests: it appears only once. When we registered an approval the validation don't show it anymore in the future.

Other good effect was the lower number of dumps in production.

We advanced some steps and for the next year (2014) we will do it better using ATC and others SAP standard tools.

And parallel with this initiative we started the ABAP DOJO meetings, but it will be a topic for another blog...

Yesterday we had an issue on an SAP implementation. I was sure that it was a standard error, because in other implementation the functionality works perfectly.

On Twitter Nicolas Busson reminded me that ANST can save your life quickly and easily

This video is the live implementation of the OSS Note using ANST.

What help.sap.com doesn't tell us

I thought, SAP is pretty clear in what they tell us about the _SCOPE-parameter that can be passed to every enqueue-function modul.

The parameter can have 3 values, which means, according to help.sap.com:

Meaning of the _SCOPE Values

_SCOPE Parameter (SAP Library - Architecture Manual)

The most interesting statement is the description for _SCOPE = 2. It says that the lock is released when the update transaction is complete.

So I understood that COMMIT WORK will implicitly release the lock. As I found out, it is not necessarily the case.

The test report

Consider the following test report.

The report is going to request a lock for an ABAP report. The lock argument is '1' as a dummy value. Keep in mind, that Z_UPDATE_TASK_DUMMY is an update function module that has no execution logic in my case.

DATA lt_enq TYPE TABLE OF seqg3.
FIELD-SYMBOLS <ls_enq> TYPE seqg3.
PARAMETERS pa_upd TYPE abap_bool AS CHECKBOX.
CALL FUNCTION 'ENQUEUE_ES_PROG'   EXPORTING     name           = '1'     _scope         = '2'   EXCEPTIONS     foreign_lock   = 1     system_failure = 2     OTHERS         = 3.
IF sy-subrc <> 0.   MESSAGE ID sy-msgid TYPE sy-msgty NUMBER sy-msgno WITH sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4.
ENDIF.
IF pa_upd = abap_true.   CALL FUNCTION 'Z_UPDATE_TASK_DUMMY' IN UPDATE TASK.
ENDIF.
COMMIT WORK AND WAIT.
CALL FUNCTION 'ENQUEUE_READ'   EXPORTING     gclient               = sy-mandt     guname                = sy-uname   TABLES     enq                   = lt_enq   EXCEPTIONS     communication_failure = 1     system_failure        = 2     OTHERS                = 3.
IF sy-subrc <> 0.   MESSAGE ID sy-msgid TYPE sy-msgty NUMBER sy-msgno WITH sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4.
ELSE.   IF lt_enq IS INITIAL.     WRITE 'No locks existing'.   ELSE.     LOOP AT lt_enq ASSIGNING <ls_enq>.       WRITE: <ls_enq>-gname,               <ls_enq>-garg,               <ls_enq>-gmode.       NEW-LINE.     ENDLOOP.   ENDIF.
ENDIF.

The report offers a parameter PA_UPD to the user. If checked, the update function module will be called. If not checked, there is no update task registered. Afterwards, COMMIT WORK AND WAIT is always triggered.

In the end, the report shows any locks that the current user has.

The ugly truth

If the report is called with the enabled checkbox, the dummy function module will be called. In the end, all locks are released.

If the report should not execute any update function module (checkbox is deactivated), the locks are not released at all. COMMIT WORK AND WAIT has no influence here as there is no update task registered. I also included the output of SM12 in the screenshot.

The moral of the story

Locks of the update owner are not necessarily released, when COMMIT WORK has been called. It depends on wether or not an update task has been called at all. help.sap.com is not wrong with the description about _SCOPE = 2, however, someone who reads the description might get a wrong idea of how ABAP works in this very case. It took me some time to figure out what happens here. So I hope this blog post helps other developers saving some time.

This document details the procedure in using Microsoft Word as editor in SAP Script / Smart Forms.

In normal case, when you try opening the editor in Smart Forms, the following editor would appear:

Click on the editor button. The following editor appears:

Now to change the above editor to MS Word, do the following:

Go to transaction I18N (Internationalization).

Click on I18N Menu ->I18N Customizing ->I18N System Configuration (as shown in the screenshot

The following screen appears:

If you would like to use MS Word Editor in both Script and Smartforms, then check the both checkboxes

as shown below:

Click on Activate.

The following popup appears (related to SAPScript Editor):

Click on Yes. Now the following popup appears (related to Smartforms Editor):

Click on Yes to proceed.

Now the MS Word editor is available for both SAP Script and Smartforms.

Result: In the SmartForms:

In SAP Script:

You can anytime revert to old editor by deactivation MS Word editor option using the transaction I18N.

   Since SAP introduced Enhancement Package concept it is possible to switch business functions on anytime in a Netweaver system and for some cases it is possible to switch them off without downtime window via transaction SFW5.

  However sometimes activation process does not succeed and it is necessary to investigate what went wrong. For such scenarios it is sometimes complicated to get the root cause because this procedure involves Data Dictionary objects, ABAP programs, BC-Sets and others.

Checking for SAP Notes now we have an excellent documentation created by SAP Development team which we can understand how to check and how to evaluate each scenario.

1909425 - SFW- Activation error in Dictionary: clear up the inconsistencies

This documentation is not only a guide how to troubleshoot issues related to Business Function activation process, but a small training content where we can learn a lot. By check its information now it is much more easier to understand where issues is and how to identify a solution for this.

For instance, if you find inconsistencies related to BC-Sets objects in the system you can easily identify it via SFW_BROWSER transaction

I really encourage you to reserve few minutes to read this documentation.

Hello ,

I am posting this blog to list out my findings of the possibility of Connecting to a server enabled with  SFTP from a Abap program.

I have been given this requirement from my company that i create a report and transfer it to a server which has been changed from normal FTP to SFTP.

In my previous blogs i have already listed the process of using Function Modules to transfer using normal FTP.

I hope this blog helps people understand the limitations of sap abap in using sftp

SAP ABAP has the Functionality to write/Read on FTP server, but there is no functionality in ABAP to read /Write on SFTP server. The code will not work with SFTP server .

Please refer to  SAP Note 795131 - FAQ: How to make Secure FTP communication with SAPFTP.

SAP recommendations

Sap’s recommendation to read/write to SFTP server is by using PI (Process Integration) solution.

Option 1

Server side scripting commands to write to SFTP server from SAP Application Server with the help of an open Source FTP client (WinSCP).I was able to write the script for this in a notepad .

code.

option batch abort

option confirm off

open sftp://username:password@192:192:192:192:9952   { where 192.192.192.192 is the server address and 9952 is the port number }

put F:\check.txt  { This is a local file i created that can be transferred to check the put statement}

close

exit

Note : If you want to test this code above please install WinSCP and open Winscp.com . Type the code step by step and you will connect and put the file.

The challenge here was that i replicate this using External Commands in SM69 in SAP .So i got to it but the issue here was our system needed some upgrades from a Basis point of view where enabling of External Commands was possible. This is how far i got .

Note : If any one who reads this blog has implemented External Commands from SAP to transfer SFTP please share .

Option 2

Secure File Transfer Protocol (SFTP) can be achieved using SSH (Secure Socket Shell

The flow of the data goes as follows:

1. Firstly the SSH (client local/daemon local) is configured as per the Vendors instructions.
2. The SSH client is installed to the client system while the SSH daemon is installed to the FTP server.
3. The data is sent from SAPFTP to the local port of the SSH client and this makes the data secure (encrypts the data).
4. Then the SSH client sends this data to the SSH server daemon which decrypts the data and forwards the data to the FTP server.

SSH can be configured for both Active and Passive mode of FTP communication.

Conclusion

There is no straight forward method to transfer to a SFTP server .

Thank you .

Please do post comments and feedback to help me improve my content.

Hello all ,

I have developed a program that will combine several spool request that are otf and create a single PDF . This PDF is then transferred to the desktop . If you want to transfer this file using FTP please refer to my other blogs .

This is a working program and if you run it with multiple spool number which are otf it will create a single PDF .

Thank you

******************************************

*&---------------------------------------------------------------------*
*& Report  Z_COMBINE_SPOOL_REQUESTS
*&
*&---------------------------------------------------------------------*
*&
*&
*&---------------------------------------------------------------------*

REPORT  z_combine_spool_requests.

TYPES: BEGIN OF blob,
        line(80) TYPE x,
        END OF blob.

*** PDF conversion Declaration .
DATA: pdf_size      TYPE so_obj_len,
       pdf_content   TYPE solix_tab,
       pdf_xstring   TYPE xstring,
       v_xstring     TYPE xstring,
       v_text        TYPE localfile,
       rq            TYPE tsp01,
       bin_size      TYPE i,
       temp_bin_size TYPE i,
       dummy         TYPE TABLE OF rspoattr,
       cancel,
       doctab LIKE docs OCCURS 1 WITH HEADER LINE,
       numbytes TYPE i,
       arc_idx LIKE toa_dara,
       pdfspoolid LIKE tsp01-rqident,
       jobname LIKE tbtcjob-jobname,
       jobcount LIKE tbtcjob-jobcount,
       is_otf,
       client LIKE tst01-dclient,
       name LIKE tst01-dname,
       objtype LIKE rststype-type,
       type LIKE rststype-type,
       get_size_from_format,
       bindata TYPE TABLE OF blob WITH HEADER LINE,
       temp_bindata TYPE TABLE OF blob WITH HEADER LINE,
       result TYPE TABLE OF text WITH HEADER LINE,
       filesize TYPE i,
       convcount TYPE i,
       textlines LIKE tline OCCURS 100 WITH HEADER LINE,
       tab1 TYPE TABLE OF soli,
       tab  TYPE TABLE OF soli WITH HEADER LINE,
       doc  LIKE TABLE OF docs,
       pdf  LIKE TABLE OF tline,
       file TYPE string ,
       otf  TYPE TABLE OF itcoo WITH HEADER LINE,
       eof TYPE soli ,
       lines TYPE i .


***Selection Screen
DATA :   spoolno TYPE tsp01-rqident,
          temp_spool TYPE tsp01-rqident.

SELECT-OPTIONS : range FOR spoolno NO INTERVALS.



LOOP AT range.

   temp_spool = range-low.

   CALL FUNCTION 'RSPO_RETURN_SPOOLJOB'
     EXPORTING
       rqident                    = temp_spool
*       FIRST_LINE                 = 1
*       LAST_LINE                  =
*       DESIRED_TYPE               =
*     IMPORTING
*       REAL_TYPE                  =
*       SP_LANG                    =
     TABLES
       buffer                     = tab1
*       BUFFER_PDF                 =
    EXCEPTIONS
      no_such_job                = 1
      job_contains_no_data       = 2
      selection_empty            = 3
      no_permission              = 4
      can_not_access             = 5
      read_error                 = 6
      type_no_match              = 7
      OTHERS                     = 8
             .
   IF sy-subrc <> 0.
* MESSAGE ID SY-MSGID TYPE SY-MSGTY NUMBER SY-MSGNO
*         WITH SY-MSGV1 SY-MSGV2 SY-MSGV3 SY-MSGV4.
   ENDIF.

   DESCRIBE TABLE tab1 LINES lines.
   READ TABLE tab1 INDEX lines INTO eof.
   DELETE tab1 INDEX lines.

   APPEND LINES OF tab1 TO tab.


   LOOP AT tab.
     CLEAR otf.
     otf = tab.
     APPEND otf.
   ENDLOOP.

*append lines of tab1 to bindata.
   REFRESH tab1.
   REFRESH tab.

ENDLOOP.
APPEND eof TO otf.




CALL FUNCTION 'CONVERT_OTF_2_PDF'
  EXPORTING
    use_otf_mc_cmd               = 'X'
*   ARCHIVE_INDEX                =
  IMPORTING
    bin_filesize                 = bin_size
   TABLES
     otf                          = otf
     doctab_archive               = doc
     lines                        = pdf
* EXCEPTIONS
*   ERR_CONV_NOT_POSSIBLE        = 1
*   ERR_OTF_MC_NOENDMARKER       = 2
*   OTHERS                       = 3
           .
IF sy-subrc <> 0.
* MESSAGE ID SY-MSGID TYPE SY-MSGTY NUMBER SY-MSGNO
*         WITH SY-MSGV1 SY-MSGV2 SY-MSGV3 SY-MSGV4.
ENDIF.
*
*



CALL METHOD cl_gui_frontend_services=>gui_download
   EXPORTING
     filename                = 'C:\sample.PDF'
     filetype                = 'BIN'
   CHANGING
     data_tab                = pdf
   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.
   WRITE sy-subrc.
ENDIF.

Dear Solution Managers(Friends),

"This is the limit of tolerance". I am writing this blog to collect people's point of view especially ABAPer how they tackle functional person's logic when they are more than one.

While working on xyz project / functionality / report many times I am encounter such kind of situation where I am getting too many logic for the single task from so many functional person. Each of them tries proves that they are correct. I don't know on what basis they are providing their functional logics and how to proofing them it as correct one. I know many of us have gone through suck kind of situations I would like to know what to do when such sort of time has arrived.

User wise case to case system is neither preferable nor reliable (Strongly not possible). Sometimes I am scared to think what to do if one more selection do exists (Execute report for which user)

It's totally horrible to dream also. Sometime I feel like SAP has provided so many standard procedures (functional logic) why not to follow one them which is suitable and compatible. Then go behind and thinking ok it's for Z and all is better if user needs something another.

I am eagerly wanted to know the experience faced by others. I am getting same kind of experience or I am the only the case and if second option is activated then you may think that I am Alien on earth.

-Avirat

What's a boxed component?

I read about them first in this document - http://scn.sap.com/docs/DOC-26231. Then I read the release notes - you do read the release notes when you upgrade to a new abap version, don't you? It's worth doing, as you can find some very nice language enhancements. I read the sap help, but couldn't quite get what the point of them was, nor how they worked.

Then I read this excellent blog SAP ABAP TYPE BOXED, New Type Category 7.02 Ehp2 - ABAP Help Blog that explains their functionality very clearly, but just now, I've created my first, real world use of the concept. So I'll share it.

Buffering data

I've got some master data - materials and time dependent attributes. I've got a few million records of data that contain materials and dates, and I want to find the attributes for those material, at that particular date. The records I've got are in no particular order, may refer to the same material many times, and may well have materials that don't have any master data. Also, the materials in my records are only a subset of all the possible materials.

Got that? Good.

The volume of master data is such that I cannot read all the data into an internal table in one go. So what I do is maintain a buffer that starts off empty. For a given material, I first check the buffer. If it isn't there, I check the database. If I still don't find anything I create a record in the buffer with a flag "not found", If I do find something, then I add it to the buffer.

Memory

So, my line structure is something like: MATERIAL, CORRECTED_COST, CORRECT_CURRENCY, NOT_FOUND. Here's some ABAP:

TYPES: BEGIN OF corrected_cost_ty,                    MATERIAL,                    CORRECTED_COST,                    CORRECTED_CURRENCY,                    NOT_FOUND,               END OF corrected_cost_ty

Now, the problem is that if a material is NOT_FOUND, then it has no correct cost. So for all the NOT_FOUND data, there's these two fields which never contain anything, but will be taking up space, nonetheless. This is where boxing comes in.

I create a type "attributes" which has CORRECTED_COST and CORRECT_CURRENCY, then I redo my corrected_cost_ty like this.

TYPES: BEGIN OF attributes_ty,        CORRECTED_COST,         CORRECTED_CURRENCY,      END OF attributes_ty.

TYPES: BEGIN OF corrected_cost_ty,
         MATERIAL,         ATTRIBUTES type attributes_ty BOXED,         NOT_FOUND,       END OF corrected_cost_ty

Now, when I don't have any attributes for a material (because it's NOT_FOUND), memory is only allocated to the MATERIAL and NOT_FOUND.

The only downside is that I have to refer to my attributes as attributes-corrected_cost.  I'd like to be able to use something like

INCLUDE TYPE attributes_ty BOXED.

But I guess we'll have to wait a while for that to happen.

The Problem

Because ABAP is a language with (too) many possibilities, called procedures can strangely affect the flow of the calling program. In some cases, even a trace does not clarify the behavior.

Sometimes this can be hard to figure out.

Known Cases

The cruel thing with the following commands is that they are performed anywhere, but affect later! So looking at the last performed command does not help.

set screen

If the code you are calling via a dynpro performs set screen 0, your dynpro will be left after your PAI has completely run.

If the called code performs set screen <nnnn> (<>0), this dynpro will be called after your PAI has completely run.

leave [to] screen

If the called code performs leave screen, the last set screen will be performed, and the calling program will not be continued.
If in this case the last set screen is 0, see set screen 0.

If in this case the last set screen <> 0, this screen will be performed.

If the called code performs leave to screen <nnnn> the same is true for dynpro nnnn.

suppress dialog

If you are calling code in your PBO that performs suppress dialog, the PAI of your dynpro will be processed as if the user would have hit enter (but he did not) although you even don´t see your dynpro (you still see the last dynpro).

message

As ABAPers we know that the message command can influence many many things, e. g. if the called program sends a message of type E your PAI-Module gets interrupted and no PBO is performed, but the program does not stop. But this command can do so much more strange things, this is why I call it the monster command .

Others

Not such cruel, but also in this context interesting statements are:

• call transaction
• call screen
• leave
• leave program
• leave list-processing
• leave to current transaction
• leave to list-processing
• leave to transaction
• submit
• stop
• exit from step-loop

A real life Example

We called BAPI_PROCORD_CHECK_MAT_AVAIL and after that call, the PAI was still processed and after PAI the program easily has ended.
See here: BAPI_PROCORD_CHECK_MAT_AVAIL affecting screen flow.

How does that help?

Well, next time I see such a strange behavior, I will set break points at the following commands:

• set screen
• leave
• suppress dialog
• message
• call transaction
• call screen
• submit
• stop
• exit from step-loop

What did I miss?

Did I miss something? If you have more commands that could be interesting here, please tell me.

If you have any questions or other notes, please tell me.

Greets

Stefan

Hi friends,

I am writing this just to share what I had learned from the TECH ED 203 Bangalore.

The renewed ABAP has come up with efficient coding or increasing the productivity and readable code.

Here is a few examples of he same.

Old Method for declaring

Field Symbols

FIELD-SYMBOLS <line> LIKE LINE of itab.

LOOP AT itab ASSIGING  <line>.

....

END LOOP.

New Method for declaring

LOOP AT itab Assigning SYMBOL(<line>).

....

ENDLOOP.

Constructor ExpressionsNEW()

Old

DATA oref TYPE REF to class.

CREATE OBJECT oref Exporting...

New way

DATA (oref) = NEW class(....).

DATA oref TYPE REF to class.

oref = NEW#(....).

Table Expressions

Old Method

READ TABLE itab INDEX idx INTO wa.

New Merhod

wa = itab [ dix ].

There are many more this is how much I could remember and will start including all as I go through the notes and examples.

Transaction Code : FIBF

SE11

RFPOS- APPEND STRUCTURE

Create your structure as you need

Append another structure also in RFPOSX but includes same fields with Appended structure in RFPOS

Run the program RFPOSXEXTEND.

Ready

Yesterday we had an issue on an SAP implementation. I was sure that it was a standard error, because in other implementation the functionality works perfectly.

On Twitter Nicolas Busson reminded me that ANST can save your life quickly and easily

This video is the live implementation of the OSS Note using ANST.

What help.sap.com doesn't tell us

I thought, SAP is pretty clear in what they tell us about the _SCOPE-parameter that can be passed to every enqueue-function modul.

The parameter can have 3 values, which means, according to help.sap.com:

Meaning of the _SCOPE Values

_SCOPE Parameter (SAP Library - Architecture Manual)

The most interesting statement is the description for _SCOPE = 2. It says that the lock is released when the update transaction is complete.

So I understood that COMMIT WORK will implicitly release the lock. As I found out, it is not necessarily the case.

The test report

Consider the following test report.

The report is going to request a lock for an ABAP report. The lock argument is '1' as a dummy value. Keep in mind, that Z_UPDATE_TASK_DUMMY is an update function module that has no execution logic in my case.

DATA lt_enq TYPE TABLE OF seqg3.
FIELD-SYMBOLS <ls_enq> TYPE seqg3.
PARAMETERS pa_upd TYPE abap_bool AS CHECKBOX.
CALL FUNCTION 'ENQUEUE_ES_PROG'   EXPORTING     name           = '1'     _scope         = '2'   EXCEPTIONS     foreign_lock   = 1     system_failure = 2     OTHERS         = 3.
IF sy-subrc <> 0.   MESSAGE ID sy-msgid TYPE sy-msgty NUMBER sy-msgno WITH sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4.
ENDIF.
IF pa_upd = abap_true.   CALL FUNCTION 'Z_UPDATE_TASK_DUMMY' IN UPDATE TASK.
ENDIF.
COMMIT WORK AND WAIT.
CALL FUNCTION 'ENQUEUE_READ'   EXPORTING     gclient               = sy-mandt     guname                = sy-uname   TABLES     enq                   = lt_enq   EXCEPTIONS     communication_failure = 1     system_failure        = 2     OTHERS                = 3.
IF sy-subrc <> 0.   MESSAGE ID sy-msgid TYPE sy-msgty NUMBER sy-msgno WITH sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4.
ELSE.   IF lt_enq IS INITIAL.     WRITE 'No locks existing'.   ELSE.     LOOP AT lt_enq ASSIGNING <ls_enq>.       WRITE: <ls_enq>-gname,               <ls_enq>-garg,               <ls_enq>-gmode.       NEW-LINE.     ENDLOOP.   ENDIF.
ENDIF.

The report offers a parameter PA_UPD to the user. If checked, the update function module will be called. If not checked, there is no update task registered. Afterwards, COMMIT WORK AND WAIT is always triggered.

In the end, the report shows any locks that the current user has.

The ugly truth

If the report is called with the enabled checkbox, the dummy function module will be called. In the end, all locks are released.

If the report should not execute any update function module (checkbox is deactivated), the locks are not released at all. COMMIT WORK AND WAIT has no influence here as there is no update task registered. I also included the output of SM12 in the screenshot.

The moral of the story

Locks of the update owner are not necessarily released, when COMMIT WORK has been called. It depends on wether or not an update task has been called at all. help.sap.com is not wrong with the description about _SCOPE = 2, however, someone who reads the description might get a wrong idea of how ABAP works in this very case. It took me some time to figure out what happens here. So I hope this blog post helps other developers saving some time.