SAP Community - SAP S/4HANA Cloud ABAP Environment

How to attach documents to a Journal Entry within SAP S/4HANA Public Cloud from ABAP.

2024-03-08T15:57:24.484000+01:00

Introduction

In this blog, we describe a method to attach document files to a Journal Entry (BKPF) instance within the same SAP S/4HANA Cloud Public Edition using ABAP.

This requires us to expose and consume the Attachment API as described in the SAP Business Accelerator HUB - Attachments.

I belive this blog can be very useful since existing documentation primarily focuses on exposing the services, but we encounter conceptual problems when consuming them locally.

This method is also valid for a S/4HANA Private Cloud but has been implemented and tested only in S/4HANA Public Cloud.

Steps

Create the Outbound Service. In Eclipse, and within your development package, follow these steps to create a new Outbound Service:
- Add name and description.
- Select the type HTTP.
- Set the Default Path Prefix for the Attachment method AttachmentContentSet, as follows: "/sap/opu/odata/sap/API_CV_ATTACHMENT_SRV/AttachmentContentSet".
Create the Communication Scenario. Still in Eclipse and under your development package, create a new Communication Scenario as follows:
- Add name and description.
- In the Outbound tab, add the previously created service.
- Use the top-right 'Publish Locally' button to publish the communication scenario.
Create the Communication User. Navigate to the Maintain Communication User app and create a new user. Remember to copy the username and password, as we will need them to configure the communication systems.
Assign the new communication user to our local Communication System. In the Communication System app, select our local system using the top button labeled "Own SAP Cloud System."
- Copy the hostname, as it will be needed in the next step.
- In edit mode, assign the previously created user as the User for Inbound Communication and save.
Create a Communication System to consume the service. Go to the Communication Systems App, create a new system, fill the ID and description.
- Complete hostname field with the value obtained in the previous step (local hostname).
- Assign the previously created user as Outbound User, and save.
Create the Communication Arrangement to expose the service. Navigate to the Communication Arrangement App, create a new one, or check if one exists, based on the Scenario SAP_COM_0002: Finance - Posting Integration. This scenario has sufficient permissions to attach document files to a Journal Entry instance.
- After selecting or creating the communication arrangement, ensure that the communication system is assigned to your local system. Also, add the created communication user as Inbound Communication User.
- We don't need the Outbound Services of the Arrangement for this requirement, so unless necessary for other reasons, deactivate these services by unchecking the Active flag.
Create the Communication Arrangement to consume the service. Create a new Communication Arrangement based on our scenario created in step 2, assign the communication system created and assign the outbound communication user.

After saving, you can verify if the user/system relationship has been correctly configured using the Check Connection button.

If you get an error, please check the Outbound User has the right password in Communication System.
Consume the Attachment API from an ABAP Class.

You can consume the API using ABAP with the following code.

    TRY.
        DATA(lo_destination) = cl_http_destination_provider=>create_by_comm_arrangement(
                                 comm_scenario  = 'ZCS_ATTACHMENT' "Communication Arrangement
                                 service_id     = 'ZOS_API_ATTACHMENT_REST' "Outbound Service).

        DATA(lo_http_client) = cl_web_http_client_manager=>create_by_http_destination( i_destination = lo_destination ).

        "Set CSRF Token
        lo_http_client->set_csrf_token(  ).

        DATA(lo_request) = lo_http_client->get_http_request( ).

        lo_request->set_header_field( i_name = 'Slug' i_value = iv_filename )."Filename (with extension)
        lo_request->set_header_field( i_name = 'BusinessObjectTypeName' i_value = iv_bo_type ). "BKPF
        lo_request->set_header_field( i_name = 'LinkedSAPObjectKey' i_value = iv_bo_key ). "Journal Entry concatenate key fields.
        lo_request->set_content_type( content_type = iv_mimetype ). "Mimetype
        lo_request->set_binary( i_data = iv_attachment ). "File content in binary

        DATA(lo_response) = lo_http_client->execute( i_method = if_web_http_client=>post ).


        DATA(ls_status) = lo_response->get_status( ).

        IF ls_status-code NE 201.
          "Catch error (the attachment hasn't be created)
        ENDIF.

      CATCH cx_web_message_error INTO DATA(lx_web).
         "Catch error (the service is misconfigured)
    ENDTRY.

Please take a look to "iv_" variables and replace them with valid information. or include the code into a class method with these variables, all of them are strings.

SAP S/4HANA Cloud ABAP开发案例之六：BOM批量读取

2024-03-11T07:05:14.803000+01:00

紧随这篇博客，今天我们将再次逐步详细地介绍一个利用SAP S/4HANA Cloud三系统来做开发扩展的案例。

1. 案例背景

我们有些客户希望查看BOM所有层级的数据，也希望能够批量下载BOM所有层级的数据。我们有标准应用程序“Display BOM level by level”可以查看或下载单个物料的BOM所有层级信息，但是没有应用程序可以查看或下载多个物料的BOM所有层级数据。我们这个案例的开发应用就是来完成这样一个需求。

standard App Display BOM level by level can only view the data for single Material

通过开发人员可扩展性，我们创建了一个自定义的应用程序，允许用户选择多个物料，可以查看或下载所选物料的所有节点数据。

2. 后台服务开发

2.1 创建数据定义

创建一个新的数据定义（data definition）

2.2 创建查询实现类

创建类ZCL_BOM_DISPLAY，在这个类里包含了详细的数据查询逻辑。

METHOD get_bom_hierarchy.

*get BOM Link and BOM hierarchy based on condition
    SELECT *
    FROM I_BOMComponentWithKeyDate( p_keydate = _keydate ) AS Bom
    JOIN I_MaterialBOMLink AS Bomlink
      ON Bom~BillOfMaterialCategory = Bomlink~BillOfMaterialCategory
     AND Bom~BillOfMaterialVariant = Bomlink~BillOfMaterialVariant
     AND Bom~BillOfMaterial = Bomlink~BillOfMaterial
    WHERE Bomlink~BillOfMaterialCategory = 'M'
    AND Bomlink~BillOfMaterialVariant = '01'
    AND Bomlink~Material IN _material
    AND Bomlink~Plant IN _plant
    INTO TABLE (lt_BOMlist).

    IF sy-subrc = 0.
      rv_resp = abap_true.
      CLEAR pt_materialhierarchy.
    ENDIF.
    LOOP AT lt_BOMlist ASSIGNING FIELD-SYMBOL(<lfs_bomlist>).
      MOVE-CORRESPONDING <lfs_bomlist>-bomlink TO ps_response.
      MOVE-CORRESPONDING <lfs_bomlist>-bom TO ps_response.

      "Get product descrption saperatelly since CDS view does not have it.
      SELECT SINGLE ProductName FROM I_producttext
      WHERE Product = _response-material AND Language = -langu INTO _response-materialDesc.

      APPEND ps_response TO pt_response.
      CLEAR ps_response.

      ps_material-sign = 'I'.
      ps_material-option = 'EQ'.
      ps_material-low = <lfs_bomlist>-bom-BillOfMaterialComponent.
      APPEND ps_material TO pt_materialhierarchy.
      CLEAR ps_material.
    ENDLOOP.

  ENDMETHOD.

@EndUserText.label: 'Multiple BOM Display'
@ObjectModel.query.implementedBy: 'ABAP:ZCL_BOM_DISPLAY'

@UI.headerInfo: {typeName: 'Billofmaterial',typeNamePlural: ' BOM Mass Download'}
                                   
define custom entity Z_BOM_DISPLAY
 with parameters 
//    @Environment.systemField: #SYSTEM_DATE
//    @ui.lineItem :[{label:'Material',position:10,importance: #HIGH }]
     P_KeyDate : vdm_v_key_date
{

    @ui.lineItem :[{label:'Material',position:10,importance: #HIGH }]
    @ui.selectionField: [{ position: 20 }]
//    @Consumption.valueHelpDefinition: [{ entity: {name:'I_ProductStdVH' ,element: 'Product' } }]
    @Consumption.valueHelpDefinition: [{ entity: {name:'I_ProductPlantStdVH' ,element: 'Product' } }]    
    @Consumption.valueHelpDefinition: [{additionalBinding: [{ element: 'Plant', localElement: 'Plant' }]}]  
    @Consumption.filter:{mandatory: true}
        
  key Material                     : matnr;
    @ui.lineItem :[{label:'Plant', position:90, importance: #HIGH }]
    @ui.selectionField: [{ position: 10 }]
    @Consumption.valueHelpDefinition: [{ entity: {name:'I_PlantStdVH' ,element: 'Plant' } }] 
    @Consumption.filter:{mandatory: true}
//    @Consumption.defaultValue: '1310'  
  key Plant                        : werks_d; 

    @ui.hidden: true    
  key BillOfMaterialCategory      : abap.char(1);       
//    @ui.selectionField: [{ position: 50 }]       
    @ui.hidden: true                         
  key Billofmaterial               : abap.char(8);
//    @ui.selectionField: [{ position: 60 }]       
    @ui.hidden: true  
  key Billofmaterialvariant        : abap.char(2);     
    @ui.hidden: true  
  key Billofmaterialitemnodenumber : abap.numc(8);
  
  @ui.lineItem :[{label:'MaterialDesc',position:20,importance: #HIGH  }]
  MaterialDesc                 : abap.char(40); 
  @ui.lineItem :[{label:'ValidityStartdate',position:100,importance: #HIGH  }]
  Validitystartdate            : abap.dats;
  @ui.lineItem :[{label:'ValidityEnddate',position:110,importance: #HIGH }]
  Validityenddate              : abap.dats;
  @ui.lineItem :[{label:'Component',position:50,importance: #HIGH  }]
  Billofmaterialcomponent      : matnr;
  @ui.lineItem :[{label:'ComponentDesc',position:60,importance: #HIGH  }]
//  BillofmaterialcomponentDesc  : abap.char(40);  
  ComponentDescription      : abap.char(40);    
  @ui.lineItem :[{label:'ItemCategory',position:30,importance: #HIGH  }]
  Billofmaterialitemcategory   : abap.char(1);
  @ui.lineItem :[{label:'ItemNumber ',position:40,importance: #HIGH  }]
  Billofmaterialitemnumber     : abap.char(4);
  @ui.lineItem :[{label:'ItemUnit',position:80,importance: #HIGH  }]
//  @Semantics.unitOfMeasure
  Billofmaterialitemunit       : meins;
//  Billofmaterialitemunit       : abap.unit(3);  
  @ui.lineItem :[{label:'ItemQuantity',position:70,importance: #HIGH  }]
//  @Semantics.quantity.unitOfMeasure : 'billofmaterialitemunit'
  Billofmaterialitemquantity   : abap.numc(13); 
//   Billofmaterialitemquantity   : abap.quan(13,3); 
    @ui.hidden: true  
  Identifierbomitem            : abap.char(8);

  @ui.lineItem :[{label:'Level',position:220,importance: #LOW  }]    
  LevelCount                   : abap.numc(8);
  @ui.lineItem :[{label:'Path(Predecessor)',position:230,importance: #LOW  }]    
  Path                         : abap.numc(8);    

}

2.3 创建服务定义和服务绑定

创建服务定义（Service Definition）

创建服务绑定（Service Binding）

然后，我们可以预览服务如下：

3. 前端应用开发

首先，配置BTP上的destination。

然后，打开SAP Business Application Studio服务

从Application Generator里选取List Report Page模板

把App部署到SAP S/4hana Public Cloud系统

复制Launchpad App Description Item名字到IAM App：

通过该新应用，我们不仅可以选择多个物料来查看BOM的节点信息，也可以把所有数据下载到Excel表格，以方便用户线下操作。

以上是该案例——BOM批量读取自开发应用的步骤介绍。希望通过此案例的介绍能让您了解到三系统开发能实现的常见功能。

SAP S/4HANA Cloud ABAP开发案例之七：库龄报表

2024-03-11T08:40:07.661000+01:00

紧随这篇博客，今天我们将再次逐步详细地介绍一个利用SAP S/4HANA Cloud三系统来做开发扩展的案例。

1. 案例背景

库龄报表是大多数客户都会询问和想要的一张报表。它以逆时间顺序概述了一段时间内从选定的关键日期开始的可用物料库存的分布情况。但是，具体的需求可能因客户而异。例如，一些客户可能希望在计算物料库龄信息时只考虑某些移动类型。通过利用开发人员可扩展性，我们开发了一个定制的库龄报表，并嵌入到SAP S/4hana Cloud系统中。此外，客户可以完全灵活地定义哪些移动类型将包括在库龄报告的计算中。

同时，我们配置了一个Custom Business Configuration项目，我们可以把希望被统计在库龄报表里的移动类型维护在这个表格内，如下图。

2. 后台服务开发

2.1 创建数据定义

创建一个新的数据定义（Data Definition）：Z_MATERIAL_STOCK_AGE

2.2 创建查询实现类

创建类ZCL_MATERIAL_STOCK_AGE，在这个类里包含了基于CDS视图的数据查询逻辑。

CLASS zcl_material_stock_age DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.

    INTERFACES if_rap_query_provider .
  PROTECTED SECTION.
  PRIVATE SECTION.
ENDCLASS.



CLASS ZCL_MATERIAL_STOCK_AGE IMPLEMENTATION.


  METHOD if_rap_query_provider~select.
    IF io_request->is_data_requested( ).

      TYPES BEGIN OF ty_value.
      TYPES: quantity TYPE i_stockquantitycurrentvalue_2-matlwrhsstkqtyinmatlbaseunit,
             value    TYPE i_stockquantitycurrentvalue_2-stockvalueindisplaycurrency.
      TYPES END OF ty_value.

      TYPES:
        BEGIN OF ty_range_option,
          sign   TYPE c LENGTH 1,
          option TYPE c LENGTH 2,
          low    TYPE string,
          high   TYPE string,
        END OF ty_range_option.


      DATA: lt_response        TYPE TABLE OF z_material_stock_age,
            ls_response        LIKE LINE OF lt_response,
            lt_responseout     LIKE lt_response,
            ls_responseout     LIKE LINE OF lt_responseout,
            lt_response_period TYPE TABLE OF z_material_stock_age,
            ls_response_period LIKE LINE OF lt_response_period,
            lt_value           TYPE TABLE OF ty_value,
            ls_value           TYPE ty_value,
            lv_price           TYPE p DECIMALS 2,
            lt_configr         TYPE TABLE OF ty_range_option,
            ls_configr         LIKE LINE OF lt_configr.


      DATA(lv_top)           = io_request->get_paging( )->get_page_size( ).
      DATA(lv_skip)          = io_request->get_paging( )->get_offset( ).
      DATA(lv_max_rows) = COND #( WHEN lv_top = if_rap_query_paging=>page_size_unlimited THEN 0
                                  ELSE lv_top ).

      DATA(lt_clause)        = io_request->get_filter( )->get_as_ranges( ).
      DATA(lt_parameter)     = io_request->get_parameters( ).
      DATA(lt_fields)        = io_request->get_requested_elements( ).
      DATA(lt_sort)          = io_request->get_sort_elements( ).

      TRY.
          DATA(lt_filter_cond) = io_request->get_filter( )->get_as_ranges( ).
        CATCH cx_rap_query_filter_no_range INTO DATA(lx_no_sel_option).
      ENDTRY.

****************************Data selection and business logics goes here*********************************
      LOOP AT lt_parameter ASSIGNING FIELD-SYMBOL(<fs_p>).
        CASE <fs_p>-parameter_name.
          WHEN 'P_KEYDATE'.   DATA(p_keydate) = <fs_p>-value.
        ENDCASE.
      ENDLOOP.

      LOOP AT lt_filter_cond INTO DATA(ls_filter_cond).
        IF ls_filter_cond-name = 'STROAGELOCATION'.
          DATA(lt_storagelocation) = ls_filter_cond-range[].
        ELSEIF  ls_filter_cond-name = 'MATERIAL'.
          DATA(lt_material) = ls_filter_cond-range[].
        ELSEIF  ls_filter_cond-name = 'PLANT'.
          DATA(lt_plant) = ls_filter_cond-range[].
        ELSEIF  ls_filter_cond-name = 'COMPANYCODE'.
          DATA(lt_bukrs) = ls_filter_cond-range[].
        ENDIF.
      ENDLOOP.

*get configuration data
      SELECT * FROM zmovementtype WHERE bukrs IN @LT_bukrs
                                  AND inuse = @abap_true
                                  INTO TABLE @DATA(lt_config).

      LOOP AT lt_config INTO DATA(ls_config).
        ls_configr-sign = 'I'.
        ls_configr-option = 'EQ'.
        ls_configr-low = ls_config-movementtype.
        APPEND ls_configr TO lt_configr.
        CLEAR ls_configr.
      ENDLOOP.

*get inventory information based on date
      SELECT *
      FROM i_materialstock_2
      WHERE storagelocation IN @LT_storagelocation
      AND material IN @LT_material
      AND matldoclatestpostgdate <= @p_keydate
      AND plant IN @LT_plant
      AND companycode IN  @LT_bukrs
      INTO TABLE @DATA(lt_stock).

      LOOP AT lt_stock INTO DATA(ls_stock).
        ls_response-companycode = ls_stock-companycode.
        ls_response-plant = ls_stock-plant.
        ls_response-material = ls_stock-material.
        ls_response-stroagelocation = ls_stock-storagelocation.
        ls_response-currentstock = ls_stock-matlwrhsstkqtyinmatlbaseunit.
        COLLECT ls_response INTO lt_response.
      ENDLOOP.

*period start date calculation
      DATA lv_30 TYPE d.
      DATA lv_60 TYPE d.
      DATA cd TYPE d.
      cd = p_keydate.
      lv_30 = cd - 30.
      lv_60 = cd - 60.

*get material movement history
      SELECT *
      FROM i_materialdocumentitem_2
      FOR ALL ENTRIES IN @LT_response
      WHERE storagelocation = @LT_response-stroagelocation
      AND postingdate <= @p_keydate
      AND plant IN @LT_plant
      AND companycode IN @LT_bukrs
      AND material = @LT_response-material
      AND goodsmovementtype in @LT_configr
      AND goodsmovementiscancelled IS INITIAL
      INTO TABLE @DATA(lt_movement).

      DATA(lt_movement_reverse) = lt_movement[].

      LOOP AT lt_movement INTO DATA(ls_movement).
        READ TABLE lt_movement_reverse WITH KEY  reversedmaterialdocumentyear = ls_movement-materialdocumentyear
                                                 reversedmaterialdocument = ls_movement-materialdocument
                                       TRANSPORTING NO FIELDS.
        IF sy-subrc = 0.
          DELETE lt_movement FROM ls_movement.
        ENDIF.
      ENDLOOP.

      LOOP AT lt_movement INTO ls_movement WHERE reversedmaterialdocument IS INITIAL.
        ls_response_period-companycode = ls_movement-companycode.
        ls_response_period-plant = ls_movement-plant.
        ls_response_period-material = ls_movement-material.
        ls_response_period-stroagelocation = ls_movement-storagelocation.
        ls_response_period-meins = ls_movement-materialbaseunit.
        ls_response_period-waers = ls_movement-companycodecurrency.

        IF ls_movement-postingdate > lv_30 AND ls_movement-postingdate <= cd.
          ls_response_period-period1 = ls_movement-quantityinbaseunit.
        ELSEIF ls_movement-postingdate > lv_60 AND ls_movement-postingdate <= lv_30.
          ls_response_period-period2 = ls_movement-quantityinbaseunit.
        ELSEIF ls_movement-postingdate <= lv_60.
          ls_response_period-period3 = ls_movement-quantityinbaseunit.
        ENDIF.

        COLLECT ls_response_period INTO lt_response_period.
        CLEAR ls_response_period.
      ENDLOOP.

      LOOP AT lt_response INTO ls_response.
        READ TABLE lt_response_period WITH KEY companycode = ls_response-companycode
                                               plant = ls_response-plant
                                               material = ls_response-material
                                               stroagelocation = ls_response-stroagelocation
                                      INTO ls_response_period.

*        ls_response-meins = ls_response_period-meins.
*        ls_response-waers = ls_response_period-waers.

        IF sy-subrc = 0.
* period 1 calculation with 30 days.
          IF ls_response-currentstock < ls_response_period-period1 AND ls_response_period-period1 > 0.
            ls_response-period1 = ls_response-currentstock.
          ELSE.
            ls_response-period1 = ls_response_period-period1.
          ENDIF.
* period 2 calculation between 30 days to 60 days.
          IF ( ls_response-currentstock - ls_response_period-period1 )  < 0.
            ls_response-period2 = 0.
          ELSEIF ( ls_response-currentstock - ls_response_period-period1 ) < ls_response_period-period2 AND ls_response_period-period2 > 0.
            ls_response-period2 = ls_response-currentstock - ls_response_period-period1.
          ELSEIF ( ls_response-currentstock - ls_response_period-period1 ) >= ls_response_period-period2.
            ls_response-period2 = ls_response_period-period2.
          ENDIF.
* period 3 calculation more than 60 days
          IF ( ls_response-currentstock - ls_response_period-period1 - ls_response_period-period2 )  < 0.
            ls_response-period3 = 0.
          ELSEIF ( ls_response-currentstock - ls_response_period-period1 - ls_response_period-period2 ) < ls_response_period-period3 AND ls_response_period-period3 > 0.
            ls_response-period3 = ls_response-currentstock - ls_response_period-period1 - ls_response_period-period2.
          ELSEIF ( ls_response-currentstock - ls_response_period-period1 - ls_response_period-period2 ) >= ls_response_period-period3.
            ls_response-period3 = ls_response_period-period3.
          ENDIF.

        ELSEIF sy-subrc > 0 AND ls_response-currentstock > 0.
          ls_response-period3 = ls_response-currentstock.
        ENDIF.

* getting price information
        SELECT SUM( matlwrhsstkqtyinmatlbaseunit ) AS quantity,
               SUM( stockvalueincccrcy ) AS value
               FROM i_stockquantitycurrentvalue_2( p_displaycurrency = 'CNY' )
               WHERE product = @LieneS_response-material
               AND plant = @LieneS_response-plant
               AND storagelocation = @LieneS_response-stroagelocation
               AND valuationareatype = 1
               GROUP BY product,plant,storagelocation
               INTO TABLE @LT_value.

        IF sy-subrc = 0.
          CLEAR: ls_value,
                 lv_price.
          READ TABLE lt_value INTO ls_value INDEX 1.
          IF ls_value-quantity NE 0.
            lv_price = ls_value-value / ls_value-quantity.
          ENDIF.
        ENDIF.

* calculate value information
        ls_response-currentvalue = ls_response-currentstock * lv_price.
        ls_response-period1_v = ls_response-period1 * lv_price.
        ls_response-period2_v = ls_response-period2 * lv_price.
        ls_response-period3_v = ls_response-period3 * lv_price.

        MODIFY lt_response FROM ls_response.
        CLEAR ls_response.
      ENDLOOP.

*paging way to return huge amount of data
      SORT lt_response BY stroagelocation material.
      lv_max_rows = lv_skip + lv_top.
      IF lv_skip > 0.
        lv_skip = lv_skip + 1.
      ENDIF.

      CLEAR lt_responseout.
      LOOP AT lt_response ASSIGNING FIELD-SYMBOL(<lfs_out_line_item>) FROM lv_skip TO lv_max_rows.
        ls_responseout = <lfs_out_line_item>.
        APPEND ls_responseout TO lt_responseout.
      ENDLOOP.

      io_response->set_total_number_of_records( lines( lt_response ) ).
      io_response->set_data( lt_responseout ).

    ENDIF.
  ENDMETHOD.
ENDCLASS.

2.3 创建服务定义和服务绑定

创建服务定义（Service Definition）

创建服务绑定（Service Binding）

我们可以看到服务预览如下：

3. 前台应用开发

首先，在BTP上配置destination。

然后，打开SAP Business Application Studio服务。

从Application Generator里选取SAP Fiori Worklist Application模板。

把应用部署到SAP S/4HANA Public Cloud系统。

以上是该案例——库龄报表自开发应用的步骤介绍。希望通过此案例的介绍能让您了解到三系统开发能实现的常见功能。

Platform agnostic ABAP Add-On Development and use of standard objects in Cloud Development

2024-03-14T11:31:39.570000+01:00

Last year we celebrated ABAP as SAP's programming language as it turned 40 and from the vision and roadmap from SAP it is evident that it is going to stay here for some more decades. SAP has been leading in the Gartner's quadrant for ERP for decades now and this has been possible because of SAP's vibrant partner eco-system.

Having said this, let's turn our focus to one of its advancement, i.e., the ABAP environment in the Business Transformation Platform (commonly know as SAP BTP). With the introduction of SAP BTP in the last couple of years there has been a huge shift of mindset in the development fraternity of SAP. At least in the partner ecosystem now solutions are being developed keeping SAP BTP in mind, i.e., solutions being developed in the partner eco-system are being made more platform agnostic.

To achieve a clean and controlled design paradigm in the cloud environment of ABAP, SAP came up with the ABAP Language Version for cloud which is known as ABAP for Cloud Development. The value for the ABAP Language Version determines which language elements can be used in the development. For example, the language version of ABAP for Cloud Development has a more restricted use and has an extensive list of elements that can be used but not as the language version Standard ABAP where there are no restrictions. [The list can be viewed in Language Elements in ABAP Versions] As mentioned already the language version ABAP for Cloud Development has a more restricted use and therefore not all objects from Standard SAP language version can be used in objects with language version ABAP for Cloud Development. Only APIs having language version as Standard ABAP and with a C1 contract which are released for Use in Cloud Development can be used in the development objects with language version ABAP for Cloud Development. [ABAP for Cloud Development is a good read to understand the concepts of Restricted Language use and API contracts.]

As mentioned before, SAP's partner eco-system has to always go hand in hand with SAP. This means that with the introduction of SAP BTP, ABAP environment, partners needs to build solutions that are more platform agnostic, i.e., solutions which can run independently on the on-premise solutionSAP ERP,SAP S/4HANAand as well on the SAP BTP, ABAP environment. This is a most widely accepted paradigm in the solution design, otherwise maintenance cost of the code-base would increase exponentially. And anyone from the partner eco-system's development fraternity will agree with the fact that refusing APIs from SAP standard solution makes our life easy and reduces the cost and time of the development life-cycle of the add-on solutions.

To be able to build solutions which are platform agnostic, i.e., would run independently on SAP S/4HANA as well as SAP BTP, ABAP environment the minimum on-premise version that can be used is the SAP S/4 HANA 1909 version. However, for objects to be deployed to SAP BTP, ABAP environment it is mandatory that the objects have the ABAP Language Version is set to ABAP for Cloud Development. But then if one tries to make use of any objects from the Standard ABAP, i.e., ABAP Language Version set to as Standard ABAP the following compilation error occurs.

Now since this class belongs to the Standard ABAP Language Version and is not released for use in Cloud the compilation error is displayed. This can be resolved by Adding a Release Contract, i.e., C1 contract in this scenario and marking the object for Use in Cloud Development.

This way you can make sure that the standard object can be used in cloud environment, but it is not a recommendable approach as there will be issues in deploying to the cloud environment.

Another scenario is where the development fraternity of the partner eco-system tries to reuse objects from standard SAP solution. And to identify objects with a released API state is cumbersome. But with ADT it can be achieved with using keyword in the properties field of the search. The search can be triggered using Search option from the menu bar and selecting ABAP Object Search, or using the keyboard shortcut of Control + H or using the Open ABAP Development Option or the using the keyboard shortcut Control + Shift + A. [Refer the screenshots below]

This way one can list out the released API or artefacts for use in SAP BTP, ABAP environment, i.e., the objects that would always be available for use in SAP BTP, ABAP environment. [Refer to the blog Searching Development Objects with the ABAP Object Search for better understanding of search options in ADT.]

S4-FSCM-Custom Credit Check Rule and Custom Credit Check Step

2024-03-21T15:00:51.335000+01:00

To perform the credit check, Credit Profile needs to be set up for the business partner under the UKM000 role. Credit Profile of the Business partner drives the credit behavior of the Business partner. Under the credit profile Credit Check rule plays vital role in performing the Credit Check in the credit engine.

Every Credit Check rule can have one or multiple Check Steps that can be defined to execute. SAP had provided several Check Steps as shown below.

For Ex: SAP standard Check rule ‘01’ has several SAP check standard Check steps

Navigate to the IMG Path :

SPRO-> Financial Supply Chain Management -> Credit Management -> Credit Risk Monitoring -> Credit Limit Check -> Define Check Rules

Select the Check rule and select Checks in the left side tree structure, to see the list of Credit check steps assigned and will be performed during credit check.

Let us see the detailed steps on how to create Custom Credit check step and assign the Created credit check step to Custom Credit Check Rule and then assign the newly created Credit check Rule to the Business partner in the credit profile under the UKM000 BP role.

Create Custom Credit Check Step ( Z10 ):-

In this step lets us define to fail the credit check always.

Navigate to the IMG Path :

SPRO-> Financial Supply Chain Management -> Credit Management -> Credit Risk Monitoring -> Enhancements -> BAdi: Individual step of Credit Check

Execute the step BAdi: Individual step of Credit Check

Choose Create and Define the step Number Z10 and the description as “Fail Credit Check always”

In the Method CHECK_STEP, define the custom logic to decide the credit check should be successful or failed.

In this example we will define the Check Step to fail always.

Variable C_PASSED is cleared.

The below Custom error message can be populated into the return table parameter ct_results.

METHOD if_ex_ukm_check_step~check_step.

    DATA : lv_dummy TYPE string.

    CLEAR c_passed.

    MESSAGE e000(zcust_msg) INTO lv_dummy.

    CALL METHOD cl_ukm_credit_checker=>add_reason
      EXPORTING
        i_check_step = flt_val
        io_account   = io_account
      CHANGING
        ct_results   = ct_results.


  ENDMETHOD.

Now we have created a New Custom Credit Check step. We need to assign this credit check step to Custom Check rule.

Now lets us create New Check Rule,

Navigate to the IMG Path :

SPRO-> Financial Supply Chain Management -> Credit Management -> Credit Risk Monitoring -> Credit Limit Check -> Define Checking Rules

Create New entry with the Check Rule “Z2” and Name of Check Rule as “Fail Credit Check always”

Select the Check Rule and select Checks and assign the Newly created check step “Z10”

Now we have completed the Creation of Custom Credit check Rule “Z2” and Check Step “Z10”. We can assign this Credit check rule Z2 to Business partner if the credit check needs to fail always for the Business partner whenever the credit check is performed for this BP.

Assign the Custom Credit Check Rule “Z2” to the Business Partner

We can perform the simulation of credit check to validate the credit check results of the custom Check Rule “Z2”

Navigate to the Credit Segment data of the Business Partner

and choose the “Simulate Credit check” option highlighted below

Note : Credit Segment master data should be created and the Credit limit of the Business Partner needs to be setup. *** creation of Credit segment master data will be explained in the upcoming blogs.

Provide the input value amount and Currency and choose Credit Check, the results is shown in the output.

Have you noticed the error message raised in the custom Check Step “Z10” is executed by the credit engine and the error message is displayed.

Now lets us see how we can perform the credit check of the given Business partner using the SAP standard Methods which in-turn provides the credit check results based on the newly created Check rule / Check Step.

Lets us create a custom Function Module which can in-turn call the SAP Standard Methods to perform the credit check.

Import Parameters

IM_BP TYPE BU_PARTNER Business Partner Number

IM_VKORG TYPE VKORG Sales Organization / Credit segment

IM_NETWR TYPE NETWR Net Value in Document Currency

IM_WAERS TYPE WAERS Currency Key

Export Parameters

ET_QUERY_RESULTS TYPE UKM_T_QUERY_RESULTS Results of Internal Credit Query

Class CL_UKM_XI_FACADE
Method IF_UKM_CREDIT_QUERY~CHECK_CREDIT

will perform the credit check and provide the results.

Explanation of the Import and export parameters for the Method IF_UKM_CREDIT_QUERY~CHECK_CREDIT

pass the BP / Credit Segment / Order Amount and Currency to the export parameter it_items which will return the Credit check results in the importing parameter et_query_results.

In this example, Credit segment is created for each Sales org with the same name as Sales org, hence Sales Org value is passed to the credit segment in the variable lv_creditsegment.

FUNCTION zbp_credit_check.
*"----------------------------------------------------------------------
*"*"Local Interface:
*"  IMPORTING
*"     VALUE(IM_BP) TYPE  BU_PARTNER
*"     VALUE(IM_VKORG) TYPE  VKORG
*"     VALUE(IM_NETWR) TYPE  NETWR
*"     VALUE(IM_WAERS) TYPE  WAERS
*"  EXPORTING
*"     REFERENCE(ET_QUERY_RESULTS) TYPE  UKM_T_QUERY_RESULTS
*"     REFERENCE(EV_DENIAL_REASON) TYPE  CHAR250
*"----------------------------------------------------------------------

  DATA: lt_items          TYPE ukm_t_check_item,
        lt_denial_reasons TYPE ukm_t_denial_reason.

  DATA : lv_creditsegment TYPE ukm_credit_sgmnt,
         lv_net_amount    TYPE ukm_comm_actual_item.

  CLEAR : lv_creditsegment, lv_net_amount.
  lv_creditsegment = im_vkorg.
  lv_net_amount = im_netwr.

  lt_items = VALUE #( ( partner       = im_bp
                        credit_sgmnt  = lv_creditsegment
                        amount        = lv_net_amount
                        currency      = im_waers
                        schedule_data = VALUE #( (  effective_date  = sy-datum
                                                    amount          = lv_net_amount
                                                    currency        = im_waers
                                                    credit_sgmnt    = lv_creditsegment
                                                    partner         = im_bp ) ) ) ).

**** Method IF_UKM_CREDIT_QUERY~CHECK_CREDIT of Class CL_UKM_XI_FACADE
**** will perform the credit check and provide the results
  TRY.
      cl_ukm_xi_facade=>if_ukm_credit_query~check_credit(
        EXPORTING it_items         = lt_items
        IMPORTING et_query_results = et_query_results ).
  ENDTRY.

  IF et_query_results[ 1 ]-passed IS INITIAL.
***    Credit Check is failed

    lt_denial_reasons = et_query_results[ 1 ]-denial_reasons.

    LOOP AT lt_denial_reasons INTO DATA(ls_denial_reason) WHERE msgty = 'E'.

      CALL FUNCTION 'FORMAT_MESSAGE'
        EXPORTING
          id        = ls_denial_reason-msgid
          lang      = sy-langu
          no        = ls_denial_reason-msgno
          v1        = ls_denial_reason-msgv1
          v2        = ls_denial_reason-msgv2
          v3        = ls_denial_reason-msgv3
          v4        = ls_denial_reason-msgv4
        IMPORTING
          msg       = ev_denial_reason
        EXCEPTIONS
          not_found = 1
          OTHERS    = 2.
      IF sy-subrc <> 0.
* Implement suitable error handling here
      ENDIF.


    ENDLOOP.

  ELSE.
***    Credit check is successful

  ENDIF.
ENDFUNCTION.

In the credit check result internal table parameter et_query_results if the parameter PASSED = ‘X’, then credit check is successful and if the parameter PASSED = space then credit check is failed.

  IF et_query_results[ 1 ]-passed IS INITIAL.
***    Credit Check is failed

  ELSE.

***    Credit check is successful

  ENDIF.

If the Credit check is failed, the denial reason is captured and sent by the method in the field denial_reasons in the internal table et_query_results

Take the necessary action based on the Credit check results

Create variable lt_denial_reason of type UKM_T_DENIAL_REASON and populate the denial reason.

lt_denial_reasons = et_query_results[ 1 ]-denial_reasons.

    LOOP AT lt_denial_reasons INTO DATA(ls_denial_reason) WHERE msgty = 'E'.

    ENDLOOP.

In the above screenshot, the Business partner has bee assigned with the Credit check rule “Z2”.

Function Module will return the Denial reason similar to Simulation that was performed in the previous step.

Note :- The Error Message “Custom - Credit Check Blocked for all Scenarios” is raised from the Custom Credit check step configured and enabled in the above steps.

BADI UKM_CHECK_STEP and BADI Implementation ZIM_CUSTOM_CHECK is called when the credit check is performed using the SAP standard Method IF_UKM_CREDIT_QUERY~CHECK_CREDIT of Class CL_UKM_XI_FACADE.

Hope this blogs helps to understand the implementation of custom credit check.

Thanks all for your visit and support, please give Kudos if you like this page and provide comments.

SAP Table Creation, Maintenance, and Authorization

2024-04-02T01:06:55.258000+02:00

Creating Custom Tables for Table Maintenance

Go to SE11 and give the table name that you want to create.

Give the Description of the table and enter the following details.

1. Delivery Class

Delivery Class Used For

A - Application table (master and transaction data).
C -Customer table: data is maintained by the customer only
L - Table for storing temporary data
G - Customer table, SAP may insert new data records, but may not overwrite or delete existing data records. The customer namespace must be defined in table TRESC. (Use Report RDDKOR54 here).
E - System table with its own namespaces for customer entries. The customer namespace must be defined in table TRESC. (Use Report RDDKOR54 here.)
S - System table, data changes have the same status as program changes.
W - System table (e.g. table of the development environment) whose data is transported with its own transport objects (e.g. R3TR PROG, R3TR TABL, etc.).

2. Data Browser/Table View Maint.

Options Available

Display/maintenance not allowed: The usage of standard table maintenance tools is not allowed.
- Maintenance and display of this Dictionary object is not possible in transaction SE16.
- Transaction SE54 does not allow the generation of a maintenance dialog, which means automatically calling transactions SM30/SM34 for this Dictionary object is no longer possible.
Display/maintenance allowed to limited extent: Usage of standard table maintenance tools is allowed to a limited extent.
- Transaction SE16 allows the display function for this Dictionary object, but no maintenance.
- Generation of a maintenance dialog for this Dictionary object is possible using transaction SE54.
- Transaction SM30 does not allow maintenance and display functions for this Dictionary object
Display/maintenance allowed: The usage of standard table maintenance tools is allowed:
- Transaction SE16 allows the maintenance and display functions for this Dictionary object. Note: If an SM30 maintenance dialog exists for this Dictionary object, it is called.
- Transaction SE54 allows the generation of a maintenance dialog for this Dictionary object.
- Transaction SM30 allows the display and maintenance functions for this Dictionary object.

Enter the Fields of the table.

Significance of the Above fields:

LASTCHANGED: Username of the person who created or changed the data.
CHANGEDATE: The date on which the records was created or changed.
CHANGE_TIME: The time on which the records was created or changed.
COMMENTS: The reason for the changes made to be specified by the user.

Once all the fields have been entered then, click on Technical Settings and enter the following details on the next screen:

Data Class

The data class defines the physical area of the database (for ORACLE, the TABLESPACE) in which your table is logically stored. If you choose a data class correctly, your table will automatically be assigned to the correct area when it is created on the database.

The most important data classes are (other than the system data):

APPL0: Master data
APPL1: Transaction data
APPL2: Organizational and customizing data

Master data is data that is frequently read but rarely updated. Transaction data is data that is frequently updated. Organizational and customizing data is data that is defined when the system is initialized and then rarely changed.

Two more data classes are available, USR and USR1. These are reserved for user developments, and the tables assigned to these data classes are stored in a table space for user developments.

Note: The data class only has an effect on table storage for the database systems ORACLE and INFORMIX.

Size Category

The size category determines the probable space requirement for a table in the database.

You can select categories 0 to 4 for your table. Each category is assigned a specific fixed storage area value in the database. When you create a table, initial space is saved for it in the database. If more space is required later due to data that has been entered, the storage space is increased in accordance with the category selected.

Press F4 on the field size category to see the number of data records that can be maintained for the individual categories of your table without complications ensuing. These complications could be for example a reorganization becoming necessary because the maximum space to be reserved for the table was exceeded due to the maintained size category.

Buffering Status

The buffering status specifies whether or not a table may be buffered.

This depends on how the table is used, for example, on the expected volume of data in the table or on the type of access to a table (mainly read or mainly write access to the table). In the latter case, for example, one would not select buffering.

You should, therefore, select:

Buffering is not allowed if a table is not buffered.
Buffering allowed but not activated if buffering is principally allowed for a table, but at the moment no buffering should be active. The buffering type specified in this case is only a suggestion.
Buffering is allowed if the table should be buffered. In this case, a buffering type must be specified.

Buffering Type

The buffering type defines whether and how the table should be buffered.

There are the following types of buffering:

single-record buffering --> Press F1 for more details
generic area buffering --> Press F1 for more details
full buffering --> Press F1 for more details

In generic area buffering, a number of key fields between 1 and no. of key fields-1 must be specified.

No. Of Key Fields for Generic Buffers

If you read a record from a generically buffered table, all records whose left-justified part of the key corresponds to that of this record (generic key fields) are loaded into the buffer.

This left-justified part of the key is determined in this field by entering a number n of key fields. The first n key fields of the table are thus the generic key fields.

Create Authorization Object

To create an Authorization Object, go to transaction SE54.

Enter the Table/View name for which the Authorization object has to be created.

Select the Radio Button ‘Authorization groups’.

Then click on Create/Change.

Then, the next screen will give a list of Authorization Objects that are already present in the system. You can Select one of them from the available list as per the requirement. But if the table demands a new authorization object then click on New Entries pushbutton given on the screen.

Enter the new authorization object name and description as shown in the screen below. The authorization object must follow a certain naming convention. (It should always start with 'Z'.) Click on Save

Table Maintenance Generator

Go to SE12 transaction. Open the table for which the table maintenance is to be implemented.
Change it to the Editable mode and then click on Utilities -> Table maintenance generator.

Enter the following details on the next screen:

Authorization group: Assigned/created for the table by following the procedure given in Section I.
Function group: Name of the function group to which the generated maintenance modules will belong.
Maintenance type: According to the table requirement, anyone should be selected.
- One step: Only one maintenance screen is processed during extended table maintenance. The entries are displayed in list form on this screen.
- Two step: Two maintenance screens are processed during the extended table maintenance:

On the Overview screen, the entries are displayed in list form.

One entry is displayed on the single screen. For every entry, the single screen can be called from the overview screen by pressing the function key.

Maintenance Screen No

According to the maintenance type selected, an overview screen and a single screen should be entered. Recording routine—This is an indicator of the recording routine that should be used for the table contents.

Standard recording routine
No, or user, recording routine

Compare Flag

This flag indicates whether the maintenance transaction allows the (checked) activation of Business Configuration Sets (BC Sets) and the adjustment. This is the case if the maintenance transaction can run in the background. There are four options present for the compare flag:

No Information
Not Adjustable
Adjustable in Dialog
Automatically Adjustable

Once done. Click on Create.

Exceptions

If changes are made to the table after the generation of table maintenance, table maintenance should be re-generated for the table.

1. Click on Utilities -> Table Maintenance Generator.

2. Click on the Edit button. A pop-up would ask for Reason for change. Select the appropriate reasons.

3. Then, Save the data.

4. Go to System -> Status and copy the Program Name.

Changing the Source Code of Table Maintenance

If fields like last changed on, last changed by, etc., are present in the table, logic should be included to save them by the system.

1. Go to transaction SE80 and open the program that was received from the above logic.

2. Go to the Screens drop-down list and click on 0001. In the PAI event of that screen, add a module to include the logic.

3. Double-click on the module. It will ask for the ‘Include’ in which this module should be included.

4. Select the Include where we need to include the logic.

5. Enter the logic to update the table with the parameters --> person responsible for making change, timestamp, etc. It is as shown below:

6. Go to the layout of the screen

7. Once you click on the Layout button, the screen below will appear.

8. Enter the text to be displayed as the column heading in the output screen.

9. Change the attributes of the fields of the table that are required to be non-editable as 'OUTPUT ONLY', i.e., the fields LASTCHANGED, CHANGEDATE, and CHANGE_TIME. The Columns will automatically be grayed out and uneditable on the output screen.

10. Save and Activate the changes.

Create Transaction

1. To create a transaction, go to transaction SE93. Enter the transaction name which is to be created.

2. Click on Create.

3. Enter the Short text and the Start Object and select Ok.

4. Enter the below details and the Click on SAVE

5. Enter the created T-code and the below screen would appear as output.

6. Click on the New Entries button to create an entry in the table. Enter the details and then click on SAVE.

7. As soon as you click on the save button the username, Date and Time appears automatically.

8. You can check the same data in the Se16 transaction for the table.

Conclusion:

I hope I was able to give you a little insight into how the you can create, maintain and add security on a custom SAP table.

I would love to hear back suggestions, feedback and questions that you might have. Please do share the article with your Team members, Colleagues and Friends working in SAP and who use or plan to use SAP custom table to maintain critical data in SAP. Also, don’t forget to like and share the blog and follow me on SAP blogs to not miss more content: maheshsinghmony

Reference: https://dzone.com/articles/sap-table-creation-maintenance-and-authorization

Exploring SAP Extensibility - Types of Extensibilities

2024-04-02T22:28:55.301000+02:00

In this blog post, I will give a brief explanation of the types of extensibilities offered by SAP: Key User (In-App) Extensibility, Developer (On-Stack) Extensibility, and Side-by-Side Extensibility on SAP Business Technology Platform (BTP). The intention is to provide just a brief summary for each type of extensibility available.

Firstly, why is extensibility necessary? Despite SAP offering numerous standard solutions, there are instances where these solutions fail to align with the unique requirements of a client's business logic. Consequently, there is the necessity to customize the standard solutions provided by SAP to fulfill these specific requirements.

Key User (In-App) Extensibility:

Functionality: This extensibility type allows the customization of SAP Fiori apps, add application logic, create custom fields, expose data, develop custom forms, email templates, analytics, and business objects mostly without a single line of code.
Targets: It is aimed at business users responsible for configuring and customizing SAP systems.
Development Tools: SAP Fiori apps, Business Add-Ins (BAdIs), Core Data Services (CDS), SAP BAS, and SAP BTP.
Technical Implementation: Key users can modify existing Fiori apps, integrate custom logic through BAdIs, extend standard business objects, generate custom CDS views and APIs, customize forms and email templates and develop custom analytics using CDS views.

Here's a video showing some examples of In-App Extensions: https://www.youtube.com/watch?v=pOOORn7fIR0

Here’s a scenario example of a Key User Extensibility: https://extensibilityexplorer.cfapps.eu10.hana.ondemand.com/ExtensibilityExplorer/#/ExtScenario/351

If you would like to implement this scenario you can follow this setup guide: https://help.sap.com/docs/SAP_EXTENSIBILITY_EXPLORER/397bf26514884cc8a5ece65970e8e3e6/3f898d6f59254ef497f00c78423cec7a.html

Developer (On-Stack) Extensibility:

Functionality: This extensibility provides flexibility to extend standard processes, develop custom OData services, and build custom APIs while isolating custom code from the digital core.
Targets: It is aimed at ABAP developers.
Development Tools: ABAP Development Tools in Eclipse and SAP Business Application Studio (BAS).
Technical Implementation: Developers can utilize ABAP RESTful application programming model, CDS views, released DDIC objects, and local APIs to extend standard processes and develop custom services.

Image Source: https://community.sap.com/t5/enterprise-resource-planning-blogs-by-sap/sap-s-4hana-extensibility-simplified-guide-for-beginners/ba-p/13548988

Here’s a scenario example of a Developer Extensibility: https://extensibilityexplorer.cfapps.eu10.hana.ondemand.com/ExtensibilityExplorer/#/ExtScenario/2851

If you would like to implement this scenario you can follow this setup guide: https://help.sap.com/docs/SAP_EXTENSIBILITY_EXPLORER/c87ef8f108e147d6b7143fd3c0fb1459/5d131ae128ed4b4fae521dc3bf798c88.html

Here’s a quick explanation and examples of RAP Extensibility: https://www.youtube.com/watch?v=YNOa1c0BxR0

Side-by-Side Extensibility on SAP BTP:

Functionality: SAP BTP serves as a unified platform for extending both cloud-based and on-premises SAP solutions, offering integration capabilities at various levels.
Targets: It is suitable for JavaScript, Java developers with cloud-native expertise, and ABAP developers.
Development Tools: Cloud-native tools and services provided by SAP BTP, such as SAP CAP, SAP Fiori tools, and SAP BAS.
Technical Implementation: Implemented using cloud-native technologies and services within SAP BTP.

Image Source: https://community.sap.com/t5/enterprise-resource-planning-blogs-by-sap/sap-s-4hana-extensibility-simplified-guide-for-beginners/ba-p/13548988

Here’s a scenario example of a side-by-side extensibility: https://extensibilityexplorer.cfapps.eu10.hana.ondemand.com/ExtensibilityExplorer/#/ExtScenario/310

If you would like to implement this scenario you can follow this setup guide: https://help.sap.com/docs/SAP_EXTENSIBILITY_EXPLORER/b0e8d558ba2f47f5b02a3fc0ac9edc34/c9520e9b67dc4d04bdae124f46c23bff.html

Developer (On-Stack) Extensibility VS Side-by-Side Extensibility on SAP BTP:

In summary the Developer (On-Stack) Extensibility is ideal for extending standard SAP processes and functionalities within SAP S/4HANA, maintaining tight integration with the digital core while the Side-by-Side Extensibility on SAP BTP is suited for developing independent applications or extensions that enhance and extend the capabilities of SAP solutions, enabling agility and innovation in addressing specific business needs.

Conclusion: SAP's extensibility options provide organizations with the flexibility and scalability needed to adapt their ERP solutions to evolving business requirements. Whether it's extending standard SAP processes within SAP S/4HANA or developing standalone applications on SAP BTP, businesses can leverage these extensibility capabilities to drive agility, innovation, and growth in today's dynamic business landscape. I hope that with this blog you now have a more clear understanding of the different type of extensibilities there are and which ones your work assigns to.

If you want to have a more detailed vision of SAP Extensibility read this blog from @Raja - https://community.sap.com/t5/enterprise-resource-planning-blogs-by-sap/sap-s-4hana-extensibility-simplified-guide-for-beginners/ba-p/13548988 (Thank you @PedroLopes for the share).

Workload Analysis for HANA Platform Series - 3. Identify the Memory Consumption

2024-04-08T18:25:56.713000+02:00

In our previous blog, we explored the essentials of CPU analysis. Today, we shift our focus to memory-related workload patterns in SAP HANA, aiming to derive actionable insights for optimizing memory resource utilization in the HANA system.

Grasping the SAP HANA Memory Components

Effective memory consumption analysis in SAP HANA begins with a thorough understanding of its memory components. SAP HANA's memory architecture comprises various elements, each with distinct functions or usage patterns, as detailed in SAP Note 1999997 - FAQ: SAP HANA Memory. In this article, we concentrate specifically on memory utilized by HANA services.

SAP HANA's used memory is primarily categorized into shared memory and heap memory. Shared memory stores system information and row store tables. Typically, shared memory poses minimal performance risks. However, exceptions occur, such as in BW on HANA systems with extensive row store tables, where excessive shared memory usage might trigger frequent out-of-memory dumps.

Heap memory, on the other hand, is an exclusive domain accessible only by a process's threads. This segment is our primary focus, as significant fluctuations in heap memory often correlate with performance issues and system instability. Identifying workload patterns here is crucial, particularly when a single costly statement or an impractical parameter (e.g., inefficient memory garbage collection) exists without appropriate workload management strategies (like workload classes). Understanding heap memory intricacies is thus imperative.

Within heap memory, our primary concerns include, but are not limited to:

Column Store
Page Cache
Other Heap Allocators
Intermediate Results
Fragmentation

Initiating Memory Consumption Analysis in SAP HANA

Having familiarized ourselves with SAP HANA's memory components, the next step is to pinpoint potential causes of high memory usage across these components, aligning this investigation with workload patterns, particularly in heap memory. Let's delve deeper into each sub-component:

In optimally configured systems, the column store often occupies about half of the heap memory. Implementing a sensible data retention policy helps maintain stability in this area. However, challenges like uncontrolled table logs, redundant data, and inadequate partitions leading to excessive memory loads often inflate the column store's size.
A disproportionately large page allocator typically signals an overextended child allocator, such as page caches. Identifying and optimizing the underlying child allocator is crucial. For instance, size of page allocator "Pool/PersistenceManager/PersistentSpace/DefaultLPA" significantly impacted by page caches, including data, LOB, or shadow pages. Proper table sizing and specific settings (like file or hybrid LOBs) are key to managing this memory consumption.
Analyzing other heap allocators and intermediate results is complex, as these areas are closely tied to costly statements and execution engines. SAP Note 1999997 - FAQ: SAP HANA Memory details frequent allocators, each providing unique insights. Some allocators point to potential performance issues, which are vital in workload analysis. However, linking high-memory allocators to specific expensive statements can be challenging, as their behavior often results from multiple combined statements.
Memory fragmentation is a common occurrence in HANA systems, but its extent requires careful monitoring. Long-running jobs or increased MVCC versions can hinder garbage collection, leading to continuous memory increase without proper reclamation.
Row stores play a pivotal role in BW on HANA systems. While converting some BW tables from column store to row store might be advantageous, this needs to be judiciously executed. Excessive or oversized row store tables can severely impact heap memory, potentially triggering out-of-memory dumps during job execution. This is because row store tables require full memory loading, unlike column store tables, which load selectively based on pages, columns, or partitions.

Tools for Identifying SAP HANA Memory Patterns

To effectively diagnose memory-related issues in SAP HANA, a variety of tools are at our disposal. While not every situation may be straightforwardly deciphered through these tools, their usage is a critical first step in understanding and addressing potential problems.

Begin with memory-related system views for an initial assessment. These views provide a snapshot of the current memory status:

HANA_Memory_Caches_Overview: Offers an overview of memory caches.
HANA_Memory_ContextMemory: Details memory within specific contexts.
HANA_Memory_Components: Breaks down memory by individual components.
HANA_Memory_MemoryObjects: Lists various memory objects.
HANA_Memory_Overview: Gives a comprehensive view of memory usage.

For analyzing workload over a specific period, the following system monitoring views are invaluable for capturing historical data:

HANA_Memory_Heap_Allocations: Tracks heap memory allocations.
HANA_Memory_Reclaims: Details memory reclamation events.
HANA_Memory_TopConsumers: Identifies the top memory consumers.
HANA_Memory_OutOfMemoryEvents: Records out-of-memory events.
HANA_SQL_SQLCache: Monitors SQL cache usage.
HANA_SQL_ExpensiveStatements: Lists costly SQL statements.

Some monitoring views may not provide direct insights into memory components but are crucial for uncovering underlying memory consumption and related issues:

HOST_SERVICE_THREAD_SAMPLES: Analyzes thread samples on the host.
HOST_LONG_RUNNING_STATEMENTS: Identifies long-running SQL statements.
TABLE_PARTITIONS: Reviews table partition details.
HOST_SERVICE_THREAD_CALLSTACKS: Examines call stacks of service threads.

In the following section, I will present two case studies demonstrating how these tools can be used to identify memory patterns, along with root causes and solutions for common scenarios in SAP HANA.

Analyzing Memory Consumption Issues: Two Practical Examples

Example 1: Analyzing Memory Component Patterns

In SAP HANA memory analysis, the initial step often involves examining the top memory consumers. This is crucial when addressing memory issues or analyzing memory patterns. Let's explore this process with an example, focusing on high-level and detailed components.

Level 1 Memory Usage Analysis
First, we assess the highest level of memory usage. In our demo system, we observed that the column store is a primary memory consumer, reaching approximately 1,500 GB with a continuous growth over a month. The next significant component is heap memory, fluctuating between 500 GB and 1,600 GB. Although heap memory is smaller than the column store in the above example, it demands close attention due to its potential for large consumption variations and complex underlying causes. In this system, row store also holds a significant size (around 200 GB), which, while not critical, should be monitored for growth.
Diving into Level 2 Components
Upon delving into heap memory, we identify sub-components that contribute notably to memory consumption or exhibit significant fluctuations. In this instance, the sub-components 'Heap (Statement Execution & Intermediate Results)', 'Heap (System - Page Cache)', and 'Heap (Monitoring & Statistical data)' are of particular interest. They showed substantial growth or wide-ranging memory consumption over the observed month, signalling potential areas for deeper analysis.
Zooming in on Specific Sub-Components
Further dissecting these level 2 components, we find that 'Heap (System - Page Cache)', for example, is composed of various page caches like:
- Pool/PersistenceManager/PersistentSpace/DefaultLPA/LOBPage
- Pool/PersistenceManager/PersistentSpace/DefaultLPA/DataPage
- Pool/PersistenceManager/PersistentSpace/DefaultLPA/LOBPageControlblock
- Pool/PersistenceManager/PersistentSpace/DefaultLPA/DataPageControlblock

Understanding these detailed components is vital for pinpointing specific issues and guiding thorough analysis. In this case, a potential reason for high memory consumption might be tables with a large number of LOBs. Considering alternatives like hybrid LOBs or converting single file LOBs to packed LOBs could be effective strategies.

Compared to CPU utilization analysis, memory consumption analysis can be more challenging due to its complexity and the need to correlate memory components with specific queries. In our next example, we will explore techniques for capturing statement information and integrating it with memory consumption patterns.

Example 2: Identifying Memory Contributors in SAP HANA

Understanding the root causes of memory consumption is critical in SAP HANA. Often, expensive SQL statements are major contributors, influenced by factors like workload management methods, HANA engine usage, or logical design leading to substantial intermediate results. This analysis aims to pinpoint these contributors and their impact on memory.

When a statement is executed in HANA, it can be processed by different engines, such as the Join, OLAP, or HEX engines. This selection is based on various factors, including table size, partitions, and replicas. Each engine choice affects the behavior of the statement, including execution time, thread involvement, and heap memory consumption. While we won't delve deeply into engine selection, this information is key in tracing the source of high heap memory usage.

Data captured from HANA Service Thread Samples (Please refer to Define and Understand the Workload Pattern), filtered to include thread details with keywords like "JE(", reveals the HANA JOIN engine involved in specific statement executions. By cross-referencing this with top memory consumer data, we can sometimes identify if an expensive statement significantly contributes to heap memory allocation. Typical memory allocators to monitor include:

Pool/JoinEvaluator/JERequestedAttributes/Results
Pool/JoinEvaluator/JECreateNTuple
Pool/JoinEvaluator/JEStep1
Pool/JoinEvaluator/NTuple
etc.

If these allocators show increased activity alongside expensive statement execution, they become potential candidates as major memory contributors. To confirm our findings, we should cross-check with other data sources as well, such as:

HANA SQL CACHE
HANA Expensive Statement Trace
HANA Executed Statement Trace

It's important to note that a high number of running threads does not necessarily equate to significant memory usage. The focus should be on the statement itself and its actual memory impact.

While thread sample analysis is insightful, it’s just one method among many for memory pattern analysis in SAP HANA. We must remember that memory analysis within workload analysis is a vast and complex field.

There are other important aspects, like analyzing Out-of-memory dumps and understanding the objects within the SQL cache. The topic of memory in HANA is extensive and cannot be fully covered in a single article. Moreover, there's no one-size-fits-all approach to memory issue analysis. Future discussions will delve into these and other complex areas of memory management in SAP HANA.

🙉🙈🙊

Workload Analysis for HANA Platform Series

This blog post is part of the 'Workload Analysis for HANA Platform Series'. In upcoming posts, we will demonstrate how to analyze the issue related to CPU, threads and NUMA Node . Here's what you can look forward to in this series:

0. HANA Workload Analysis Overview
1. Define and Understand the Workload Pattern
2. Analyze the CPU, Threads and Numa Utilizations
3. Identify the Memory Consumption (This blog)
4. How the Network, I/O and locks influent the workload
5. Performance Impact by HANA Internal Functions
6. HANA Workload Management Methodology

Stay tuned as we explore these aspects in detail, providing insights and strategies to optimize your HANA environment.

How to find the specific ABAP Code that is updating any Logic in a Smart Way in enhancements also?

2024-04-15T11:45:52.565000+02:00

Procedure 1

For SAP ECC and SAP S/4HANA

Go to Transaction Code SE38 and Execute Program RS_ABAP_SOURCE_SCAN

Provide the below Parameter and Execute

Wala below is the result

Procedure 2

Login to SAP S/4HANA and Go to Transaction Code CODE_SCANNER

Suppose I want to find all the Program/Enhancement that has mentioned the Check " = 'SAP_WFRT' "

In the below screenshot we are only restricting to Z Packages. Now Execute

Wala below is my result.

Procedure 3:

Go to Tcode EWK1

Wala we found this

SAP BTP, ABAP environment, ABAP Connectivity

Debug Application Job on S/4HANA Public Cloud

2024-04-16T13:01:48.420000+02:00

As of today (Apr 10, 2024), SAP has not provided a method to debug application job on S/4HANA Public Cloud (related Question by @rammel ) or provided a method to pass parameters to the class via IF_OO_ADT_CLASSRUN (related Question by @fabianlupa answered by @horst_keller ). Below is a workaround method until SAP provides a way to do either of these options.

Every Class used in a Custom Job catalog uses interfaces IF_APJ_DT_EXEC_OBJECT and IF_APJ_RT_EXEC_OBJECT. IF_APJ_DT_EXEC_OBJECT~GET_PARAMETERS provides the parameter definition and IF_APJ_RT_EXEC_OBJECT~EXECUTE is responsible to receive the job parameters from the caller and execute the business logic.

The idea implemented here, is to create a wrapper to reuse this functionality to call the Execute method. The wrapper is created as a HTTP service so that it can be called from external parties to pass the required parameters.

So, first lets create a HTTP service. If you plan to use the plugin attached here, then please make sure to use the same name for HTTP service as ZSRV_ADT_PLUGIN_EXEC_JOBCLASS, since that name is used in the plugin.

Below is the code I used in the handler class. Please feel free to improvise this class, to have better authorization checks or validations according to your needs.

class zcl_adt_plugin_exec_jobclass definition
  public
  create public .

  public section.

    interfaces if_http_service_extension .
  protected section.
  private section.
endclass.



class zcl_adt_plugin_exec_jobclass implementation.
  method if_http_service_extension~handle_request.
    types: lty_char   type c length 100,
           ltyt_range type range of lty_char.
    data: lo_definition type ref to if_apj_dt_exec_object,
          lo_runtime    type ref to if_apj_rt_exec_object,
          lt_values     type if_apj_rt_exec_object=>tt_templ_val,
          begin of ls_value,
            param type string,
            range type ltyt_range,
          end of ls_value,
          lv_params type string.
    data(lt_form) = request->get_form_fields( ).
    loop at lt_form reference into data(lo_form).
      translate lo_form->name to upper case.
    endloop.
    read table lt_form into data(ls_form) with key name = 'CLASSNAME'.
    if sy-subrc eq 0.
      try.
          translate ls_form-value to upper case.
          create object lo_definition type (ls_form-value).
          create object lo_runtime type (ls_form-value).
          lo_definition->get_parameters( importing et_parameter_def = data(lt_params) ).
        catch cx_root into data(lo_root).
          response->set_text( |Class { ls_form-value } is invalid| ).
          response->set_status( 400 ).
          return.
      endtry.

      case request->get_method( ).
        when 'GET'.
          loop at lt_params into data(ls_param).
            lv_params = lv_params &&
                        cond #( when lv_params is not initial then ',' && cl_abap_char_utilities=>newline ) &&
                        |"{ ls_param-selname }":| &&
                        cond #( when ls_param-kind = 'S' then |[\{"SIGN":"I","OPTION":"EQ","LOW":"","HIGH":""\}]| else |""| ).
          endloop.
          lv_params = |\{{ cl_abap_char_utilities=>newline }{ lv_params }{ cl_abap_char_utilities=>newline }\}|.
          response->set_text( lv_params ).
        when 'POST'.
          try.
              data(lv_body) = request->get_text( ).
              loop at lt_params into ls_param.
                /ui2/cl_json=>deserialize( exporting json          = lv_body
                                                     name_mappings = value #( ( abap = cond #( when ls_param-kind = 'S' then 'RANGE' else 'PARAM' )
                                                                                json = ls_param-selname ) )
                                           changing  data          = ls_value ).
                if ls_param-kind = 'S'.
                  loop at ls_value-range into data(ls_rng).
                    append value #( selname = ls_param-selname sign = ls_rng-sign option = ls_rng-option low = ls_rng-low high = ls_rng-high ) to lt_values.
                  endloop.
                elseif ls_value-param is not initial.
                  append value #( selname = ls_param-selname low = ls_value-param ) to lt_values.
                endif.
                clear ls_value.
              endloop.
              lo_runtime->execute( lt_values ).
            catch cx_root.
              response->set_status( 400 ).
              return.
          endtry.
      endcase.
      response->set_content_type( 'application/json' ).
      response->set_status( 200 ).
    endif.
  endmethod.
endclass.

If you plan to use the custom plugin, then copy the plugin to the plugins folder of your Eclipse installation.

Close the eclipse application and re-open it from command line using command eclipse.exe -clean, so that it re-reads the plugin folder.

Now, logon to SAP system via eclipse. In order to activate debugging request from plugin, please activate the following checkbox, for the ABAP Cloud Project.

Open the custom Job Catalog related to the class that you would like to debug. Once you are the Job Catalog editor, open Run menu. If Eclipse found and installed the plugin correctly, then you should be able to see a new option saying "Run Job Class" as highlighted below. (This option will only be visible while on Job Catalog editor view)

Now, open the related class and add a breakpoint in the Execute method of the Class.

You can now go back to the Job Catalog Editor and select the option "Run Job Class". This will call the custom HTTP service that was created and which will internally create a JSON payload of the parameter list. It will then popup a dialog for you to edit the JSON.

Modify the payload to pass values to each of the provided parameters in the JSON and hit OK.

If you have setup everything right, then a new Debugger session will start and break at the breakpoint that you have set earlier.

If you do not plan to use the plugin, other options may be to use tools like Postman or Restman to GET or POST, JSON payloads to the custom HTTP service.

Plugin can be downloaded from here.

Capture Your Own Workload Statistics in the ABAP Environment in the Cloud

2024-04-18T13:02:05.620000+02:00

As an administrator in SAP BTP, ABAP environment or in SAP S/4HANA Cloud ABAP Environment, it’s important to keep track of performance issues and identify bottlenecks. Now SAP offers a few Fiori apps to help you with monitoring the system workload. However, relying on what data the system automatically collects for you sometimes isn’t enough.

Instead, you want to define yourself what kind of workload information is captured, such as in the following use cases:

Standard apps and tools show you that there’s a high workload, but when you drill down to details, you don’t get the information you’re interested in.
You want to monitor the workload of a clearly defined special case, such as the workload generated by a user or by one of your custom apps (which you might want to watch using its request entry point).
You have specific requests where you want to get alerted when the workload, for example, exceeds a defined threshold.

In this blog post, I’ll show you how to use the Capture Request Statistics app to cover these use cases.

Background: the System Workload App

Before I introduce you to the Capture Request Statistics app, let me start with a brief recap of what the System Workload app can do for you out of the box (for more details, see the blog post Analyzing performance degradations in the ABAP environment in the Cloud).

Let’s say you want to analyze the performance of your ABAP system in the System Workload app:

System Workload app

You find the top resource-consuming application in the system and want to analyze it further. You can analyze this application in more detail by choosing the Details arrow at the end of the row. In the following screen, you typically find samples of single ABAP statistics records for this workload. Now, how are these ABAP statistics records collected by default and how can you influence what is captured? Let's take a look behind the scenes.

Default Configuration: Capture Workload Statistics with Static Thresholds

An ABAP Environment in the Cloud comes with pre-delivered SAP profiles that capture ABAP statistics records in your system. You can find these pre-delivered SAP profiles in the Capture Request Statistics app:

Pre-delivered SAP profiles

These profiles ensure that the statistics about “bad” requests - meaning a high consumption of compute resources – are captured in the system. If you look, for example, at the details of the static profile for expensive requests regarding server response time, you find a static threshold of 1 second:

Pre-delivered SAP profile - capture requests with high server response time

With this profile always active, ABAP statistics records with an ABAP server response time larger than 1 second are captured and stored. Similarly, the other pre-delivered static profiles capture requests that exceed 1 second regarding HANA CPU time, ABAP CPU time, etc.

In the profile header, you can find that for the SAP-delivered profiles, a sampling rate of 1% has been set. It means that only 1% of the records that fulfill the filter condition will be captured. In addition, the record limit per minute is set to 50. The periodic data collector that runs every minute and processes the ABAP statistics records (together with the profiles in the Capture Request Statistics app) will only store the ABAP statistics records up to this limit in the database. So, if many ABAP statistics records fulfill the filter condition at a time, not all of these records will be stored.

For SAP-delivered profiles, this low record limit per minute together with the low sampling rate ensures that the workload and data footprint for processing and storing monitoring data in your system stay low, even if the overall business workload on the system gets exceedingly high.

Default Configuration: Capture Workload Statistics Dynamically

In addition to the pre-delivered static profiles, the dynamic SAP profile SAP_DYNAMIC_CAPTURING ensures that for the top workload of your system “good” statistic samples of requests are also captured (with respect to the server response time). As a result, you can compare statistics of samples of “bad” workload to statistics of samples of “good” workload. The top workload in your system might vary as well as the behavior in response times. The dynamic profile adapts to these changes.

In addition, for the top workload, the dynamic profile captures samples of ABAP statistics when their server response times deviate too much from the average server response time of this specific kind of workload. This ensures that for workloads with typically different server response times, samples of ABAP statistics records are also at hand, even if their server response times do not exceed the static thresholds of the static profile types.

In principle, the pre-delivered static profiles together with the dynamic profile will give you a high chance that for your top workload, you’ll find samples of ABAP statistics records in the system that you can use for detailed analysis. You get this data using the System Workload app and by drilling down to the ABAP statistics records, and in most of the cases, that’s enough. However, as these statistics are sampled, it might happen that sometimes you don't find any records that you can use for further analysis:

System Workload app - no detailed statistics available

To have these detailed statistics for your root cause analysis, you can capture your own workload statistics in your ABAP environment in the Cloud.

Capture Your Own Workload Statistics in the Capture Request Statistics App

You can create your own capture profiles, of course. While the SAP profiles are designed in such a way that they capture samples of ABAP statistics records for generic expensive workload in the ABAP tenant, you might want to specify the workload more concretely. For example, you might be interested specifically in the ABAP statistics records of your user or of a certain outbound communication arrangement. Or you might be interested in workload that exceeds a specific threshold (as in the pre-delivered SAP profiles). To do so, you can create your own capture profile.

If, for example, you have built a new ABAP RESTful application for travel bookings, you could define a profile that filters on its specific request entry point (consisting of request entry name and request entry type):

Custom profile

A custom profile is in status Inactive when newly created. If you click on the Activate button, the profile status will be set to status Processing, and only then will the data collector process ABAP statistics records that fulfill the defined filter conditions. On activation of the profile, you also need to specify the duration of how long the profile should be active. When the duration is exceeded and all the relevant ABAP statistics records are processed, the profile will be set to status Finished and no further ABAP statistics records will be processed for this profile.

In the example profile shown here, a sampling rate of 100% and a record limit per minute of 1000 has been set. Both are the maximum possible values. This setting guarantees that all ABAP statistics records fulfilling the filter conditions are captured. Of course, if the record limit of 1000 is exceeded, you won’t capture everything. But this happens only in rare cases. In any case, it’s ensured that also for a badly designed capture profile, your business is not impacted by the additional workload of capturing request statistics.

The target user group in the profile header indicates that only workload is considered that is running in customer user context. You can specify this further by considering, for example, only customer communication users or customer business users.

If the profile is active and users are performing actions in your ABAP RESTful application, the according ABAP statistics records are captured and stored in the database for a period that you have defined in the retention time of your profile.

For further analysis, e.g., the performance of a new app that you have built, you can navigate to the captured ABAP statistics records by clicking on Analyze Request Statistics. There you can analyze the captured single ABAP statistics records in detail and obtain insights into the behavior of your newly created app:

Analyze ABAP statistics records in detail

You can find more information, for example, about SQL statements or, in the case of communication, about HTTP calls by choosing the Details arrow at the end of a row, which leads you to the details of that ABAP statistics record.

If your new application belongs to the more expensive workload in the system, you’ll easily find the captured ABAP statistics records also in the System Workload app. There, you start from the overall workload (aggregated ABAP statistics records) of your business tenants. If you drill down to the details of your application, you will get to the ABAP statistics records. Your custom profile ensures that they have been captured:

System Workload app - detailed statistics available

Note: With the Capture Request Statistics app, you can also define profiles with profile type SQL Trace. With these profiles, you can trace the execution of SQL statements. These captured SQL statements can be further analyzed in the SQL Trace Analysis app. This might be another story for another blog post in the future, so stay tuned.

You can find more information about the Capture Request Statistics app in the following documentation:

Getting Notified About Specific Workloads

You may have noticed that by defining a custom capture profile for capturing ABAP statistics records, you can set the option for Health Monitoring. If you have connected your SAP BTP, ABAP environment or SAP S/4HANA Cloud ABAP Environment tenant to SAP Cloud ALM, you’ll receive a counter per capture request statistics profile in SAP Cloud ALM for Operations in the Health Monitoring app. You can find more information on how to connect your tenant to SAP Cloud ALM here:

For our custom profile example Z_STATIC_PROFILE, you’ll find the tile Captured ABAP Statistics Records in the Health Monitoring app in your connected SAP Cloud ALM tenant. If you click on the tile for details, you find your custom profile together with a counter

SAP Cloud ALM - Health Monitoring

This counter is normalized to 5 minutes. This means that during the last 5 minutes, 27 ABAP statistics records were captured in your ABAP tenant that fulfill the filter conditions that you have defined in your custom profile. Besides this usage scenario, you can also use the Health Monitoring feature on capture profiles with static thresholds (like in the case of the pre-delivered static SAP profiles) to count how often your defined thresholds are exceeded. For more information, see also the blog post Monitoring the Performance of Outbound Communication in the ABAP Environment in the Cloud.

If you want to get alerted by email when the filter conditions of your profile are hit a certain number of times, you can configure alerts in SAP Cloud ALM in the Health Monitoring app. For more information, see the blog post Monitoring the Health of the ABAP System in the Cloud.

Summary

The default configuration of your SAP BTP, ABAP environment or SAP S/4HANA Cloud ABAP Environment tenant comes with pre-delivered SAP profiles that capture ABAP statistics records for the most important workload in your system. This helps you analyze and understand your system workload in detail.

However, if you want to enhance this default configuration, you can do so by creating your own profiles using the Capture Request Statistics app. The monitoring data collector ensures that requests that fulfill your filter conditions are captured and stored in the system for further analysis. You can define profiles for capturing ABAP statistics records and for capturing SQL statements.

Let’s quickly recap in which use cases creating your own profiles in the Capture Request Statistics app is useful:

In your standard system-local analysis of the system behavior, detailed statistics are missing for a certain workload that you need to have at hand.
You want to proactively capture extensive details for a workload of your choice to analyze it in detail.
In SAP Cloud ALM, you want to understand how often your workload in the landscape hits certain criteria (= your filter conditions defined in the profiles), and you want to get alerted in this case

I’d like to thank everyone who contributed to this blog post, especially my colleagues @anke_griesbaum, @Karen_Kuck, @SabineReich, and @steffen_siegmund.

Let me know in the comments if and how you’ve used the Capture Request Statistics app and what you think of it.

SAP S/4HANA Cloud ABAP开发案例之八：物料临期管理App

2024-04-19T09:11:36.318000+02:00

紧随这篇博客，今天我们将再次逐步详细地介绍一个利用SAP S/4HANA Cloud三系统来做开发扩展的案例。

1. 案例背景

我们经常听到启用批次管理的客户在问是否有对临近效期物料的提醒、是否有对临近效期物料的批量查询报表，在标准产品中要查询相关信息需要检索多张报表，比如库存报表、批次信息等。通过利用开发人员可扩展性，我们开发了一个定制的物料临期管理App，并嵌入到SAP S/4HANA Cloud系统中。旨在帮助企业智能化地管理物料效期，提高供应链管理效率。关于业务上该自开发案例的价值，可参考此博客。

每个企业由于不同业务管理需要，可能对临近效期的提醒范围定义不同，我们还开发了警示灯自定义阈值配置app，用户可以自定义设置效期多少范围需显示为红灯，多少范围需显示为黄灯，多少范围需显示为绿灯，自定义设置满足不同企业客制化效期管理需求。

2. 后台服务开发

2.1 创建CDS数据模型

创建数据定义YCDS_DUE_MAT_LIST

@AbapCatalog.sqlViewName: 'YDUEMATMANGE'
@AbapCatalog.compiler.compareFilter: true
//@AbapCatalog.preserveKey: true
@AccessControl.authorizationCheck: #CHECK
@EndUserText.label: 'Material Due Date List'
define view YCDS_DUE_MAT_LIST as select from I_Batch
inner join YCDS_SUM_STOCK_01 on YCDS_SUM_STOCK_01.Material = I_Batch.Material
                                       and YCDS_SUM_STOCK_01.Plant = I_Batch.Plant
                                       and YCDS_SUM_STOCK_01.Batch = I_Batch.Batch
association [1..1] to I_Product on I_Product.Product = I_Batch.Material
association [1..1] to I_ProductDescription on I_ProductDescription.Product = I_Batch.Material
                                          and I_ProductDescription.Language = $session.system_language
association [1..1] to I_Plant on I_Plant.Plant = I_Batch.Plant
                              and I_Plant.Language = $session.system_language
association [1..1] to I_Supplier on I_Supplier.Supplier = I_Batch.Supplier                           
{
  key I_Batch.Material,
  key I_Batch.Batch,
  key I_Batch.Plant,
  key I_Batch.Supplier,
  key I_Batch.BatchBySupplier,
//  key YCDS_SUM_STOCK_01.InventoryStockType,
//  key YCDS_SUM_STOCK_01.MatlDocLatestPostgDate,
  YCDS_SUM_STOCK_01.StorageLocation,
  YCDS_SUM_STOCK_01.MatlWrhsStkQtyInMatlBaseUnit,
  I_Batch.MatlBatchIsInRstrcdUseStock,
  I_Batch.ShelfLifeExpirationDate,
  I_Batch.ManufactureDate,
  I_Product.BaseUnit,
  I_ProductDescription.ProductDescription,
  I_Plant.PlantName,
  I_Supplier.SupplierName,
  case when I_Batch.MatlBatchIsInRstrcdUseStock = 'X' then 'Restricted' else 'Unrestricted' end as BatchStatus,
  $session.system_date as curr_date
}
where I_Batch.ShelfLifeExpirationDate is not initial
  and YCDS_SUM_STOCK_01.MatlWrhsStkQtyInMatlBaseUnit <> 0

创建数据定义YCDS_DUE_MAT_LIST2

@AbapCatalog.sqlViewName: 'YDUEMATMANGE2'
@AbapCatalog.compiler.compareFilter: true
@AbapCatalog.preserveKey: true
@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Material Due Date List'
define view YCDS_DUE_MAT_LIST2 as select from YCDS_DUE_MAT_LIST
association [1..1] to I_StorageLocation on I_StorageLocation.StorageLocation = YCDS_DUE_MAT_LIST.StorageLocation
                                       and I_StorageLocation.Plant           = YCDS_DUE_MAT_LIST.Plant
{
  key YCDS_DUE_MAT_LIST.Material,
  key YCDS_DUE_MAT_LIST.Plant,
  key YCDS_DUE_MAT_LIST.StorageLocation,
  key YCDS_DUE_MAT_LIST.Batch,
  key YCDS_DUE_MAT_LIST.Supplier,
//  key YCDS_DUE_MAT_LIST.InventoryStockType,
//  key YCDS_DUE_MAT_LIST.MatlDocLatestPostgDate,
  YCDS_DUE_MAT_LIST.ProductDescription,
  YCDS_DUE_MAT_LIST.PlantName,
  I_StorageLocation.StorageLocationName,
  YCDS_DUE_MAT_LIST.BatchBySupplier,
  YCDS_DUE_MAT_LIST.SupplierName,
  MatlWrhsStkQtyInMatlBaseUnit,
  YCDS_DUE_MAT_LIST.BaseUnit,
  YCDS_DUE_MAT_LIST.ShelfLifeExpirationDate,
  YCDS_DUE_MAT_LIST.ManufactureDate,
  YCDS_DUE_MAT_LIST.BatchStatus,
  dats_days_between(YCDS_DUE_MAT_LIST.curr_date,YCDS_DUE_MAT_LIST.ShelfLifeExpirationDate) as remaining_days
}

创建数据定义YCDS_SUM_STOCK_01

@AbapCatalog.viewEnhancementCategory: [#NONE]
@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Sum of Stock 01'
@Metadata.ignorePropagatedAnnotations: true
@ObjectModel.usageType:{
  serviceQuality: #X,
  sizeCategory: #S,
  dataClass: #MIXED
}
define view entity YCDS_SUM_STOCK_01 as select from I_MaterialStock_2
{
  key Material,
  key Plant,
  key StorageLocation,
  key Batch,
  key MaterialBaseUnit,
  @Semantics.quantity.unitOfMeasure: 'MaterialBaseUnit'
  @Aggregation.default: #SUM
  sum( MatlWrhsStkQtyInMatlBaseUnit ) as MatlWrhsStkQtyInMatlBaseUnit
}
where InventoryStockType = '01'
group by Material, Plant, StorageLocation, Batch, MaterialBaseUnit

2.2 创建Metadata Extensions

创建新的Metadata Extension：YC_DUE_MAT_LIST

@Metadata.layer: #CUSTOMER

@UI.headerInfo.title.type: #STANDARD
@UI.headerInfo.title.label: 'Material Shelf Life Management'
@UI.headerInfo.description.type: #STANDARD
@UI.headerInfo.typeName: 'Material Due List'
@UI.headerInfo.typeNamePlural: 'Material Shelf Life Management'

annotate view YC_DUE_MAT_LIST with
{

  @UI.facet: [{ id: 'Material',
                purpose: #STANDARD,
                type: #IDENTIFICATION_REFERENCE,
                label: 'Material',
                position: 10}
                 ]

  @UI:{ lineItem: [{ position: 10 }],
        lineItem: [{label: 'Material'}],
        identification: [{ position: 10 }],
        selectionField: [{ position: 20 }]
        }
  Material;
  @UI:{ lineItem: [{ position: 20 }],
        lineItem: [{label: 'Material Description'} ],
        identification: [{ position: 20 }]
        }
  @UI.lineItem: [{exclude: true}]
  ProductDescription;
  @UI:{ lineItem: [{ position: 30 }],
        lineItem: [{label: 'Plant'}],
        identification: [{ position: 30 }],
        selectionField: [{ position: 10 }]
        }
  Plant;
  @UI:{ lineItem: [{ position: 40 }],
        lineItem: [{label: 'Plant Name'}],
        identification: [{ position: 40 }]
        }
  @UI.lineItem: [{exclude: true}]
  PlantName;
  @UI.lineItem: [{ position: 50 }]
  @UI.lineItem: [{label: 'Storage Location'}]
  @UI.identification: [{ position: 50 }]
  @UI.selectionField: [{position: 50}]
  StorageLocation;
  @UI.lineItem: [{ position: 60 }]
  @UI.lineItem: [{label: 'Storage Location Name'}]
  @UI.identification: [{ position: 60 }]
  @UI.lineItem: [{exclude: true}]
  StorageLocationName;
  @UI.lineItem: [{ position: 70 }]
  @UI.lineItem: [{label: 'Batch'}]
  @UI.identification: [{ position: 70 }]
  @UI.selectionField: [{position: 70}]
  Batch;
  @UI.lineItem: [{ position: 80 }]
  @UI.lineItem: [{label: 'Supplier Batch'}]
  @UI.identification: [{ position: 80 }]
  @UI.selectionField: [{position: 80}]
  BatchBySupplier;
  @UI.lineItem: [{ position: 90 }]
  @UI.lineItem: [{label: 'Supplier'}]
  @UI.identification: [{ position: 90 }]
  Supplier;
  @UI.lineItem: [{ position: 100 }]
  @UI.lineItem: [{label: 'Supplier Name'}]
  @UI.identification: [{ position: 100 }]
  @UI.lineItem: [{exclude: true}]
  SupplierName;
  @UI.lineItem: [{ position: 110 }]
  @UI.lineItem: [{label: 'Unrestricted Inventory Qty'}]
  @UI.identification: [{ position: 110 }]
  MatlWrhsStkQtyInMatlBaseUnit;
  @UI.lineItem: [{ position: 120 }]
  @UI.lineItem: [{label: 'Unit'}]
  @UI.identification: [{ position: 120 }]
//  @UI.lineItem: [{exclude: true}]
  @UI.hidden: true
  BaseUnit;
  @UI.lineItem: [{ position: 130 }]
  @UI.lineItem: [{label: 'Expiration Date'}]
  @UI.identification: [{ position: 130 }]
  ShelfLifeExpirationDate;
  @UI.lineItem: [{ position: 140 }]
  @UI.lineItem: [{label: 'Manufacture Date'}]
  @UI.identification: [{ position: 140 }]
  @UI.lineItem: [{exclude: true}]
  ManufactureDate;
  @UI.lineItem: [{ position: 150 }]
  @UI.lineItem: [{label: 'Batch Status'}]
  @UI.identification: [{ position: 150 }]
  @UI.lineItem: [{exclude: true}]
  BatchStatus;
  @UI.lineItem: [{ position: 160, importance: #HIGH }]
  @UI.lineItem: [{label: 'Remaining Days'}]
  @UI.identification: [{ position: 160 }]
  remaining_days;
  @UI.lineItem: [{ position: 170, value: 'due_range', criticality: 'Criticality' }]
  @UI.lineItem: [{label: 'Due Date Range'}]
  @UI.identification: [{ position: 170 }]
  due_range;    
//  @UI.hidden: true
//  InventoryStockType;
//  @UI.hidden: true
//  MatlDocLatestPostgDate;
  @UI.hidden: true
  Criticality;
}

2.3 创建Service Definition和Service Binding

我们可以通过预览的方式查看发布的服务：

3. 前台应用开发

首先在BTP创建Destination：

然后打开BAS服务，选择SAP Fiori Worklist Application：

发布完成，部署完权限之后，就可以看到App：

以上是该案例——物料临期管理自开发应用的步骤介绍。希望通过此案例的介绍能让您了解到三系统开发能实现的常见功能。

SAP S/4HANA Cloud, public edition, ABAP Environment Case 8: Material Shelf Life Management

2024-04-19T13:16:11.809000+02:00

This is a detailed step-by-step technical guide document to introduce a Developer Extensibility case followed by this blog.

1. Case Background:

We frequently hear inquiries from clients who have enabled batch management, asking whether there are reminders for nearing expiry materials and batch query reports for such materials. In standard products, retrieving relevant information often requires searching through multiple reports, such as inventory reports and batch details. To meet this demand, we have developed a Material Shelf Life Management App on S/4HANA public cloud through developer extensibility (also known as cloud ABAP development), aiming to help enterprises intelligently manage material Shelf Life and enhance supply chain management efficiency. Regarding the business value of this use case, you can refer to this blog for details.

Due to varying business management needs, each company may define different ranges for nearing expiry reminders. The Customizable Warning Threshold Configuration App allows users to set customized ranges for when to display red, yellow, or green warning lights, meeting the diverse customization needs of different enterprises for expiry management.

2. Backend Service Development:

2.1 Create CDS Data Model

Create Data Definition: YCDS_DUE_MAT_LIST

@AbapCatalog.sqlViewName: 'YDUEMATMANGE'
@AbapCatalog.compiler.compareFilter: true
//@AbapCatalog.preserveKey: true
@AccessControl.authorizationCheck: #CHECK
@EndUserText.label: 'Material Due Date List'
define view YCDS_DUE_MAT_LIST as select from I_Batch
inner join YCDS_SUM_STOCK_01 on YCDS_SUM_STOCK_01.Material = I_Batch.Material
                                       and YCDS_SUM_STOCK_01.Plant = I_Batch.Plant
                                       and YCDS_SUM_STOCK_01.Batch = I_Batch.Batch
association [1..1] to I_Product on I_Product.Product = I_Batch.Material
association [1..1] to I_ProductDescription on I_ProductDescription.Product = I_Batch.Material
                                          and I_ProductDescription.Language = $session.system_language
association [1..1] to I_Plant on I_Plant.Plant = I_Batch.Plant
                              and I_Plant.Language = $session.system_language
association [1..1] to I_Supplier on I_Supplier.Supplier = I_Batch.Supplier                           
{
  key I_Batch.Material,
  key I_Batch.Batch,
  key I_Batch.Plant,
  key I_Batch.Supplier,
  key I_Batch.BatchBySupplier,
//  key YCDS_SUM_STOCK_01.InventoryStockType,
//  key YCDS_SUM_STOCK_01.MatlDocLatestPostgDate,
  YCDS_SUM_STOCK_01.StorageLocation,
  YCDS_SUM_STOCK_01.MatlWrhsStkQtyInMatlBaseUnit,
  I_Batch.MatlBatchIsInRstrcdUseStock,
  I_Batch.ShelfLifeExpirationDate,
  I_Batch.ManufactureDate,
  I_Product.BaseUnit,
  I_ProductDescription.ProductDescription,
  I_Plant.PlantName,
  I_Supplier.SupplierName,
  case when I_Batch.MatlBatchIsInRstrcdUseStock = 'X' then 'Restricted' else 'Unrestricted' end as BatchStatus,
  $session.system_date as curr_date
}
where I_Batch.ShelfLifeExpirationDate is not initial
  and YCDS_SUM_STOCK_01.MatlWrhsStkQtyInMatlBaseUnit <> 0

Create Data Definition: YCDS_DUE_MAT_LIST2

@AbapCatalog.sqlViewName: 'YDUEMATMANGE2'
@AbapCatalog.compiler.compareFilter: true
@AbapCatalog.preserveKey: true
@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Material Due Date List'
define view YCDS_DUE_MAT_LIST2 as select from YCDS_DUE_MAT_LIST
association [1..1] to I_StorageLocation on I_StorageLocation.StorageLocation = YCDS_DUE_MAT_LIST.StorageLocation
                                       and I_StorageLocation.Plant           = YCDS_DUE_MAT_LIST.Plant
{
  key YCDS_DUE_MAT_LIST.Material,
  key YCDS_DUE_MAT_LIST.Plant,
  key YCDS_DUE_MAT_LIST.StorageLocation,
  key YCDS_DUE_MAT_LIST.Batch,
  key YCDS_DUE_MAT_LIST.Supplier,
//  key YCDS_DUE_MAT_LIST.InventoryStockType,
//  key YCDS_DUE_MAT_LIST.MatlDocLatestPostgDate,
  YCDS_DUE_MAT_LIST.ProductDescription,
  YCDS_DUE_MAT_LIST.PlantName,
  I_StorageLocation.StorageLocationName,
  YCDS_DUE_MAT_LIST.BatchBySupplier,
  YCDS_DUE_MAT_LIST.SupplierName,
  MatlWrhsStkQtyInMatlBaseUnit,
  YCDS_DUE_MAT_LIST.BaseUnit,
  YCDS_DUE_MAT_LIST.ShelfLifeExpirationDate,
  YCDS_DUE_MAT_LIST.ManufactureDate,
  YCDS_DUE_MAT_LIST.BatchStatus,
  dats_days_between(YCDS_DUE_MAT_LIST.curr_date,YCDS_DUE_MAT_LIST.ShelfLifeExpirationDate) as remaining_days
}

Create Data Definition: YCDS_SUM_STOCK_01

@AbapCatalog.viewEnhancementCategory: [#NONE]
@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Sum of Stock 01'
@Metadata.ignorePropagatedAnnotations: true
@ObjectModel.usageType:{
  serviceQuality: #X,
  sizeCategory: #S,
  dataClass: #MIXED
}
define view entity YCDS_SUM_STOCK_01 as select from I_MaterialStock_2
{
  key Material,
  key Plant,
  key StorageLocation,
  key Batch,
  key MaterialBaseUnit,
  @Semantics.quantity.unitOfMeasure: 'MaterialBaseUnit'
  @Aggregation.default: #SUM
  sum( MatlWrhsStkQtyInMatlBaseUnit ) as MatlWrhsStkQtyInMatlBaseUnit
}
where InventoryStockType = '01'
group by Material, Plant, StorageLocation, Batch, MaterialBaseUnit

2.2 Create Metadata Extensions

Create new Metadata Extension: YC_DUE_MAT_LIST

@Metadata.layer: #CUSTOMER

@UI.headerInfo.title.type: #STANDARD
@UI.headerInfo.title.label: 'Material Shelf Life Management'
@UI.headerInfo.description.type: #STANDARD
@UI.headerInfo.typeName: 'Material Due List'
@UI.headerInfo.typeNamePlural: 'Material Shelf Life Management'

annotate view YC_DUE_MAT_LIST with
{

  @UI.facet: [{ id: 'Material',
                purpose: #STANDARD,
                type: #IDENTIFICATION_REFERENCE,
                label: 'Material',
                position: 10}
                 ]

  @UI:{ lineItem: [{ position: 10 }],
        lineItem: [{label: 'Material'}],
        identification: [{ position: 10 }],
        selectionField: [{ position: 20 }]
        }
  Material;
  @UI:{ lineItem: [{ position: 20 }],
        lineItem: [{label: 'Material Description'} ],
        identification: [{ position: 20 }]
        }
  @UI.lineItem: [{exclude: true}]
  ProductDescription;
  @UI:{ lineItem: [{ position: 30 }],
        lineItem: [{label: 'Plant'}],
        identification: [{ position: 30 }],
        selectionField: [{ position: 10 }]
        }
  Plant;
  @UI:{ lineItem: [{ position: 40 }],
        lineItem: [{label: 'Plant Name'}],
        identification: [{ position: 40 }]
        }
  @UI.lineItem: [{exclude: true}]
  PlantName;
  @UI.lineItem: [{ position: 50 }]
  @UI.lineItem: [{label: 'Storage Location'}]
  @UI.identification: [{ position: 50 }]
  @UI.selectionField: [{position: 50}]
  StorageLocation;
  @UI.lineItem: [{ position: 60 }]
  @UI.lineItem: [{label: 'Storage Location Name'}]
  @UI.identification: [{ position: 60 }]
  @UI.lineItem: [{exclude: true}]
  StorageLocationName;
  @UI.lineItem: [{ position: 70 }]
  @UI.lineItem: [{label: 'Batch'}]
  @UI.identification: [{ position: 70 }]
  @UI.selectionField: [{position: 70}]
  Batch;
  @UI.lineItem: [{ position: 80 }]
  @UI.lineItem: [{label: 'Supplier Batch'}]
  @UI.identification: [{ position: 80 }]
  @UI.selectionField: [{position: 80}]
  BatchBySupplier;
  @UI.lineItem: [{ position: 90 }]
  @UI.lineItem: [{label: 'Supplier'}]
  @UI.identification: [{ position: 90 }]
  Supplier;
  @UI.lineItem: [{ position: 100 }]
  @UI.lineItem: [{label: 'Supplier Name'}]
  @UI.identification: [{ position: 100 }]
  @UI.lineItem: [{exclude: true}]
  SupplierName;
  @UI.lineItem: [{ position: 110 }]
  @UI.lineItem: [{label: 'Unrestricted Inventory Qty'}]
  @UI.identification: [{ position: 110 }]
  MatlWrhsStkQtyInMatlBaseUnit;
  @UI.lineItem: [{ position: 120 }]
  @UI.lineItem: [{label: 'Unit'}]
  @UI.identification: [{ position: 120 }]
//  @UI.lineItem: [{exclude: true}]
  @UI.hidden: true
  BaseUnit;
  @UI.lineItem: [{ position: 130 }]
  @UI.lineItem: [{label: 'Expiration Date'}]
  @UI.identification: [{ position: 130 }]
  ShelfLifeExpirationDate;
  @UI.lineItem: [{ position: 140 }]
  @UI.lineItem: [{label: 'Manufacture Date'}]
  @UI.identification: [{ position: 140 }]
  @UI.lineItem: [{exclude: true}]
  ManufactureDate;
  @UI.lineItem: [{ position: 150 }]
  @UI.lineItem: [{label: 'Batch Status'}]
  @UI.identification: [{ position: 150 }]
  @UI.lineItem: [{exclude: true}]
  BatchStatus;
  @UI.lineItem: [{ position: 160, importance: #HIGH }]
  @UI.lineItem: [{label: 'Remaining Days'}]
  @UI.identification: [{ position: 160 }]
  remaining_days;
  @UI.lineItem: [{ position: 170, value: 'due_range', criticality: 'Criticality' }]
  @UI.lineItem: [{label: 'Due Date Range'}]
  @UI.identification: [{ position: 170 }]
  due_range;    
//  @UI.hidden: true
//  InventoryStockType;
//  @UI.hidden: true
//  MatlDocLatestPostgDate;
  @UI.hidden: true
  Criticality;
}

2.3 Create Service Definition and Service Binding

And then we can preview the published service:

3. Frontend App Development

First create destination on BTP:

Then open BAS service, and choose SAP Fiori Worklist Application:

After publish, and authorization setup, we can see the App like below:

Analyze Expensive ABAP Workload in the Cloud with Work Process Sampling

2024-04-19T15:56:01.041000+02:00

As an administrator or developer in the ABAP environment in the cloud, you need to keep track of the workload that kept your system busy throughout the day or at specific points in time. You want to check how many of your work processes are or were occupied with what kind of workload, consuming how much ABAP CPU time and main memory. Finally, you want to find out which ABAP coding was responsible for the high consumption of these resources.

In this blog post, I’d like to show you how you can use the Sampled Work Process Data app to analyze concurrent workload and resource consumption and to find the root cause of a performance problem.

Sampled Work Process Data App vs. Other Tools

Maybe you are already familiar with the System Workload app that provides an overview of the ABAP workload in your system. The following blog post gives you an insight with examples:

Analyzing Performance Degradations in the ABAP Environment in the Cloud

The ABAP system provides two data capturing mechanisms for the ABAP workload: ABAP statistics records and ABAP work process samples. The different strategies for data collection and timing aspects are explained in the following documentation on SAP Help Portal:

Monitoring the System Workload: Data Collection and Focus of Available Apps | SAP Help Portal

Both data capturing strategies are designed to cover different scenarios. You can read more about the supported monitoring use cases in the following documentation on SAP Help Portal:

Monitoring the System Workload: Apps and Their Use Cases | SAP Help Portal

The ABAP statistics data of the System Workload app is persisted after the respective processing step has finished. In addition, the data on CPU time and main memory consumption is only available for the entire processing step, so you can’t determine if any interesting "hotspot" is hiding somewhere in the ABAP coding, let alone where they’re precisely located in the code.

You might also have heard about - or already used - the ABAP Profiler, which creates ABAP traces that provide detailed insights into your program, its resource consumption and potential "hotspots" in your coding. However, using the ABAP Profiler requires you to explicitly activate it before running any specific program or application. This means that retrospective analysis is not possible. Furthermore, the results are usually limited to your application only, or at best a subset of the workload in the system. Other software running concurrently, which may cause resource bottlenecks, is not considered. For more information about the ABAP Profiler, please refer to the following documentation on SAP Help Portal:

Profiling ABAP Code | SAP Help Portal

If you want to detect a large resource consumption immediately or detect the responsible code location without activating any tracing, you’d rather use the Sampled Work Process Data app.

Get an Overview of the ABAP CPU Time Consumption

On the SAP Fiori launchpad of the ABAP environment in SAP BTP, I went to the Technical Monitoring area and chose the Sampled Work Process Data app. This app is available for administrator and developer roles.

On the entry screen of the app, I get an overview of the ABAP CPU time consumption for the last 24 hours with a resolution of ten minutes. I can easily adjust the time range and the resolution using the time slider at the top.

Time Slider

I can even change to a granularity of single seconds. Of course, this only makes sense for a total time range of much less than 24 hours, such as 1 minute, for instance.

In the upper part of the screen, there’s a graphical overview drilled down by the Request Entry Type (for example, OData v4 or SQL Service). In the lower part of the screen, there’s a table that lists the top 10 consumers with more detailed characteristics, such as the Request Entry Name. Additionally, there’s a metric that indicates the overall ABAP CPU utilization as a percentage over time. This is represented by the black line in the screenshot below, with a scale located on the right side.

ABAP CPU Time Overview

Analyze Concurrent Workload and Resource Consumption

The entry screen provides four different metrics to depict resource consumption. These metrics include ABAP CPU time, main memory, and dialog and background work process utilization. Speaking of filters, you can use the filters for Transaction Code, Request Entry Type, Request Entry Name, Tenant ID and WM Process Class ID to focus on what you are really interested in:

Filter and Drilldown

Filter values can be precise values or wildcards.

When it comes to drilldown, you might be interested in drilling down according to other characteristics or a more fine-grained resolution of the depicted workload. On the upper right, you can define the set of characteristics that the drilldown is based on:

Adjusting the Drilldown

By default, this is only the Request Entry Type. However, you can also select the Transaction Code, Request Entry Name, Tenant ID and WM Process Class ID, either individually or in any combination that is appropriate for your specific use case. This allows you to investigate concurrent resource consumption in different dimensions. In the chart below, the top values of your drilldown characteristics (in this case, just the Request Entry Name) are displayed accordingly:

ABAP CPU Time Drilled Down by the Request Entry Name

In the chart, you can clearly identify which types of workloads are competing concurrently for resources within the same 10 minutes interval. By adjusting the time slider, you can also choose much finer granularities.

Note: Please be aware that the work process sampling is, as the name suggests, based on samples (snapshots) of the work process data provided by the ABAP kernel that are taken once per second. The ABAP CPU time consumption is then calculated as the delta between consecutive samples. This means that only expensive workloads running for more than a second are displayed as relevant ABAP CPU time consumers.

Reveal the Root Cause of Performance Problems

Now let’s assume that we don’t have a uniform distribution of the workload as in the example above. Instead, one of the Request Entry Name values is popping up again and again, for example, around 09:30 a.m.:

ABAP CPU Time with an Expensive Workload

I click on the bar in the chart as shown in the above screenshot (which filters for the respective Request Entry Name and time interval) and then on the Details arrow on the right of a table row. This takes me to the Request Entry Point screen for the ABAP CPU time. (If I had switched to the Main Memory or another aspect before, I would arrive at a corresponding detail view for that metric, of course.) Since I have also selected a specific time interval, I get a zoomed-in view with a resolution of single seconds, here for the time range between 09:20 and 09:30:

Request Entry Point Screen with a Resolution of Single Seconds

This screens also offers a graphical overview over time, along with further details in the table. However, the drilldown characteristic in the chart is the Current Program Name, that is the name of the coding artifact (typically a class name) that was being executed when the sample was created. This chart may already give you a pretty good understanding of which parts of your application (on a technical level in terms of ABAP coding that is run) are expensive and where you may find optimization potential (as shown in the screenshot below). Clicking on the legend or directly on the chart filters the table data accordingly. You can zoom in and zoom out, as on the previous screens. The lower part of the screen shows a list of single work process samples, which include detailed characteristics and metrics describing the work process at specific points in time.

In this case, we can recognize two executions of the same workload that were both running for two and a half minutes. During the execution, the CPU time consumption per second was often close to 1000 milliseconds.

“Most Prominent” Current Program Name in Our Example

Now I click on the Details arrow at the end of a row in the table, which leads me to the Single Work Process Sample object page with even more details:

Characteristics on the Object Page

For a database-intensive scenario, you have the option to navigate further to the ABAP statistics record using the link on the upper right of the screen. On the ABAP Statistics Record screen, you can find – among other things – detailed data about the HANA processing time and the single expensive SQL statements, as explained in the blog post about the System Workload app mentioned at the beginning of this blog post.

Now let’s go back to the Single Work Process Sample object page. Here, I can also switch to the Work Process: Metrics tab page of the object page to learn, for instance, about the number of table entries transferred between the application server and the database within the last second before this sample was taken:

Metrics on the Object Page

In this ABAP CPU-intensive scenario , work process sampling can help directly identify whether there’s room for improvement. You can recognize that your application is CPU-intensive if many single samples have a CPU time consumption that’s not too far from 1 second, as is the case here.

Typical defects include expensive operations on large internal tables. On the ABAP Stack Trace tab page of the object page, I can check whether this is the reason for poor performance:

ABAP Stack Trace on the Object Page

By navigating from here to ABAP development tools for Eclipse (ADT) or an HTML viewer (by clicking on the Details arrow next to a line in the table), I can easily jump to the respective code where, in our simple example, a LOOP statement is executed on an internal table.

Note: In the case of single expensive statements (typically a READ TABLE or a LOOP statement, as in our example here, or a long-running Open SQL statement), the ABAP kernel – when regaining control and returning a stack trace –usually points to the next statement (the one directly following the really expensive one). Thus, we shouldn’t be concerned about the IF statement, but rather the LOOP statement.

ABAP Code Behind the Performance Glitch

Verify the Impact of Performance Improvements

In this simple example, the performance of the statement can be significantly improved by introducing a secondary key. In addition, we slightly adjust the LOOP statement by referring to the secondary key:

Enhancement of the Static Attribute ST_PIERS

Loop Statement Using the Secondary Key

We can assess the impact of this tiny change by inspecting the time interval from 10:00 to 10:10 a.m., during which the same workload was run again. This can be done on both the Sampled Work Process Data entry screen ...

Sampled Work Process Data Screen After Fixing the Issue

...and the Request Entry Point screen by selecting the respective time interval.

Request Entry Point Screen After Fixing the Issue

We can clearly recognize that now two executions of the same workload finish within seconds and that the FIND_RELATION_DATA method does not even show up in any of the collected work process samples anymore. Here are both versions of the workload in direct comparison on the Request Entry Point screen:

Non-Optimized and Optimized Workload on the Request Entry Point Screen

Conclusion

The Sampled Work Process Data app in the Technical Monitoring area of the SAP Fiori launchpad in an ABAP environment in the cloud gives you a lot of insights into concurrent workload in your system and lets you glance under the hood of ABAP CPU or memory intensive applications. It bridges the gap between apps based on ABAP statistics records and tracing tools like the ABAP Profiler.

I’d like to thank everyone who contributed to this blogpost, especially my colleagues anke.griesbaum, christian.cop, steffen.siegmund, ingrid.mautes, karen.kuck and sabine.reich.

For more information, refer to the following documentation on SAP Help Portal:

Sampled Work Process Data | SAP Help Portal

SAP BTP, ABAP in the Cloud Custom Code Transformation using abapGit and gCTS

2024-04-26T09:09:05.666000+02:00

abapGit and gCTS (Git-enabled Change and Transport System)

The basic idea behind abapGit is to exchange source code between any ABAP systems using a Gitbased repository.

By introducing gCTS, SAP is aiming for the best of both worlds, that is, repository-based
development where concurrent work on the same object is possible, while retaining all the benefits of
central development.
Following is the process flow for gCTS.

You can use gCTS to distribute your custom code through a central repository, which will enable
possible rollbacks before importing to the target system, if required.
You can possibly use abapGit to move your on-premise ABAP objects to SAP BTP, ABAP
environment. In the next section, we’ll demonstrate how to use abapGit to move ABAP objects from
your SAP S/4HANA on-premise environment to SAP BTP, ABAP environment.

Custom Code Transformation Using abapGit

Transforming on-premise ABAP code to SAP BTP requires three primary steps.
- Evaluating current code.
- Installing abapGit.
- Transforming code.

Evaluation of On-Premise code for Compatibility

Make sure that your code is using the ABAP for SAP BTP language version (ABAP for SAP Cloud
Platform).
Once the language version is changed, execute ATC check or transaction SCI to check for any issues.

Installing abapGIT on an On-Premise and as an Eclipse Plugin

On-Premise

Create a new repository on GitHub.

Give a name to the repository and click the “Create Repository” button

Visit https://github.com/abapGit/abapGit and click on the latest build as follows. This simply has the
code for an ABAP report program.

Create a report program on your on-premise SAP system and copy the code you see above into the
program and activate.

The following screen should appear once you execute this program

abapGit has now been installed on the on-premise system

As an Eclipse Plugin

Open ADT->Help->Install new software and enter the following URL to load abapGIT for ABAP
development on ADT.
http://eclipse.abapgit.org/updatesite/
Simply click on “Next” and install the plugin

Transform code form on-premise to cloud

Visit your GitHub repository and copy the URL corresponding to your repository.
Go back to your ABAP report program on the on-premise system, Click new online.
Paste the URL you copied above to the following location, along with the package that you want to
commit to the Git Repository you created above. This is the package that is in your on-premise
system, which you want to migrate to the cloud environment.

Click on “Create Online Repo”.
Once the execution is completed, you should see the cloned repository as follows, which is ready to
be committed to the online Git Repository.

Now click on “stage” and “commit all changes” to the online repository

Give a comment for the commit that you do each time as follows. Click on “Commit”

This will request for your GitHub credentials, to authenticate. Give them and Continue.

Once the commit is complete, you should see a message as follows

And the source code under the package should be available in your online Git Repository.

Open ADT on Eclipse-> Select Your ABAP in the cloud Project -> Window -> Show -> Other ->
abapGit Repositories.
Click the “Plus” button to link your abapGit Repository to ADT. Give the URL corresponding to your
Git Repository here as well.

Create a package in your ABAP in the cloud project, to which you will be importing all the supported
objects in your on-premise ABAP package. Here I have given the same package name.
Make sure to put the “Pull after link” tick as well, so the objects will be pulled from your online Git Repository into ABAP in the cloud project.

Once that is completed, you should see all supported objects on your on-premise system, imported
into your ABAP in the cloud package.

SAP Datasphere + SAP S/4HANA: Your Guide to Seamless Data Integration

2024-04-29T20:33:46.737000+02:00

Introduction:

Achieving seamless data integration between SAP S/4HANA, your core operational ERP system, and SAP Datasphere, the business data platform is a critical requirement for most SAP customers. This integration unlocks powerful reporting capabilities across various business functions.
This technical article aims to empower you with expert tips and strategies to simplify and enhance your SAP S/4HANA integration for operational reporting, analytical insights, and planning & forecasting purposes. You are following the best practices and knowing what is supported and when to use what. you can streamline data integration unlock the full potential of this integration and bring more time to value.

SAP S/4HANA Data Integration Explained:

This diagram illustrates various methods for integrating data with SAP S/4HANA, covering both data federation and replication scenarios.

Source Object Types:

ABAP CDS Views: It provides business data along with semantic(context) information (hierarchies, text, etc.), security, associations, and improved performance.
ODP Extractors: Specialized tools designed to extract specific datasets from SAP S/4HANA.
ABAP Tables: The traditional SAP master and fact tables are used for raw business data storage.

Delta Handling Mechanisms During Data Replication:

Database Trigger-based CDC Delta: This method leverages database triggers to capture changes in real-time. It utilizes the well-established SAP Landscape Transformation Replication Server (SLT) technology.ABAP Pipeline Engine (APE): This framework provides flexibility for building custom CDC pipelines suited to specific needs.
Generic Timestamp/Date-based Delta: This approach relies on a designated timestamp/date column within your ABAP CDS views to identify data modifications.

ODP Technical Infrastructure:

Operational Data Provisioning (ODP) Framework: This is the modern framework for CDC, replacing the older RSA7 (BW Delta Queues) approach. It simplifies data extraction and management.
Operational Delta Queue (ODQ): This queue stores changes made to data until they are replicated.

Data Builder Objects in SAP Datasphere facilitate your integration with SAP S/4HANA:

Remote Tables: Enable access to SAP S/4HANA data in real-time or through snapshots.
Replication Flows: These define the path for data replication from source to target system.
Data Flows: These specify the transformations applied to the data during replication.

Model Import Wizard:

This tool imports valuable metadata, context, and semantics from your CDS views, including associations, logic, and security information. Convert the SAP S/4HANA CDS semantics to SAP Datasphere data and business builder entities using the wizard, take a quick look at the below image for the I_PRODUCT CDS view same can also be done for the Sales Order, and Purchase Order CDS views. It is automatic, and you can imagine how much time/effort is required to build something similar to a standalone. This is something you will only get with Datasphere.

Now you may have a question what is the benefit of getting a data model available in SAP S/4HANA into SAP Datasphere? Let's look at the use case, I strongly believe one will apply to your organization's data platform needs.

Integrate with Non-SAP Data, It is obvious that you want to keep your SAP ERP clean for business transactions while needing a data platform to combine the SAP ERP business data with other business data segments with the context.
Strategic or Historical Reporting, over time you may plan to achieve the data from SAP S/4HANA hence for the historical data along with the business semantics for the reporting needs.
Leverage the Hyperscalar capabilities like ML/AI, with SAP Business data with semantic information.

Source Object Types Support and Compatibility:

The top diagram conveniently highlights which source object types are compatible with specific data integration objects within the SAP Datasphere.

Prerequisites and Additional Software Components (Middleware):

The diagram also indicates any prerequisites or middleware components needed for specific functionalities. For instance, Remote Tables require installing, configuring, and setting up the SAP Data Provisioning (DP) Agent with the ABAPAdapter. Refer to the help guide on Preparing Connectivity for Connections and filter based on the Connection Type = SAP S/4HANA.

Optional Components:

SAP BW bridge: This component (optional) creates a data staging layer specifically for supporting SAP S/4HANA ODP extractors. This is mainly for the existing SAP BW and BW/4HANA customers to enable a path towards conversion with SAP Datasphere, BW bridge, or Hybrid use case
- Transferring Data using ODP Options
SAP Landscape Transformation Replication Server (SLT): This server replicates tables from SAP S/4HANA to the SAP Datasphere and can be integrated into your Replication Flow.

Further Resources:

For a deeper understanding of ABAP CDS delta mechanics and the ODP framework, refer below:

Recommendations for choosing the right approach for SAP S/4HANA Data Federation and Replication into SAP Datasphere:

Recommended option is ABAP CDS Views: If the ABAP CDS is available with the desired data needs then establish a direct connection between SAP Datasphere and the source system. Leveraging the available CDS views is the BEST and RECOMMENDED Approach. Recommend to use released CDS views as they are upgrade stable.
- Individual C1-released CDS views across various business areas.
- SAP Business Accelerator Hub List of Released CDS Views. Here you can filter based on the capabilities of Data Source for Data Extraction to find extraction-enabled released ABAP CDS views.
- Finding the right CDS Extractor in the SAP S/4HANA System. In SAP S/4HANA On-Prem or Private cloud >=2020, You can use Tcode SE16N with CDS SQL View: IXTRCTNENBLDVW (I_DataExtractionEnabledView) or View Browser Fiori App.
  - How to find the released Sales Document Item CDS view using SE16N GUI Tcode?
  - How to find the released Sales Document Item CDS view using the View Browser Fiori App? You will need the business role: SAP_BR_ANALYTICS_SPECIALIST. Tcode /UI2/FLP -> View Browser -> Released Views for Cloud Development
- Recommended using standard CDS views with extension capabilities, and pre-built business contents over creating custom CDS views as long-term custom CDS may not be a sustainable option with the upgrades and may lead to performance implications. However, all requirements cannot be met with the standards hence only create custom CDS when it becomes business required and no standard alternative is available.
- Unavailable CDS Views: The required CDS views haven't been released yet. Missing Data Extraction Settings: The data extraction settings are not configured even if the CDS views are available. There are two approaches to resolving these issues:
  1. Customer Influence Request: Raise a customer influence request or upvote the existing one at SAP S/4HANA Cloud Public Edition, CDS View Extraction Enablement. OR Open a Product Support Ticket For High Priority Request: A ticket can be submitted to the relevant component for a long-term solution. Be aware that this process may take some time.
  2. Build a Custom CDS View: Create a custom CDS view replicating the missing one. You can then enable data extraction on this custom view for your use. How to Create a Custom ABAP CDS View with Change Data Capture Delta Mechanism.
  3. How to deal with “Not released” predefined VDM in S/4HANA.
- DATA FEDERATION FIRST THEN DATA REPLICATION, The approach for using the CDS view as a data federation goes back to the basics 🙂
  1. Select the required columns from the projection. e.g. CDS view may have 200 columns however business may require 75 columns. hence select only 75 columns.
  2. Filter the data as early as possible based on attributes like company code, sales org, plant, dates, or periods.
  3. Business logic and data aggregation can be handled in the source CDS view, you do not have to do it on SAP Datasphere, unless required.
  4. Use the view persistency option intelligently to get optimized data and high performance.
  5. Middleware components like DPAgent need to be sized properly S-M-L, go with a higher side like 16GB, 32GB memory vs 4GB default and 8 cores CPU.
- Restrictions: 2890171 - SAP Data Intelligence / SAP Datasphere - ABAP Integration
  1. Not supported for data transfer if the CDS view not having the "dataExtraction" annotation.
  2. CDS view for the delta load requires the "dataExtraction" and "changeDataCapture" annotations.
  3. CDS Views having parameters and a table function are not supported.
  4. CDS Views include Tables with a client field as a key, not a client-dependent field.
  5. Data extraction halts with an error if the structure of a table or CDS view changes mid-load or replication. Unfortunately, resuming after such an error isn't currently possible, requiring a full restart of the data extraction process.
An alternative option is ODP extractors: If the ABAP CDS view is unavailable then prefer ODP objects over the direct ABAP table replication. A direct connection can be established provided SAP S/4HANA has the DMIS add-on.
The discouraged option is Direct ABAP Table Access and Replication: Bypassing CDS views to replicate tables into SAP Datasphere directly is not recommended. This approach involves replicating raw data (master and transactional) without its inherent business context and relationships. Essentially, you'd be replicating the data and then manually recreating the associations, logic, and hierarchies – a time-consuming and error-prone process. The preferred approach is to leverage the existing, comprehensive CDS data models whenever possible. However, if replicating tables is unavoidable due to specific business or compliance requirements, then the recommendations below should be followed.
1. Standalone SAP LT Replication Server: For replicating tables, the recommended approach.
2. Embedded(Add-on) SAP LT Replication in SAP S/4HANA: This option is discouraged because it's tightly coupled with the SAP S/4HANA version. Upgrading the server requires a complete SAP S/4HANA upgrade, limiting flexibility. Downporting new functionalities to older versions is also not feasible.
3. Restrictions:
  1. Replicating tables with redirect views (e.g., MBEW, MARD, COEP) from your SAP S/4HANA source system is not supported.
  2. Declustering of INDX-like tables (e.g. STXL, PCL1, ...) during the transfer is not supported.

SAP S/4HANA Connection Supported SAP Datasphere Integration Features:

	Supported Objects Types	Delta Load Supported?	Prerequisite Connectivity Components?
Remote Tables	ABAP Tables Extractors: ABAP_CDS ODP_BW ODP_SAPI Model Import	YES - Real-time data replication. The object in the source has to be enabled for change data capture (CDC). For source views, ABAP Dictionary tables real-time replication is not supported. For ABAP ODP sources, real-time replication is supported in the following cases: ODP-BW: InfoProviders with a change log.object type ADSO), Standard DataStore objects (classic) (object type ODSO), InfoObjects ODP-CDS: For all ABAP CDS views with primary key and that are delta-enabled ODP-SAPI: For all extractors that are delta enabled (delta method ADD* not allowed) and have a primary key. For an overview of all S-API extractors released for ODP replication. refer: 2232584 - Release of SAP extractors for ODP replication (ODP SAPI) For remote tables using an SAP HANA smart data access connection (SAP HANA on-premise via Cloud Connector or SAP HANA Cloud), you can replicate your data changes in real-time but with some restrictions as some remote object types are not supported: The remote object needs to be a table of type "COLUMN TABLE" (other table types like Row Tables or Virtual Tables are not supported) Some data types and SAP HANA table features are not supported. For more information, see Unsupported Data Types and Other Limitations. Note You can’t pause the replication for connections if SAP HANA smart data access is used. For remote tables connected via an SAP HANA smart data integration Cloud Data Integrator (CDI) adapter, we recommend that you use a DP Agent with the latest version.	DP(Data Provisioning) Agent
Replication Flows	CDS_EXTRACTION (ABAP CDS Views Enabled for Data Extraction) ODP_BW ODP_SAPI SLT (add-on DMIS )	YES - Load type: Initial and Delta The default delta load interval is 60 minutes. You can change the integer between 0 and 24 for hours and 0 and 59 for minutes, respectively. If you enter 0 hours and 0 minutes, the system replicates any source changes immediately. Performance Issues: 3360905 - SAP Data Intelligence / SAP Datasphere - ABAP Integration - Performance when using RMS / Replication Flows	SAP S/4HANA On-Premise: Cloud Connector SAP S/4HANA Cloud: None
Data Flows	CDS_EXTRACTION SLT (add-on DMIS )	NO SAP Note: 3335277 - Datasphere - No Delta or Init in Data Flow	SAP S/4HANA On-Premise: Cloud Connector SAP S/4HANA Cloud: None
Import Entities	ABAP CDS Views Entities. e.g.: I_PRODUCT, I_BillingDocumentItem etc.	N/A Even though this object already exists from a prior import, any changes to its structure or meaning within the source system will be automatically detected, triggering an update and redeployment within your system. By default objects created will be as data is federated (remote tables), you can switch to replication when required.	SAP S/4HANA On-Premise: DP(Data Provisioning) Agent, Cloud Connector SAP S/4HANA Cloud: None

Further Resources:

For a deeper understanding of the SAP S/4HANA and ECC integration scenarios with persistence options: Exploring Integration Options in SAP Datasphere with a focus on using SAP extractors

Pre-built Business Content for SAP S/4HANA:

Overall, SAP Datasphere Business Content for SAP S/4HANA helps you unlock the full potential of your data by providing a faster, easier, and more reliable way to access, integrate, and analyze your business information. e.g. Finance Foundation for SAP S/4HANA and SAP S/4HANA Cloud, Sales Analysis for SAP S/4HANA and SAP S/4HANA Cloud, etc.

Faster Time to Value: Pre-built dashboards, data models, tables, and views with pre-defined business context eliminate the need for extensive development and configuration from scratch.

Simplified Data Integration: Business Content streamlines the process of integrating data from SAP S/4HANA with other applications and data sources. This allows you to create a unified view of your data for more comprehensive analysis. With minimum effort, you will only have to replace the SAP S/4HANA server details in the connection placeholder and you are ready to consume the continent or if you want to replicate the data then just create the required replication flow and you are done. all details are provided as a part of the help guide.

Preserved Business Context: Business Content captures the business meaning of the data, including units, hierarchies, and other relevant information. This ensures that users understand the data in its proper context and can make informed decisions.

Alignment with Industry Standards: Business Content is often aligned with industry best practices and key performance indicators (KPIs), allowing you to benchmark your performance against industry standards

Key Takeaways:

This breakdown highlights the various options in SAP Datasphere for data federation, extracting, transforming, and replicating data from SAP S/4HANA.The most suitable method(feature) depends on factors like real-time data federation or real-time updates vs. snapshots, data type, data volume, and the desired level of data transformation or conversions.
The data source object recommended precedence is ABAP CDS View > ODP Extractors > ABAP Tables. ABAP CDS view object type from SAP S/4HANA is the first-class citizen as a data source or provider from the ERP system. Customers can also prefer to create a custom CDS view with CDC capabilities even for the master data where date or timestamp columns are unavailable.
SAP S/4HANA real-time operational reporting can be done based on the Remote tables, and master data (smaller data sets) with Snapshot. For Mass data replication from SAP S/4HANA into SAP Dataspher Prefer, use the New Replication Flow.
The import model wizard provides the capability that scans the semantically rich CDS data model with associations and automatically creates the data builder and business builder objects with the default data federation scenario.
SAP S/4HANA Business Content provides time to value and quick win use case that can be enhanced.
Optional components like the BW bridge and SLT server can further enhance data integration capabilities and Safeguard existing on-prem investments and skillsets.

SAP Workflow administration in Public Cloud

2024-05-01T18:39:36.671000+02:00

First Login to Fiori Link for Public Cloud and Search app with Workflow as below

Now Select Workflow Administration App

Here you can do a bunch of activities which needed different Tcode in On Premise System. Look out for creating Substitute for users.

Below for example we now execute for Restart Workflow

Below is the List Provided for Restart Workflow

We can check details here

We can check the Workflow Log also

Here is the Tcode for Backend system.

Below is the Video version

https://youtu.be/BssG1UhVm-Y?si=yNfmXun6qD3qFOjd

Also check Playlist for Workflow

https://youtu.be/p93SN2eAPH8?si=jR97GNo6XdkLYxTV

Unlocking the Power of Cloud

2024-05-03T14:09:31.393000+02:00

Embarking on a cloud migration journey can be a daunting task for any organization. Just like setting out on a long road trip, embarking on a cloud migration journey requires careful planning, a clear roadmap, and the guidance of experienced experts. SAP MaxAttention offers a distinctive solution, granting organizations access to a team of experts who can effectively guide them through their cloud journey.

In the study titled "The Total Economic Impact™ of SAP MaxAttention for Cloud Adoption," Forrester Consulting conducted interviews with 10 professionals from seven companies who have implemented SAP MaxAttention. The objective was to assess various aspects of cloud migration, including costs, benefits, and risks. The purpose of these interviews was to gain insights into the challenges, benefits, and risks associated with cloud migration. To model the results, Forrester synthesized the participants' experiences and consolidated the findings into a single composite organization representing a global enterprise entity with an annual revenue of US$25 billion. Upon careful examination of the data, Forrester concluded that SAP MaxAttention delivered a significant three-year financial impact throughout the cloud journey.

As you embark on your cloud journey, you can rely on the expertise of SAP MaxAttention professionals to provide valuable guidance and ensure your path to success. We invite you to explore the comprehensive study commissioned by SAP, titled "The Total Economic Impact™ of SAP MaxAttention for Cloud Adoption," which was published in February 2023.

Calling Fragment Form & Send it as an attachment using ABAP Walk-Through

2024-05-15T21:53:21.876000+02:00

This Blog is based on the Output Management Form and has all of its configuration completed

Ex for dunning: use maintenance view: V_T047E using code: sm30 to switch between frameworks through drop-down list

First: you can identify Fields for Key & Master Key internal tables for standard fragment form through putting a breaking point

By using framework: sap cloud and using fragment form template and of course maintain brf+ configuration

In class: CL_SOMU_FORM_SERVICES , Method : GET_DOCUMENT

Put a break point in the first line and go back to the previous program to see internal tables passed to form calling for keys.
Take screenshots for them, as you will be using them for the custom calling of the form as these fields are maintained according to configuration & master form template derivation.
If you need the application ID Key, it’s a concatenation between multiple variables, You will find it in the call back class specific to a given object in the SPRO configuration

SPRO -> CROSS APPLICATION COMPONENTS -> OUTPUT CONTROL (here you can find all of OM Configuration) -> DEFINE OUTPUT TYPE THEN SELECT THE ENTRY CORRESPONDING TO YOUR BRF+ ROLE and click details, you will find your call back class, in our class for dunning : CL_FIN_FO_DUNN_OUTPUT , all call back classes Implement same interface, then go into method : IF_APOC_COMMON_API~GET_FDP_PARAMETER

Second step:

Activate the legacy printout system and put a breakpoint inside the printing object whether it’s a program or function module, if you are using PDF, you can put a breakpoint in open job FM and trace back through the stack to the transaction screen printing program

In our case for dunning: It prints using FM : “PRINT_DUNNING_NOTICE_PDF”, put a breakpoint there

Start comparing the values of the key & master key internal table with local variables available to locate the objects that contain the data which will be passed to the fragment forms Key internal tables from the standard
1. You will find all the data u need in the objects because whether it is fragment, PDF or whatever technology, the system always collects the same data passed one way or the other
After that start creating your custom code to call the fragment form
- Consider the condition to identify which master form template to use.
Create an enhancement in the standard program to defuse the standard code and prevent its execution, make sure that the standard code doesn’t update standard somewhere along the code as you need to confirm whether it happens through the OData service of fragment or not! ( because if not you will have to use the standard code that does that to make everything consistent )

then test the cycle end to end

in our case , here is the example for the PO Form

I created a custom program se38 to test using po form

*&---------------------------------------------------------------------*
*& Report ZDUMMY
*&---------------------------------------------------------------------*
*&
*&---------------------------------------------------------------------*
REPORT ZDUMMY.




SELECTION-SCREEN BEGIN OF BLOCK b1.
  PARAMETERS: p_po_num TYPE ebeln MATCHCODE OBJECT h_ekko OBLIGATORY.
SELECTION-SCREEN END OF BLOCK b1.



INITIALIZATION.



START-OF-SELECTION.
  DATA: lo_cl_somu_form_services TYPE REF TO cl_somu_form_services.
  DATA: lt_keys TYPE cl_somu_form_services=>ty_gt_key.
  DATA: ls_ekko TYPE ekko.
  DATA: lt_master_keys TYPE cl_somu_form_services=>ty_gt_key.
  DATA: lv_content TYPE  xstring.
  DATA: lv_xml TYPE xstring.
  DATA: lv_pages TYPE  fppagecount.
  DATA: lv_trace_string  TYPE string.
  DATA: lv_stop_processing TYPE  abap_bool.
  DATA: lt_message TYPE cl_somu_form_services=>ty_gt_message.
  DATA: lv_output_length TYPE i.
  DATA: lt_generated_pdf  TYPE STANDARD TABLE OF tbl1024 .

  FIELD-SYMBOLS: <ls_key> TYPE cl_somu_form_services=>ty_gs_key.



  SELECT SINGLE *
    FROM ekko
    INTO ls_ekko
    WHERE ebeln = p_po_num.


  " --------------------------- Values for the purchase order form ---------------------------
  APPEND INITIAL LINE TO lt_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'PurchaseOrder'.
  <ls_key>-value = p_po_num.

  APPEND INITIAL LINE TO lt_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'SenderCountry'.
  <ls_key>-value = 'DE'.

  APPEND INITIAL LINE TO lt_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'PurchaseOrderChangeFlag'.
  <ls_key>-value = space.

  APPEND INITIAL LINE TO lt_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'Language'.
  <ls_key>-value = 'E'.


  APPEND INITIAL LINE TO lt_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'ReceiverPartnerNumber'.
  <ls_key>-value = ls_ekko-lifnr.

  " --------------------------- Values for the master form template ---------------------------
  APPEND INITIAL LINE TO lt_master_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'PrintFormDerivationRule'.
  <ls_key>-value = 'PURCHASE_ORDER_MASTER_FOR_COMPANY'.

  APPEND INITIAL LINE TO lt_master_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'WatermarkText'.
  <ls_key>-value = space.

  APPEND INITIAL LINE TO lt_master_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'LocaleCountry'.
  <ls_key>-value = 'DE'.

  APPEND INITIAL LINE TO lt_master_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'LocaleLanguage'.
  <ls_key>-value = 'E'.

  APPEND INITIAL LINE TO lt_master_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'OutputControlApplicationObjectType'.
  <ls_key>-value = 'PURCHASE_ORDER'.

  APPEND INITIAL LINE TO lt_master_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'OutputControlApplicationObject'.
  <ls_key>-value = p_po_num.

  APPEND INITIAL LINE TO lt_master_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'OutputRequestItem'.
  <ls_key>-value = '000001'.

  APPEND INITIAL LINE TO lt_master_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'OutputDocumentType'.
  <ls_key>-value = 'PURCHASE_ORDER'.

  APPEND INITIAL LINE TO lt_master_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'Recipient'.
  <ls_key>-value = ls_ekko-lifnr.

  APPEND INITIAL LINE TO lt_master_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'RecipientRole'.
  <ls_key>-value = 'LF'.

  APPEND INITIAL LINE TO lt_master_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'SenderCountry'.
  <ls_key>-value = 'DE'.


  lo_cl_somu_form_services = cl_somu_form_services=>get_instance( ).


  lo_cl_somu_form_services->get_document( 
   EXPORTING iv_master_form_name  = 'SOMU_FORM_MASTER_A4'
             iv_form_name         = 'MM_PUR_PURCHASE_ORDER'
             it_key               = lt_keys
             it_master_key        = lt_master_keys
             iv_form_language     = 'E'
             iv_form_country      = 'DE'
  IMPORTING  ev_content          = lv_content
             ev_xml               = lv_xml
             ev_pages             = lv_pages
             ev_trace_string      = lv_trace_string
             ev_stop_processing   = lv_stop_processing
             et_message           = lt_message ).
  IF sy-subrc <> 0.
  ENDIF.


  CALL FUNCTION 'SCMS_XSTRING_TO_BINARY'
    EXPORTING
      buffer        = lv_content
    IMPORTING
      output_length = lv_output_length
    TABLES
      binary_tab    = lt_generated_pdf.


  " Shows a preview of the generated PDF file in a popup window.
  CALL FUNCTION 'FDM_COLL_INV_PDF_SHOW'
    EXPORTING
      t_pdf = lt_generated_pdf.


"=================================================================================================================

  "Object References
DATA: lo_bcs         TYPE REF TO cl_bcs,
      lo_doc_bcs     TYPE REF TO cl_document_bcs,
      lo_recep       TYPE REF TO if_recipient_bcs,
      lo_sapuser_bcs TYPE REF TO cl_sapuser_bcs,
      lo_cx_bcx      TYPE REF TO cx_bcs,
      lv_string_text  TYPE string,
      lt_text           TYPE bcsy_text,
      lv_bin_filesize TYPE so_obj_len,
      lv_sent_to_all  TYPE os_boolean,
      lt_binary_content TYPE solix_tab.

  CALL FUNCTION 'SCMS_XSTRING_TO_BINARY'
    EXPORTING
      buffer        = lv_content
    IMPORTING
      output_length = lv_output_length
    TABLES
      binary_tab    = lt_binary_content[].

lv_bin_filesize = lv_output_length.

  TRY.
*     -------- create persistent send request ------------------------
    lo_bcs = cl_bcs=>create_persistent( ).
      "First line
      CONCATENATE 
                 'Dear Colleague' cl_abap_char_utilities=>newline 
      INTO lv_string_text.
    APPEND lv_string_text TO lt_text.
    CLEAR lv_string_text.
    "Second line
    CONCATENATE 'Please find attached a test smartform.'
     cl_abap_char_utilities=>newline INTO lv_string_text.
    APPEND lv_string_text TO lt_text.
    CLEAR lv_string_text.
    "Third line
    APPEND 'Best Regards,' TO lt_text.
    "Fourth line
    APPEND 'Systems Administrator.' TO lt_text.

*---------------------------------------------------------------------
*-----------------&      Create Document     *------------------------
*---------------------------------------------------------------------
    lo_doc_bcs = cl_document_bcs=>create_document(
                    i_type    = 'RAW'
                    i_text    = lt_text[]
                    i_length  = '12'
                    i_subject = 'Test Email' ).   "Subject of the Email

*---------------------------------------------------------------------
*-----------------&   Add attachment to document     *----------------
*---------------------------------------------------------------------
*     BCS expects document content here e.g. from document upload
*     binary_content = ...
    CALL METHOD lo_doc_bcs->add_attachment
      EXPORTING
        i_attachment_type    = 'PDF'
        i_attachment_size    = lv_bin_filesize
        i_attachment_subject = 'Test Email'
        i_att_content_hex    = lt_binary_content.

*     add document to send request
    CALL METHOD lo_bcs->set_document( lo_doc_bcs ).

*---------------------------------------------------------------------
*------------------------&   Set Sender     *-------------------------
*---------------------------------------------------------------------
*    lo_sapuser_bcs = cl_sapuser_bcs=>create( sy-uname ).
*    CALL METHOD lo_bcs->set_sender
*      EXPORTING
*        i_sender = lo_sapuser_bcs.

lo_recep = 
cl_cam_address_bcs=>create_internet_address('Receiving Email Address').

"Add recipient with its respective attributes to send request
    CALL METHOD lo_bcs->add_recipient
      EXPORTING
        i_recipient = lo_recep
        i_express   = 'X'.

    CALL METHOD lo_bcs->set_send_immediately
      EXPORTING
        i_send_immediately = 'X'.

*---------------------------------------------------------------------
*-----------------&   Send the email    *-----------------------------
*---------------------------------------------------------------------
    CALL METHOD lo_bcs->send(
      EXPORTING
        i_with_error_screen = 'X'
      RECEIVING
        result              = lv_sent_to_all ).

    IF lv_sent_to_all IS NOT INITIAL.
      COMMIT WORK.
    ENDIF.


*---------------------------------------------------------------------
*-----------------&   Exception Handling     *------------------------
*---------------------------------------------------------------------
  CATCH cx_bcs INTO lo_cx_bcx.
    "Appropriate Exception Handling
    WRITE: 'Exception:', lo_cx_bcx->error_type.
ENDTRY.

PS. you can use same concept if you are creating a total custom fragment on your own but you need to

Create OData Model
Create Master Template using Maintain Form Template Fiori APP / SFP

Create Content Template using Maintain Form Template Fiori APP / SFP

Start building Up your Solution, i haven't tried build a full custom solution from A to Z but this is the main idea for it

Logic of CDC (Change Data Capture) in ABAP CDS View

2024-05-16T09:04:35.754000+02:00

Background

There was requirement to extract closed POs as part of Daily Delta from S4 and load to BW. We are extracting Data from S4 via creating Custom Abap CDS Views. But here we had the challenge to bring only Delta records which was closed on a particular Day.

We went ahead to implement Change Data Capture (CDC) Delta: This delta method makes use of real-time database triggers on table level. The Change Data Capture recording mechanism uses database triggers to record any changes to the tables that belong to an ABAP CDS view. To do this, the key fields of all underlying tables need to be mapped to the fields of the CDS view.

Below is the annotation used for CDC Delta Functionality

@analytics.dataExtraction.delta.changeDataCapture.mapping

CDC Mechanism in Delta Enabled ABAP CDS View

We successfully did the technical go-live of this deliverable to Production Environment and daily deltas in terms of closed PO’s was successfully getting captured in ODQMON and was flowing to BW as part of Daily Loads.

Problem Statement

One Particular Day (For example 5th Oct 2023), we noticed that as part of Daily Delta loads for closed Po’s, zero records were fetched. The same happened in next day as well. We checked in ODQMON and saw that last TSN Requested Date was not changing, it was still showing the date when the last delta was captured successfully i.e. 4th Oct 2023.

Root Cause Analysis

After exploring, got to know that there are basically 2 Jobs in the S4 Side which drives the entire flow of delta records based on CDC mechanism.

Observer job (/1DH/OBSERVE_LOGTAB)
Transfer job (/1DH/PUSH_CDS_DELTA) which's started by Observer job.

In this case when we checked in SM37, Observer Job was running as per logs, But Transfer Job last run was on the day (04-OCT-2023) when Delta records were extracted successfully in BW side. After that there was no run.

Observer job /1DH/OBSERVE_LOGTAB is scheduled hourly.

Transfer Job /1DH/PUSH_CDS_DELTA in SM37 in S4. No Run after 4th Oct 2023

If a record is changed, then database triggers write it into a master logging table /1DH/ML... (e.g./1DH/ML000000001). Afterwards, the Transfer job copies the records from master logging table to subscriber logging table /1DH/SL... (e.g./1DH/SL000000001).

After the Observer job copies the logging table entries, the view reconstruction is executed. The view reconstruction selects the latest after images from the CDS view if there exists a corresponding key in at least one subscriber logging table. The result is written into unit of Operational Delta Queue (ODQ).

In our case, we could see that database triggers have written data correctly into master logging table (/1DH/ML000000001) but it's not being copied from master logging table to subscriber logging table /1DH/SL000000001 & /1DH/SL000000002 because Transfer job is not running.

Master Logging Table – Having Entries

Subscriber logging Table - No Entries

Resolution

GOTO Transaction code DHCDCMON to check the status of Observer & Transfer Job. It must be green. Either Red or yellow, probably no delta can be pushed into ODQMON unit.

To correct the status, click button “Dispatcher job” (starts SAP_DHCDC_DISPATCHER job) which will schedule all the required and missing jobs.

/1DH/OBSERVE_LOGTAB (Observer Job)

/1DH/PUSH_CDS_DELTA (Transfer Job)

/1DH/CDC_HEALTH_CHECK (Health Check Job)

For more information, please refer SAP Note – 2930269: ABAP CDS CDC: Issues & Troubleshooting