SAP Community - ABAP Development

Dynamic BDC in Table Control

2024-04-16T12:52:14.723000+02:00

Introduction

During the execution of the program, a maximum of five lines are displayed in the table control. To get a better understanding of how this works, consider the program's attempt to loop through all the records contained within the ITEM_TAB table.

Implementation

In the context of table control, there's a need to reset the counter to 4 after the insertion of a new line. The reason behind this is that once a new line is inserted, the program proceeds to display four lines that include the inserted values. Additionally, there's a blank line, which is positioned on line 5.

Every time a new record is to be added, it should be positioned on line 5, following the execution of OKCODE =0006. This approach ensures the proper display and handling of data within the table control.

To provide a clearer understanding of how this works, below is a snapshot of the BDC program with the associated T-Code FB60:

* Intialize counter for table control rows (Max 5 lines).
  lv_cnt  = 1.
  
* Insert BDC_FIELD from each line in table ITEM_TAB.
  LOOP AT item_tab ASSIGNING FIELD-SYMBOL(<lf_item_tab>).
    CONDENSE lv_cnt.
    
    lv_txt_fkber = |ACGL_ITEM-FKBER({ lv_cnt })|.
    lv_txt_hkont = |ACGL_ITEM-HKONT({ lv_cnt })|.
    lv_txt_wrbtr = |ACGL_ITEM-WRBTR({ lv_cnt })|.
    lv_txt_sgtxt = |ACGL_ITEM-SGTXT({ lv_cnt })|.
    lv_txt_prctr = |ACGL_ITEM-PRCTR({ lv_cnt })|.
    lv_txt_kostl = |ACGL_ITEM-KOSTL({ lv_cnt })|.
    lv_txt_shkzg = |ACGL_ITEM-SHKZG({ lv_cnt })|.
    
    PERFORM bdc_dynpro      USING 'SAPMF05A' '1100'.
    PERFORM bdc_field       USING 'BDC_OKCODE'
                                  '=PI'."'/00'.
    PERFORM bdc_field       USING 'RF05A-BUSCS'
                                  lc_r.
    PERFORM bdc_field       USING 'INVFO-ACCNT'
                                  iv_vendor.
    PERFORM bdc_field       USING 'INVFO-XBLNR'
                                  iv_xblnr.
    PERFORM bdc_field       USING 'INVFO-WRBTR'
                                  lv_wrbtr.
    PERFORM bdc_field       USING 'BDC_CURSOR'
                                  lv_txt_hkont.
    PERFORM bdc_field       USING lv_txt_hkont
				<lf_item_tab>-glaccount.
																
* ............................................................*
																	
    PERFORM bdc_dynpro      USING 'SAPMF05A' '0330'.
    PERFORM bdc_field       USING 'BDC_CURSOR'
                                  'BSEG-XREF3'.
    PERFORM bdc_field       USING 'BDC_OKCODE'
                                  '=RW'.
    PERFORM bdc_field       USING 'BSEG-XREF1'
				<lf_item_tab>-xref1.
    PERFORM bdc_field       USING 'BSEG-XREF2'
				<lf_item_tab>-xref2.
    PERFORM bdc_field       USING 'BSEG-XREF3'
				<lf_item_tab>-xref3.
																	
* Managing line items in the table control of FB60 transaction.
    IF lv_cnt >  4.    "Max 5 records appear in table control.
* Reset the counter to 4 (Last line in the table conrtol) after last record is filled up.
      lv_cnt = 4.
      PERFORM bdc_dynpro      USING 'SAPMF05A' '1100'.
      PERFORM bdc_field       USING 'BDC_OKCODE'
                                    '=0006'.
      PERFORM bdc_field       USING 'BDC_CURSOR'
				lv_txt_hkont.
    ENDIF.
    
    lv_cnt  = lv_cnt + 1. "Counter increment by 1.
  ENDLOOP.
  
  PERFORM bdc_dynpro      USING 'SAPMF05A' '1100'.
  PERFORM bdc_field       USING 'BDC_OKCODE'
                                '=BU'.
  PERFORM bdc_field       USING 'RF05A-BUSCS'
                                lc_r.
  PERFORM bdc_field       USING 'INVFO-ACCNT'
                                iv_vendor.
  PERFORM bdc_field       USING 'INVFO-XBLNR'
                                iv_xblnr.
  PERFORM bdc_field       USING 'INVFO-WRBTR'
                                lv_wrbtr.
  PERFORM bdc_field       USING 'BDC_CURSOR'
                                lv_txt_hkont.
                                
  PERFORM bdc_transaction TABLES messtab
  USING                         'FB60'
                                ctu
                                mode
                                update.

If you've encountered an error while using different devices, the issue could be due to the varying screen resolutions of your devices. This is a common problem that can occur when working with a variety of devices, each with its own unique specifications. The software needs to adapt to these different environments, and this is where our solution comes into play.

To address this, we need to add a specific part of code, the defsize option, to our program. The defsize option is a powerful tool that ensures consistent handling of table control across all systems. It is designed to provide a uniform experience, regardless of the device or screen resolution being used.

The process begins by recording your transaction using the default screen size. This establishes a baseline for the software to refer to and ensures that the process is calibrated properly.

Next, you will need to increment the index. This is done based on the number you get from the default recording for the table control entries. This step is crucial as it allows the program to adjust the display according to the specific requirements of the device being used.

By following these steps, you can ensure that your program can handle table control consistently across all devices and screen resolutions. This will not only resolve the error you're currently experiencing but also make your program more robust and reliable for future use.

DATA ctu_options TYPE ctu_params.

ctu_options-defsize = 'X'.

CALL TRANSACTION 'MMZ1' USING bdcdata OPTIONS FROM ctu_options.

Conclusion

I sincerely hope that this blog has been a helpful resource in your journey to understand how to develop a BDC Table Control program. My aim was to provide you with a comprehensive guide that simplifies the process and makes it more accessible to everyone, regardless of their level of familiarity with the platform. If you found this blog useful, I would greatly appreciate it if you could share it with others who might also benefit from this information.

Your likes and shares help to spread the word about these resources and support the work that goes into creating them. Moreover, your feedback and comments are extremely valuable to me. They not only help me improve my future content, but also provide a space for discussion and learning. I look forward to hearing your thoughts and engaging in fruitful discussions!

A journey of discovery and a prime example for utilizing dynamic logpoints

2024-04-16T13:02:04.868000+02:00

I recently got pulled into trying to resolve a helpdesk ticket raised by a user department because they had noticed something "off" with delivery note attachments to several deliveries. For some unknown reason, some deliveries kept getting the same PDF attached over and over again - and not just a few times but really often, like up to almost 140,000 times!

Collecting information

To begin with, we didn't really know where these were coming from and our only lead were the many entries also getting added to the archive link table TOA01. There, we noticed a big jump in daily additions at around November 20. Before then, we had daily additions in the 3 digit numbers range and afterwards it quickly jumped up to 250K entries per day.

I then did a where-used analysis for table TOA01 and found function module ARCHIVE_CONNECTION_INSERT which looked like a promising lead just based on its name! Luckily enough, we have the SAP Call Monitor (SCMON) active in our productive environments, so I went there to see if there were any "interesting" hits for the function module. Not too surprisingly, there was a very clear outlier within the 7 days worth of data readily available:

So, I checked our RFC-enabled function module which looked fine logic-wise and which also hadn't been changed recently. It therefore couldn't really be the underlying reason for what was happening in the system. I now however had some impacted piece of code to take a closer look at.

Dynamic logpoints to the rescue!

As far as I'm concerned, dynamic logpoints (SDLP) are one of the best options to troubleshoot issues like the one at hand where you can't capture the process stand alone via starting a report or transaction. So, I identified a suitable place in the code and defined a logpoint for a few relevant fields:

It didn't take long for a very distinct patter to emerge in that we had most delivery numbers showing up with slowly increasing KEY COUNTS (the combination of fields in Key Definition) and a few others where the numbers went up far more quickly.

Slow cycle with something between 36 and 40 minutes between each addition:

Fast cycle with something between 1m50s and 2m30s (ignoring the outlier):

Watching this for a few days, the pattern was eerily consistent so that it was roughly possible to tell when numbers would go up again for one of the deliveries simply by knowing if it was stuck in the slow or fast cycle! Just how eerily regular the pattern was, can be seen in this screenshot with only partially masked delivery numbers. I had the dynamic logpoints active for about 8 hours each day, during which time they had been triggered about 74K times each:

Resolution of the issue

By that time we had collected more than enough data to be "fairly" certain that the root cause for the issue was outside our SAP system and had to be with one of our external logistic partners who kept re-sending the same delivery notes over and over again instead of just once. After getting in touch with them, the issue was quickly resolved: the root cause of all of this was a local C-drive running out of space with nobody noticing! Once that was tackled on their end, the number of transmitted delivery notes went down to pre-issue numbers immediately!

Next steps

Now that we successfully stopped the build-up of unwanted attachments we'll need to find a way to get rid of the millions of obsolete attachments in an orderly way with always obviously leaving one attachment intact but deleting all the many others from an impacted delivery. I already identified one most likely helpful function module for this task: ARCHIV_DELETE_META. I'll however have to investigate how best to get rid of the many items without causing issues for the system with these many updates.

So, here is a question for you: did you per chance already have to tackle a comparable clean-up of archivelink attachments and if so, am I on the right track with ARCHIV_DELETE_META or are there other/better options available? If you have any suggestions, please mention them in the comments. Thanks!

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 Developer News, April 18th, 2024

2024-04-18T14:16:44.083000+02:00

SAP CodeJam European Roadshow

SAP CodeJam Event Calendar: https://community.sap.com/t5/sap-codejam/eb-p/codejam-events
SAP CodeJam Group: https://community.sap.com/t5/sap-codejam/gh-p/code-jam

SAP CodeTalk with Daniel Schlachter on the CAP plugin concept

The interview https://www.youtube.com/watch?v=cG-cMqAhqyQ
The Capire section on "CAP Plugins & Enhancements" https://cap.cloud.sap/docs/plugins/#cap-plugins-enhancements

SAP Build Developer Challenge Week 3 Announcement

SAP builders group discussion : https://community.sap.com/t5/sap-builders-discussions/april- citizen-developer-challenge-sap-build-apps-task-3/td-p/13672860

FioriConf 2024 and SAP CodeJam – SAP Fiori elements flexible programming model

FioriConf 2024: https://www.fioriconf.org/
SAP CodeJam topic list: https://community.sap.com/t5/sap-codejam-blog-posts/sap-codejam-topics/ba-p/221407
SAP CodeJam – SAP Fiori elements flexible programming model: https://github.com/SAP-samples/fiori-elements-fpm-exercises-codejam

Solution Experience Live Session: Deliver Real-World Results with SAP Business AI, April 30, 2024

Register: https://events.sap.com/live-session-sap-business-ai/en/home
SAP Business AI release highlights: https://community.sap.com/t5/technology-blogs-by-sap/deliver-real-world-results-with-sap-business-ai-q4-2023-amp-q1-2024-release/ba-p/13650291

CHAPTER TITLES

0:00 Intro
0:07 SAP CodeJam European Roadshow
1:04 SAP CodeTalk with Daniel Schlachter on the CAP plugin concept
2:16 SAP Build Developer Challenge Week 3 Announcement
3:00 FioriConf 2024 and SAP CodeJam – SAP Fiori elements flexible programming model
3:55 Solution Experience Live Session: Deliver Real-World Results with SAP Business AI, April 30, 2024

TRANSCRIPT

[Tom]
This is the SAP Developer News for the 18th of April, 2024. Live from Amsterdam. Live from Bucharest. Live from Leverkusen, Germany. Hey there, we're halfway through this year's SAP Code Jam European Roadshow. As the little intro there demonstrated, we've hit three cities already, we've got Paris, France, and Madrid, Spain still to go on this trip. We've had a wonderful time interacting with all the community members, developers out there, introducing them to ABAP cloud as well as the SAP cloud application programming model. And this is a great time to remind you that anybody can request and offer to host an SAP Code Jam, we'll do our best to accommodate and and make that possible. So if you'd like to see next time's road show come to an area near you, consider hosting a code jam in the future.

[DJ]
Recently, there's a new plugin concept that's been introduced in the SAP Cloud Application programming model. On the one hand, it allows the CAP team to build out new functions and features for CAP in a really beautifully modular way and it allows us as developers to consume those extensions and new features also in a really beautifully simple way, often only requiring one line in our projects. It also allows us in the community to contribute extensions to CAP as well. This is the CAP plugin concept and recently I got the opportunity to talk about the CAP plugin concept and learn more about it from one of the enablement team members Daniel Schlachter. It's in a code talk format so you can consume it in video form or in audio form in the code talk podcast. Check it out. The link is in the description.

[Shrini]
Hello, SAP Builders. We are already in week three of the developer challenge. And this time, we will be diving into the theming capabilities of SAP Build. Our very own developer advocate, Rekha, has prepared an exciting challenge that will walk you through all the different options available in the theme, style, and layout tabs of SAP Build apps. She has also provided step-by-step instructions on how to complete the challenge in a post. Participate in the challenge and share your screenshots, along with the hashed answers in the reply section of this discussion in the SAP Builders group. We are eager to see your responses to this challenge.

[Nico]
Hi everyone, and welcome to the SAP Developer News. This is just a friendly reminder that FioriConf 2024 happens on April 24th. It's free, live, online only, with a 100% focus on SAP Fiori. The event is organized by SAP community members and is a great fit for everyone working with SAP Fiori, be it developers, consultants, architects, or admins. Make sure to check out the link in the description. And speaking of SAP Fiori, we just added a new topic to the list of available topics for SAP Code Jam events, the SAP Fiori Elements Flexible Programming Model. Make sure to check out the link in the description if you want to host or attend an SAP Code Jam event, and also check out the repository with the content. Hope to see you soon. Bye.

[Nora]
Many partners and customers always ask me what SAP means by business AI, and what SAP's approach is to business AI, and how SAP can help them transform their businesses and leverage AI for their businesses. If you also have those questions, Then listen up because SAP Learning is hosting a 16-minute solution experience live session on the 30th of April at 1.30 Central European summertime to answer exactly those questions. The session is suitable for all audiences as it is a get started session. And you will not only learn about SAP's latest innovative use cases of AI, but also understand SAP's strategy towards business AI and how your business can benefit from it. The speaker is no other than Dr. Philipp Herzig, our Chief AI Officer, who will also guide you through the 2024 Q1 releases of Business AI and he will share all the know-how with you that you need to stay up to date and to transform your business. So make sure you register with the link below and sign up for the event and don't miss out on all the insights.

Debugging transaction MD04 in SAP S/4HANA

2024-04-19T03:03:14.027000+02:00

Back in 2014 I wrote the blog How to analyze transaction MD04 in debug, which explained how we could analyze the execution of the Stock/Requirements List (transaction MD04) in debug mode, in order to understand which how is selected and resolve common issues that might affect the MRP elements displayed in MD04.

In 2015, however, SAP S/4HANA was introduced and the logic to select the planning elements from the database in the Stock/Requirements List was redesigned for a better performance on the HANA database. While the old blog is still relevant for debugging transaction MD04 in SAP ECC, this new blog explains how to debug MD04 in an SAP S/4HANA system.

We can use debugger to understand, for example, why a certain element exists in the database but it is not displayed in MD04, why an MRP element is not relevant for MRP or why it is displayed with a different quantity.

The starting point to debug MD04 in an SAP S/4HANA system is still function module AUFBAUEN_MDPSX_ANZEIGEN; however, instead of calling different procedures where MRP elements are sequentially selected from the database and processed by an ABAP code, method GET_MAT_WERKS_S4H of class CL_PPH_MDPSX_SELECTION will be called, as shown in the figure below.

Figure 1 - Method GET_MAT_WERKS_S4H being called in MD04

Inside this method, a HANA stored procedure will be called to read the all the MRP elements from the database at once, taking advantage of HANA internal parallelism. In the following figure we can see the details of the stored procedure that is called, however, we won’t be able to debug the AMDP execution in the ABAP debugger.

Figure 2 - HANA procedure where data is read in MD04

After the execution of the AMDP procedure, system will collect the MRP elements read from the database and build the internal table ET_MDPS_OUT. This internal table will contain all the MRP elements that were selected from the database and that might be relevant to MRP. We can see in the figure below that 17 records were selected from the database. Here is the first point that we can check to determine if a planning element was originally selected from the database or not.

Figure 3 - Contents of internal table ET_MDPS_OUT after the data selection

With the internal table populated with the MRP elements, system will call method FINALIZE_MDPSX_CDS of class CL_PPH_MDPSX_POSTPROCESSING, in order to determine if a planning element should be really displayed in MD04 and determine additional settings. In the following figure we can see the piece of code where system determines whether an MRP element is available for MRP and the firming indicator, for example (note that all comments are in English, so we can easily understand what is happening inside each call).

Figure 4 - Additional checks after data selection

After the execution of this method, we will come back to the old function module AUFBAUEN_MDPSX_ANZEIGEN, and the old table MDPSX will be populated with the MRP elements. The following pictures show the contents of internal table MDPSX after the execution of function module AUFBAUEN_MDPSX_ANZEIGEN and the results displayed in transaction MD04, and as we can see in the pictures, both are very similar.

Figure 5 - Contents of internal table MDPSX

Figure 6 - Results displayed in MD04

As we mentioned earlier, the logic to select the MRP elements from the database has been completely rewritten and the data selection has been pushed into the HANA layer. It means that old ABAP BAdIs that were previously called when reading the MRP elements from the database will no longer be called. This is the case, for example, of BAdI MD_CHANGE_MRP_DATA, which was commonly used in SAP ECC to manipulate the MRP elements in the Stock/Requirements List. As an alternative, we can use the ABAP BAdI MD_ADD_ELEMENTS, which can be for the same purpose. As of SAP S/4HANA 2022, we can also use the new AMDP BAdI PPH_SUPPLY_DEMAND_LIST, which is also called by MRP Live and the MRP Fiori Apps. This blog provides more details about this BAdI.

Finally, there are situations where we might still want to have the old logic ABAP triggered when troubleshooting an issue. This is the case, for example, if we think that there is a bug in the new logic and we want to compare it with the old one. We can force MD04 to use the old logic by typing HANA_OFF in the command field, and HANA_ON to make sure that the new logic is used. Note that this should only use used for troubleshooting, not as part of the daily usage of MD04.

Figure 7 - Command HANA_OFF in MD04

After we finish reading the MRP elements from the database, we continue with the same flow that previously executed in SAP ECC. The following function modules, mentioned in the previous blog, are still relevant in SAP S/4HANA:

MD_GET_KUND: Read customer information for sales orders;
MD_GET_LIEF: Read vendor information;
MDEZX_AUFBAUEN: Build the MRP elements texts, as they are displayed on the screen;
MDSUX_AUFBAUEN: Build the MD04 period totals;

Brought to you by the SAP S/4HANA RIG

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

New way to maintain settings in ABAP

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

source code https://github.com/AntonSikidin/global_settings

Time-to-time constants appear in your code. Some time constants are less constant. They have different types for example date of feature start, rfc_dest to other system, and number of parallel tasks.

To maintain settings you have to create a table of 1 row or class for constant. Both this way has different costs to create settings, add settings, and change settings. Less is better.

And you have tens of tables of 1 row that replicate each other.

I have a solution that has the best part of both ways to maintain settings. Easy to create, easy to add, and easy to maintain. As a bonus, you can have documentation for settings like flag_25 type xfeld.

We can hold

single value
single structure
table of value
table of struct

to hold this different variable in one table I serialized them in JSON and saved them in the table of text255

to read settings:

select data
join string
deserialize

After installation navigate to screen #2

We need to adjust something

Make layout bigger

from

Change field size: Double click

Visible length 50

Double click

Visible length 15

Double click

Text “Is Table?”

Activate!

To describe your settings go to ZTR_GS_CONFIG (Global Settings Configuration).

First level – project name

Second-level variables of this project

Name of variable/structure/table
Short description
Abap type. For data elements, this element must be used in a table or structure
Sign that it is a table. You can’t use table type

The third level is a long description of what these settings are for, how they change program flow, and what possible value can hold

Changes save in transport requests.

To edit the value of settings go to ZTR_GS_EDITOR in each system( development, quality, production )

Enter the project name or search.

In the variable block list all settings of this project. You can view or change by clicking on the var name.

Long description in Description block.

to view history.

use for navigation.

You can easily work with these settings in the program.

REPORT Z_TEST_NEW_SETTINGS.

DATA
      : lr_gs TYPE REF TO zcl_gs " settings object

*        variable to hold settings data
      , lv_data  TYPE datum
      , lv_struct TYPE SCARR
      , lt_table_of_date  TYPE TABLE OF datum
      , lt_table_of_struct TYPE TABLE OF SCARR
      .

START-OF-SELECTION.
*create object
  lr_gs  = NEW zcl_gs( 'FIRST_PROJECT' ).

*read settings
  lr_gs->get_object( EXPORTING iv_var_name =  'DATE'
                     IMPORTING ev_data     =   lv_data ).

  lr_gs->get_object( EXPORTING iv_var_name =  'STRUCT'
                     IMPORTING ev_data     =   lv_struct ).

  lr_gs->get_object( EXPORTING iv_var_name =  'TABLE_OF_DATE'
                     IMPORTING ev_data     =   lt_table_of_date ).

  lr_gs->get_object( EXPORTING iv_var_name =  'TABLE_OF_STRUCT'
                     IMPORTING ev_data     =   lt_table_of_struct ).
*display
  cl_demo_output=>write( lv_data ).
  cl_demo_output=>write( lv_struct ).
  cl_demo_output=>write( lt_table_of_date ).
  cl_demo_output=>write( lt_table_of_struct ).

  cl_demo_output=>display( ).

You cannot use a structure or table with includes with suffixes like this

ABAP Cloud Developer Trial 2022 Available Now

2024-04-19T18:52:59.860000+02:00

Dear all,

ABAP Cloud Developer Trial 2022 is now available on Docker:

https://hub.docker.com/r/sapse/abap-cloud-developer-trial/tags -> 2022

ABAP Cloud Developer Trial is a free, downloadable ABAP Platform on SAP HANA 2.0 for trying out the ABAP language and toolset. It is extensively pre-configured with SAP Fiori launchpad, SAP Cloud Connector, pre-configured backend /frontend connections, roles, and sample applications.

This solution is intended for two groups of developers:

Non-ABAP developers, who are interested in learning more about the ABAP language and development tools
ABAP developers, who are interested in learning about new features (see below for some examples)

Note: This is the new name for ABAP Platform Trial. The name change is to highlight that you can now develop in the new ABAP Language Version, ABAP for Cloud Development. For more information, see the Highlights below. By the way, if you are interested in our overall release strategy for the Trial, see Karl Kessler’s announcement blog post from 2023: Now available: ABAP Platform Trial

IMPORTANT:

All: Before you pull the image, make sure:

You understand the principles of docker container technology
You know the entities docker image / docker container and their relationship
You know the basic commands to work with images and containers

Mac Users: Previously, ABAP Platform Trial ran on both Intel and M-series processors. Since then, Apple has upgraded its iOS. Thus, on the newest MacOS version, you can no longer run ABAP Cloud Developer Trial on Docker Desktop for MacBooks with an M-seríes processor. This is not a SAP-specific issue. So for now, you have two options:

Run Docker Desktop with a MacBook that has an Intel processor.
Use the UTM app to emulate an AMD64 Linux distro via Apple QEMU.

Many many thanks to Community member @dylan-drummond for researching this. Dylan has written an exhaustive guide to this:

M-series Apple Chip MacBooks and Abap Platform Trial containers using Docker and Podman

This is Community content, so consume at your own risk; however, this could be very helpful to many Mac users.

ABAP License

The ABAP license supplied with the Docker image lasts only three months. Therefore, you should download and import the demo license as follows:

Logon to your ABAP system with the user SAP*, client 000, same password as for DEVELOPER (DEVELOPER , client 001, is locked).
Start transaction SLICENSE; copy the hardware key.
Get the license from minisap , choosing the system A4H.
Back in your ABAP System, log off, then log on with the user DEVELOPER, client 001.
Choose Install.
The old ("INITIAL") license(s) should be deleted automatically. If not, start SLICENSE again; remove the old invalid licenses. (sap* is not allowed to delete licenses).

Update, 23rd April, 2024: 2022 as a Cloud Appliance (CAL)

Dear all, As an alternative to the Docker download, we have also released the same version of the Trial, under the name SAP ABAP Platform 2022, Developer Edition:

https://cal.sap.com/catalog#/applianceTemplates/c12a3b3d-99b0-4b44-a0c7-6509fe279a3d

Enjoy!

Highlights of the 2022 Edition

ABAP Cloud Development: Developer Extensibility Scenario

ABAP Cloud map

ABAP Cloud is the ABAP development model you need to build cloud-ready business apps, services, and extensions. Including it in the ABAP Cloud Developer Trial means that you can get a feel for the concepts pertaining to ABAP Cloud Development and to a clean core when extending SAP S/4HANA. This scenario lets you build extensions directly on the SAP S/4HANA stack - tightly coupled, cloud-ready, and upgrade-stable. Of course, we don't offer the strictly business content from SAP S/4HANA. However, we do offer all the language elements - RAP cloud-optimized language, and released APIs and extension points.

Important: You are thereby restricted to cloud-optimized ABAP language. That is, if you are used to developing in Classic ABAP on-premise, and want to try out Cloud development, you must comply with ABAP Cloud Development rules, such as:

Use public SAP APIs (local or remote) released by SAP to access SAP functionality and SAP data
Use public SAP extension points released by SAP to extend SAP objects. Modifications to SAP objects are not supported. (This includes SFLIGHT, for example.)
Use ADT (ABAP Development Tools) as your ABAP IDE
Use RAP (ABAP RESTful Application Programming Model) to build Fiori apps and services. SAP technologies like Dynpro or Web Dynpro are not released for ABAP cloud development
The software components ZLOCAL and ZCUSTOM_DEVELOPMENT can only be used for ABAP Cloud development - that is, compliant with these rules

More information:

ABAP RESTful Application Programming Model (RAP) - 2022

Offers you an efficient way to build enterprise-ready, SAP HANA-optimized, OData-based Fiori UI services and Web APIs in the cloud as well as on-premise.

New features in 2022 include:

Custom business objects
Event Consumption and Exposure
RAP Generator
RAP business object Test Double Framework (TDF)

To make it easier for you to get started, we have also added:

The demo and training data model, the ABAP Flight Reference Scenario (or directly: ABAP Flight Reference Scenario 2022 on github)
The SAP Fiori Element Feature Showcase App for RAP

More information:

Git-Enabled Change and Transport System (gCTS)

gCTS = CTS + git

A new way of transporting objects, gCTS enables you to use Git to store your ABAP development objects. gCTS makes use of special Git features, such as working on local copies of a central remote Git repository. Software development takes place in the usual editors like ABAP Development Tools (ADT). Changes to objects are still recorded in transport requests. Current states of objects can be pushed to remote Git repositories, either by releasing a transport request or while you’re working.
For the official documentation overview, see:

Git-Enabled Change and Transport System (BC-CTS-GIT) | SAP Help Portal

The official documentation for configuration is in two parts:

Configuring Git-Enabled Change and Transport System
Here, we have preconfigured the first two parts, so you only have to complete parts 3-5:
Configuring Git Repositories

Some certificates are already available. If you would like to connect to your own GitHub server or to a provider other than github.com, you have to add the appropriate certificates to the ABAP system in transaction STRUST. The configuration has been done for the default user ‘DEVELOPER’.

To get started with gCTS, simply open the gCTS app in the SAP Fiori Launchpad (FLP).

If you are a SAP customer, partner, or employee, the following SAP Note provides additional information: SAP Note: 2821718 . However, the essential configuration has already been done for everyone.

abapGit

Yes, abapGit is available out of the box.
Documentation is here: abapGit Documentation
If you are not yet familiar with abapGit, this post by graham.robinson is a great introduction, with how-to videos:
abapGit So Easy

Custom Code Migration with the ABAP Test Cockpit (ATC)

We've pre-configured ABAP Platform Trial to run as a central check system for checking your custom code prior to migration - particularly useful for:

SAP S/4HANA Readiness Checks
SAP Cloud Readiness Check

You can test this out of the box locally in SAP ADT, then configure the rest of your landscape to work with it.
For more general information on ATC, see these two excellent blogs, by Olga Dolinskaja:

SAP Cloud Connector

SAP Cloud Connector provides a link between SAP Business Technology Platform (BTP) applications and on-premise systems. It runs as on-premise agent in a secured network; acts as a reverse invoke proxy between the on-premise network and SAP BTP; and lets you use existing on-premise assets without exposing the entire internal landscape.

If you are interested in connecting your ABAP Platform Trial with a licensed version of SAP BTP, ABAP Environment (i.e.“Steampunk”), I have written a tutorial mission on this: Connect Your On-Premise System with SAP BTP, ABAP Environment

For more information, see:

SAP Help Portal, SAP BTP Connectivity: SAP Cloud Connector
SAP Community blog post (third-party content): SAP BTP Cloud Connector – A Brief Guide for Beginners

Other Highlights of ABAP Platform 2022: Overview

Blog post: ABAP Platform for SAP S/4HANA 2022, from November 2022, by Olga Dolinskaja, including the Overview Presentation

Guides, Tutorials, FAQ, Troubleshooting

If you’re not sure where to start with your new system, we have written several tutorials:

SAP Tutorial Navigator: ABAP On-Premise Tutorials.

I have started putting together FAQs specifically for ABAP Platform Trial / ABAP Cloud Developer Trial on Docker. If you would like to contribute to this, please let me know:

ABAP Trial Platform on Docker: Tips and Tricks

The old FAQs also contains some non-release-specific info on Cookbook-style projects, by SAP Community members: I will

FAQ and Troubleshooting for SAP AS ABAP 7.5x

Troubleshooting: One last thing: Now that comments are no longer threaded, it is almost impossible to keep track of / answer your troubleshooting / error questions. Please please create a new question in the SAP Community - ABAP Development forum (which uses the User Tag "abap_trial"). I will try to monitor these questions, but other experienced ABAP users / mentors will also see them.

Enjoy!

App to automatically configure a new ABAP Developer System

2024-04-23T21:39:08.985000+02:00

TL:DR

New application abapDevSysInit available to automate configuration and personalization tasks after installing a new ABAP Trial or Developer Edition instance.
Disclaimer: Work in progress at the time of writing, expect bugs and changes, may break stuff, use at own risk!

Background

I've been using ABAP Trial and Developer editions since SAP made the first NetWeaver ABAP trial system available back in 2000-something. It's great to have a system you can play around with and break. But that also means we need to install a new system every so often for various reasons - something broke, backups too old, new version available.

So here's the problem: How to manage the work I've done that I'd like to keep and move onto my new ABAP instance? Backing up the Virtual Machine is a sensible thing to do, but won't help in all cases. Before abapGit, I used to export my objects using SAPlink and import into the new system. That comes with its own set of challenges of maintaining versions and keeping track of which version is on which system, especially if you regularly use more than one system (description of my setup at the end). abapGit however made a different mindset possible.

Enter

With abapGit, the Git repository becomes the single source of truth. It is possible to set up an automatic push to GitHub on a daily or even hourly basis. Your systems are now disposable, and it doesn't matter which one you want to use. If a system breaks, or, as happened a few days ago, SAP release a new version, then you can just delete it and fire up or install a new instance, and with Docker it's quicker than ever.

However the most time-consuming part is a bunch of stuff that I end up repeating for every new instance. Downloading and installing GitHub SSL certificates, changing user details, pulling various repos from GitHub, setting up GitHub authentication so I don't need to enter my password every time. And mundane stuff like updating my user profile to use decimal points and adding my email address.

So I built myself something to automate as much as I can and published it on GitHub.

How To Use abapDevSysInit

Coming back to the point of the blog: How to use it?

Installing:

The repo is at https://github.com/pokrakam/abapDevSysInit, with two options to install:

If you already have abapGit installed, you can pull it directly from GitHub. Fortunately the new 2022 system already includes it.
If not, everything is in one report for this very reason, so all that's needed is to create a package and a program zdevsysinit and paste the code from GitHub (link in the readme).

Configuring:

Once again, the rationale is to be able to copy/paste, so no tables or anything. Therefore the configuration is just an include that sets a bunch of variables.

As the configuration is personal to your requirements, it should be stored outside of SAP ready to be pasted into anew system. The include itself should ideally also live in a different package (e.g. $tmp), unless you have your own cloned version on GitHub.

A config include example which you can copy/paste to get started is also in the repo. Settings should be self-explanatory.

Running:

The program will read the config and also try to determine what is/isn't available and toggle the different activity checkboxes accordingly.
e.g. The "Get abapGit Standalone" checkbox will be checked if it can't find report ZABAPGIT_STANDALONE, else unchecked. (Hint: The new 2022 system has a several months old version, so you can use this option to pull the latest one straight away).

This means the report can also be run directly in the Eclipse ADT console without needing any input.
Note that copy-pasting will not have the selection texts as in the screenshot above, but the raw parameter names (P_ABAPGT instead of "Get abapGit Standalone"). ~~This is on the todo list.~~ Edit: Done, you should only see P_... parameters the first time it runs, just restart it.

Feel free to raise any issues for bugs or feature requests on GitHub.

Addendum: My Setup

For anyone interested in my setup: I have two main systems: a NetWeaver 7.52 Developer Edition running in VMWare on my MacBook, and an ABAP on HANA Developer Edition on my NAS.
Why two? Convenience. For most Open Source projects 7.52 is quite sufficient and it takes exactly one minute to fire up 7.52 on my five year old MacBook, and it works anywhere, without internet, even on a plane ("in the cloud", I guess).
A4H in contrast takes 10-15 minutes to get going if my NAS is off, and only works at home unless I open up a VPN.

How to improve the ADT Class Runner with additional Features

2024-04-24T10:28:47.088000+02:00

What is a Class Runner?

A class runner is a great tool to test code snippets and run code directly from ADT. You can even write a simple log to the console in Eclipse.

What can be improved?

When using multiple systems and complex projects I got annoyed at some point in time, that I don't know from which system the last log was, when it was written by which runner and if the last execution has finished or failed maybe.

Thats when I started my own class runner that have some improved capabilities.

How does it look like?

The output looks like this:

You see when, what, by whom and where it was started.
For every log entry you get a timestamp.
You see when the execution finished.
All times and dates are formatted in your personal date and time format

What about the ABAP code? Your code gets defined in the logic() method.

CLASS zcl_runner_demo DEFINITION
  PUBLIC
  INHERITING FROM zcl_base_runner
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.
    METHODS: logic REDEFINITION.
  PROTECTED SECTION.
  PRIVATE SECTION.
ENDCLASS.

CLASS zcl_runner_demo IMPLEMENTATION.
  METHOD logic.
    write( `Hello World` ).
    write( `this is a demo of the enhanced class runner` ).
    write( 123 ).
  ENDMETHOD.

ENDCLASS.

Methods write() and out->write()

The write() method has the same signature as the out->write() method, you can even access the original out->write() if needed.

  METHOD logic.
    write( `Hello World` ).
    write( `this is a demo of the enhanced class runner` ).
    write( 123 ).
    out->write( `bare write` ).
  ENDMETHOD.

of course you can pass structured and table data to write(), like you can do to out->write()

  METHOD logic.
    DATA ls_airport type /dmo/airport.
    write( `Hello World` ).
    ls_airport = value #( airport_id = 'SAP' city = 'Dokkerland' ).
    write( ls_airport ).
    write( name = 'Info about airport' data = ls_airport ).
  ENDMETHOD.

Uncaught exceptions

Method logic is secured against uncaught exceptions.

  METHOD logic.
    write( `Hello World` ).
    raise EXCEPTION new cx_abap_invalid_name(  ).
  ENDMETHOD.

It logs the behaviour:

How does it look under the hood?

It is basically an abstract class that wraps the original ADT class runner:

"! <p class="shorttext synchronized" lang="en">Base Runner</p>
"! Improved class runner with enhanced logging capabilities
CLASS zcl_base_runner DEFINITION
  PUBLIC
  ABSTRACT
  CREATE PUBLIC.

  PUBLIC SECTION.

    INTERFACES if_oo_adt_classrun .

    "! <p class="shorttext synchronized" lang="en">This method implements your logic</p>
    "! You can use {  .METH:write } with enhanced capabilities or the {  .DATA:out }->write( ) for plain logging.
    "! @raising cx_root | <p class="shorttext synchronized" lang="en">any exception not caught, will be handled in the runner.</p>
    METHODS logic ABSTRACT
      RAISING cx_root.

    CLASS-METHODS convertuuid
      IMPORTING
                str            TYPE string
      RETURNING VALUE(rv_uuid) TYPE sysuuid_c32.

  PROTECTED SECTION.

    DATA out TYPE REF TO if_oo_adt_classrun_out.

    "! <p class="shorttext synchronized" lang="en">wrapper for out->write( )</p>
    "! this enhances the default function by writing a timestamp.
    "! this method should be used in {@link .METH:logic }
    "! @parameter data | <p class="shorttext synchronized" lang="en"></p>
    "! @parameter name | <p class="shorttext synchronized" lang="en"></p>
    METHODS write
      IMPORTING
        data TYPE any
        name TYPE string OPTIONAL.

  PRIVATE SECTION.

    "! <p class="shorttext synchronized" lang="en">determine the current timestamp and returns as string</p>
    "! <ul><li>in users timezone</li><li>in users prefered format</li></ul>
    "! @parameter rv_dateandtime | <p class="shorttext synchronized" lang="en"></p>
    CLASS-METHODS getCurrentDateandTimeFormatted
      RETURNING VALUE(rv_dateandtime) TYPE string.

    "! <p class="shorttext synchronized" lang="en">draws a horizontal line on the console</p>
    "!
    "! @parameter out | <p class="shorttext synchronized" lang="en"></p>
    CLASS-METHODS horizontalLine
      IMPORTING out TYPE REF TO if_oo_adt_classrun_out.

ENDCLASS.



CLASS zcl_base_runner IMPLEMENTATION.

  METHOD if_oo_adt_classrun~main.

    me->out = out.

    horizontalline( out ).

    TRY.

        out->write( |Start on { xco_cp=>current->tenant( )->get_url( io_type = xco_cp_tenant=>url_type->ui )->get_host(  ) } runner { cl_abap_classdescr=>get_class_name( me ) } by { cl_abap_context_info=>get_user_formatted_name( ) }| &&
        | at { getcurrentdateandtimeformatted(  ) }| ).

      CATCH cx_abap_context_info_error INTO DATA(lc_context_error).
        "handle exception
        out->write( 'Error occured in determine current user:' ).
        out->write( lc_context_error->get_text(  ) ).
    ENDTRY.

    TRY.
        me->logic( ).

      CATCH cx_root INTO DATA(lc_error).
        "handle exception
        write( 'Error occured in executing the logic:' ).
        write( lc_error->get_text(  ) ).
        DATA(previous) = lc_error->previous.
        IF lc_error->previous IS BOUND.
          write( name = 'Previous' data = lc_error->previous->get_text(  ) ).
        ENDIF.


    ENDTRY.

    out->write( |Done at { getcurrentdateandtimeformatted(  ) }| ).

    horizontalline( out ).

  ENDMETHOD.

  METHOD write.

    DATA(descr_ref) = cl_abap_typedescr=>describe_by_data( data ).

    IF name IS INITIAL.

      IF descr_ref IS INSTANCE OF cl_abap_elemdescr.
        out->write( data = |{ getcurrentdateandtimeformatted(  ) }: { data }| ).
      ELSE.
        out->write( data = |{ getcurrentdateandtimeformatted(  ) }:| ).
        out->write( data = data ).
      ENDIF.

    ELSE.
      IF descr_ref IS INSTANCE OF cl_abap_elemdescr.
        out->write( data = |{ getcurrentdateandtimeformatted(  ) }: { Name }:{ data }| ).
      ELSE.
        out->write( data = |{ getcurrentdateandtimeformatted(  ) }: { Name }:| ).
        out->write( data = data ).
      ENDIF.
    ENDIF.
  ENDMETHOD.

  METHOD getcurrentdateandtimeformatted.
    DATA tsp TYPE tzntstmps.
    DATA(lo_unix_timestamp) = xco_cp=>sy->unix_timestamp( ).
    DATA(lo_moment) = lo_unix_timestamp->get_moment( xco_cp_time=>time_zone->user ).
    tsp = lo_moment->as( xco_cp_time=>format->abap )->value.
    rv_dateandtime = |{ tsp TIMESTAMP = USER }|.
  ENDMETHOD.

  METHOD horizontalline.
    out->write( repeat( val = '-' occ = 120 ) ).
  ENDMETHOD.

  METHOD convertuuid.
    DATA(lo_uuid) = xco_cp_uuid=>format->c36->to_uuid( str ).
    rv_uuid = xco_cp_uuid=>format->c32->from_uuid( lo_uuid ).
  ENDMETHOD.

ENDCLASS.

Summary

The improved class runner is a tool that supports SAP NetWeaver, SAP S/4HANA and SAP BTP, ABAP environment, basically everywhere the class runner is supported.

I put in a function for UUID conversion that I used in one of my last projects a lot, of course its optional.

It would be easy to extend this logic for application job execution too. All you need is an additional wrapper that rewrites the write method to append an application log and calls the logic method from the application job.

Feel free to share, reuse and enhance this idea.

If you like this post or it helped you, don't hesitate to give kudos.

Customer & Partner Roundtable for SAP BTP ABAP Environment #12

2024-04-24T20:33:53.136000+02:00

👉 The call for contributions for one of the upcoming roundtables is open!

If you want to show a demo or share a use case scenario for SAP BTP ABAP Environment send us an email and we will get back to you.

Introduction

As SAP BTP ABAP environment (aka Steampunk) and ABAP Cloud became more and more popular inside and outside of SAP, there is a high demand for rolling out the latest product news and updates, asking questions, and of course showing demos.

💡 If you weren’t able to join one of our previous roundtables, you can find the slides presented, recordings, and further references in this GitHub repository.

Meeting Information

When:

May 23rd, 10:00 - 11:00 AM CET – Zoom Meeting (please register in advance)

Who:

All interested customers, partners, and stakeholders are invited to join and exchange ideas and feedback with others and the product team
Steampunk team: Frank Jentsch (Product Lead for SAP BTP ABAP Environment), Anne Keller (Chief Development Experts ABAP Cloud Dev Tools), Thomas Alexander Ritter (Area Product Owner ABAP Cloud Dev Tools), Iwona Hahn & Burcu Karlidag (BTP ABAP Product Manager)

Preliminary Agenda:

Product news
New features of 2405 release
E2E Developer Experience for ABAP Cloud incl. demo
Q&A

Looking forward to meeting you!

Check out our SAP Business Technology ABAP Environment page in SAP Community for product updates and upcoming events.

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.

Get started with SAP BTP ABAP Environment: Trial Account vs. Free Tier Option

2024-04-26T15:24:35.800000+02:00

Understanding the various Try and Buy options is crucial in exploring the SAP BTP ABAP Environment, ensuring an easy start to your journey. Let's take a closer look at the two tryout options:

Trial Account

The SAP BTP trial allows you to experiment and educate yourself and get familiar with the SAP BTP ABAP Environment. The instance is shared between all trial users. This shared trial offering allows users to share an instance, where all development objects are visible and editable by other trial users. You agree not to upload any personal data, any confidential information of you or your company, or use the service for a productive environment. By default, the trial account lasts for 30 days but can be extended up to 90 days. After this period, the instance is automatically deleted, and a seamless transition to a paid standard version isn't feasible. Due to the shared instance approach, a few features like connectivity are not supported. Please find more information in this blog post.

Free Tier Option

Designed for small proof-of-concept projects, the free tier option offers exploration of all capabilities for non-productive scenarios over a fixed 90-day trial period. It can also be utilized for piloting remote ABAP Test Cockpit (ATC) scenarios against on-premise systems in the Custom Code Migration App. Unlike the trial version, each user has their own instance. A seamless transition to the paid standard plan is supported within the trial period, without data loss. After 90 days, the instance is automatically deleted.

Selecting the appropriate choice

To choose the right option between the trial account and the free tier option, consider your specific needs and goals:

Category	Trial Account	Free Tier Option
Purpose	Experimentation, educational purposes	Small proof-of-concept projects, non-productive scenarios
Feature Set	Limited	Not limited
Duration	Extendable up to 90 days	Fixed 90-day trial period
Data Privacy and Security	Shared instance	Individual instance
Seamless Transition	Not possible	Possible

Please evaluate these aspects and consider your future beyond the trial period to determine which option aligns best with your needs.

The 2024 Developer Insights Survey: The Report

2024-04-30T03:48:33.552000+02:00

We normally publish the annual external report for our annual SAP Developer Insights Survey directly on SAP Developer Center. This year we encountered an unfortunate process issue that delayed publishing this report on that site: rather than delaying it further, I'm posting a copy of the report here for Community review and discussion. We'll post the final copy on developers.sap.com as soon as practical.

Role Overlaps for external SAP developers

Part I: Introduction and General Information

Welcome to the 2024 SAP Developer Insights Survey report. This annual survey targets SAP’s existing external developer audience. It is used to track demographics, usage patterns, and trends within that population. 2024 is the fifth year we have conducted the survey. The survey program is led by the SAP Ecosystem and Community team. Key support is provided by the SAP Global Experience Management Office. Several other SAP teams provide advice and inputs to survey content. Those teams are listed at the end of this report.

This year's survey was open for six weeks - from mid-January through the end of February.

Each year's survey is composed of a mix of new topic questions and repeat select questions from past years to track trends.

Key Findings from the 2024 Survey

SAP Low Code / No Code Use is Increasing - this is true both on production Extension projects and proportional to competitor Low Code / No Code products
Increasing Presence of Solution Architects - this is a trend we noted last year and it continues this year. 42% of respondents now report that they acted in the role of Solution or Application Architect in the last year -- this proportion has been consistently rising and is up by a net 20% in the past two years. This role is probably underserved in our current external outreach and is likely a good area to focus upon for new programs.
SAP Developer Satisfaction is flat or slightly declining - 70% of respondents report they are “very satisfied” or “satisfied” with their development work with SAP. This is down from 75% in 2023 -- lower, but just within the margin of error for responses to this question.
Back-to-Office trend slowing - we have been tracking these numbers since 2021. Additional 2024 respondents report settling back into a tradition office work environment, but the rate of the shift has slowed.
BTP Developers Guide - limited awareness -- this important guidance document was announced at TechEd this past November, but barely half of respondents were aware of its existence.

These topics will be covered in more detail in the rest of the report.

General Topics

We included a number of general questions in the survey covering such topics as age, work location and status, as well as role.

Employment Status and Relation to SAP

Employment

"What is your current employment status?"

SAP Developer Community Composition

We have seen no significant change in these breakdowns from year to year.

SAP Developer Community Age Distribution

There is a modest decrease this year in the two eldest age categories. There is a corresponding increase in the 35-44 bucket. We cannot produce an accurate median age from the way that we currently gather this information.

Part II. Narrowing the Response Set

A primary objective of our survey is to build a model of our community's usage patterns. It helps us build more effective programs. With that goal in mind, in the remainder of the report we will narrow the data we'll consider in these ways:

External Developers Only - we exclude responses from SAP employees, and others (students, analysts, etc.)
Recent Development Experience - we only include responses from those who stated that they had been part of an SAP extension or integration project within the past year

Workplace and Trends

Office Location

"As of right now, where do you primarily physically work from?"

Year-to-year trend in Workplace

This shows a slowing trend of employees moving back to conventional offices from home. From a past Developer Survey, 29% of respondents reported they had primarily worked at home prior to the pandemic.

Where are the Developers?

We asked, "Which country are you based in?"

Respondent Count

Position	Country
1	India	108
2	Germany	93
3	United States	29
4	Turkey	18
5	Australia	16
6	Spain	15
7	Canada	12
8	Italy	8
9	Brazil	7
10	Denmark	7
11	Mexico	7
12	Switzerland	6
13	Austria	6
14	Chile	5
15	Czech Republic	5

By country, India has the largest number of respondents and probably the densest geographic concentration, followed by Germany, and then the USA. When grouped by SAP region, however, EMEA North is largest.

Development Job Roles

We asked respondents which common development-related roles they perform.

"Which roles describe your day-to-day work? (Select all that apply)"

Respondents often "wear multiple hats" in their job. This question is asked in "select all that apply" form to capture that information.
The Venn diagram on the right depicts the relative overlaps of the top seven roles reported by respondents. The area of each overlapping region reflects the count respondents performing the overlapping roles. For example, from this we can seel that all (UX) "Designers" are also "Developers". Most but not quite all "Enterprise Architects" also are "Solution Architects".

It is unsurprising that the "Developer" role leads. Architecture roles as a group have increased each year. Solution/Application developer shows roughly a ten percent increase, year to year. This probably corresponds to SAP Developers' steady move to the Cloud -- cloud extensibility offers more choices in solving a given business problem, and Solution Architects are the role responsible most often for making such decisions.

Development Domains

For respondents selecting "Developer" as one of their roles, we were interested in the specific application domains they work in:

"Which of the following development domains describe your day-to-day work? (select all that apply)"

Year to year, Integration came in higher than we expected. Mobile web front-end development is more common than native mobile application development. This isn't completely unexpected, but worth noting.

Recent SAP Project Experience?

"Have you developed integrations or extensions for any SAP products or technologies in the past 12 months?"

Extension and Integration are key scenarios for developers working with SAP applications. We wanted to focus on developers with recent experience in these areas. Roughly 70% of developers answered "Yes" here.

Popular Programming Languages

"Which programming languages have you used in your development work over the past 12 months? Please select all that apply."

This was posed as a multiple response question. ABAP dominates, as it has in every year of our survey. JavaScript is very popular as well, which could be attributed to its use in both SAPUI5 and CAP. Java and Python are roughly tied for third place. The relative positions of these top four languages hasn't changed much, year to year.

We extended our survey beyond just language use to ask about popular frameworks.

Popular Programming Frameworks

We asked respondents who are Developers to pick which common front and back-end frameworks they have worked with in the past year.

Front-Ends

Back-Ends

Application and Business Technology Platform Architectures

SAP applications can be extended using any one of several architectural approaches. These can be grouped into two major classes: on-stack (in-app) and side-by-side (essentially, BTP-based).

We were wondering which approaches are most popular.

Popular Extension Architectures

"For the most recent extension project that you were part of, what was the principal runtime architecture of the back-end elements?"

We don't distinguish between newer and older applications (e.g., S/4HANA vs. ECC) -- this likely explains the dominance of "on-stack ABAP". Aside from the obvious dominance of ABAP, we can also see that CAP is relatively popular. We also, somewhat unexpectedly, see that Low Code/No Code products like Build Apps and Build Process Automation have quickly grown in popularity -- this question is asking about real production projects, and seeing those two account for roughly 10% is an interesting surprise. Basically, they have only been available in the last year.

ABAP and CAP both have style or language variants in their respective frameworks.
ABAP can be programmed as "ABAP for Cloud Development" or "ABAP Standard". CAP is available in JavaScript or Java language variants.
Where the respondent selected ABAP or CAP, we asked about the variant used on the project:

ABAP Variants

CAP Variants

The roughly 50-50 breakdown of ABAP styles is consistent with responses elsewhere in the survey. It reflects that roughly half of the ABAP projects are ECC or very early forms of S/4HANA.

CAP/JavaScript if plainly most popular for CAP projects. It was curious that CAP/Java wasn't used all by itself and this gave us pause to go look at the data carefully. Recall that these results apply to external SAP Developers only. When we consider SAP employees as well, we do see projects that are CAP/Java-only. We have no explanation for why external developers might use both concurrently on a project. That's something maybe for follow-up investigation.

Popular IDEs

We are always curious about general work patterns of developers. We asked about developer's most commonly used editors. While it would be difficult in such a survey of all developers to add many questions, we were particularly curious about most popular IDE or editor.

Preferred IDE or Editor

"Which IDE or text editor do you most commonly use for development tasks?"

The editor of choice will depend on the language. For example, BAS does not currently support ABAP. This might contribute to its relatively low preference. At the same time, SAP GUI and -- arguably -- Eclipse are the primary editors for ABAP, so it's maybe no surprise that they are reflected as most popular. As a follow-on, we might look at the editor choices here for CAP/JS, CAP/Java, and ABAP developers separately.

Potential / Use of Generative AI for Developers

Generative AI for Developers

"Generative AI (GenAI) has been an exciting topic for developers in 2023. Looking forward, which of these GenAI capabilities do you expect will be useful in your work? Select the choice that best describes your interest or use for each technology area."

As these capabilities were not generally available in SAP products at the time of the survey, we posed a series of questions intended to gauge their interest in particular features that might be based on Generative AI technologies. Since one or more of these features might be available in non-SAP products, we included choices in each category for the respondent to state that they have either evaluated such a capability or are even using it today.

An brief explanation of each category was included in the survey and is shown below:

Code Generation and Autocompletion: GenAI tools can generate code snippets, complete lines of code, or suggest entire functions based on the context provided by the developer.

Bug Detection and Code Review: AI models can be trained to identify potential bugs and vulnerabilities in the code. They can also suggest improvements in code quality, best practices, and code consistency.

Automated Testing and Test Data Generation: GenAI can be used to create test cases, which can help in thoroughly testing software applications. This includes generating test data that covers edge cases, potentially reducing the time and effort in manual testing.

Documentation Generation: AI can assist in generating and updating technical documentation. It can interpret the code and create comprehensive documentation, which is crucial for maintaining and scaling software projects.

Natural Language Processing (NLP) for Code: AI models can translate natural language queries into code, allowing developers to express their intent in plain language. This can be particularly helpful for novice developers working with unfamiliar frameworks.

Customized User Experience Design: AI can help generate user interface designs to enhance user experience.

AI-Powered Development Tools: Integration of AI in IDEs for real-time assistance, such as suggesting optimizations, refactoring code, or even predicting the next steps in development.

Automated Code Refactoring: AI can assist in code refactoring by suggesting or even implementing improvements in code structure.

Software Design and Architecture: AI can help in generating software design patterns or architectural models based on specified requirements. This can speed up the initial stages of development and ensure adherence to best practices.

Enhanced Security Protocols: Generative AI can be used to develop advanced security protocols and encryption methods, providing robust security solutions in software applications.

Use of Select SAP Technologies

In past surveys we asked questions around the awareness and use of select SAP technologies. The list changes year to year. This year we asked more specific questions elsewhere, so the list is short.

Developer Satisfaction with SAP

SAP Development Satisfaction

"For your recent experience developing an integration or extension, how would you describe your overall satisfaction with SAP?"

Roughly 70% of respondents report they are “very satisfied” or “satisfied” with their development work with SAP. This is down from 75% reported in 2023 -- a lower number, but just within the margin of error for responses to this question.

BTP Developers Guide

Awareness and Use of the BTP Developers Guide

"A new BTP Developers Guide was announced at SAP’s TechEd this past November. Which statement best described your level of familiarity with this document?"

Nearly half of respondents were unaware of this document's release. Raising awareness for this and other related BTP framework documents would be a good goal for 2024.

Cloud Insights

We first asked respondents if they used any cloud providers for their projects. For those that answered, "yes", we asked about the use of several major providers, including SAP BTP. We also asked if their use included SAP or non-SAP projects. This information was condensed into a chart depicting the relative use of each cloud provider.

Similar to the earlier questions around BTP Environments, these numbers do not reflect a tally of projects for each platform - instead it reflects developer exposure to each.

Using Cloud Providers?

"Are you using any cloud providers for your development projects?"

We asked, "Which cloud providers are you using for development projects?" and we asked in a way to separate SAP-related projects from more general use.

SAP Business Technology Platform

Microsoft Azure

Amazon Web Services

Google Cloud Platform

Alibaba Cloud

Low / No Code Tools

This is the third consecutive year in which we've asked questions around Low Code and No Code products. The list was composed of leaders in the Gartner LCNC Magic Quadrant Report and select SAP products. SAP Process Automation -- now Build Process Automation -- was not yet announced at the time of the 2022 survey, so it only appears in the more recent data.

For each product, we asked respondents to select the most applicable category reflecting their awareness or use of the product (e.g., "I am aware of the product", "We plan to use the product", "We are currently using the product in production", ...). We normalized the tallies for each year to adjust for the annual variation in overall survey response counts. We then filtered down to just examine productive use:

Productive use of Product	2022	2023	2024
Vendor A	36%	33%	28%
SAP Build Process Automation	0%	8%	22%
SAP Build Apps	4%	14%	20%
Vendor B	24%	19%	13%
SAP Signavio	9%	10%	8%
Vendor C	12%	8%	5%
Vendor D	4%	2%	2%
Vendor E	5%	3%	1%
Vendor F	5%	3%	1%

Learning and Help Resources

We were interested in preferences in the format or media type of learning resources by respondents.

Preferred General Technical Resources

"When learning new skills or technical subjects over the past 12 months, what resources did you tend use the most? Please select up to three resources."

On the topic of Help, we shifted in this next question from formats to specific web sites.

Top SAP Help Resource Sites

"What is your preferred resource if you need help, or have a challenge with the SAP technology / tool you are working with? "

Almost sixty percent of respondents say they use organic search or SAP Community as their primary source of SAP help. This is consistent with past years. This continues to demonstrate good visibility of the Community site overall and likely speaks well for the usefulness of the site content.

SAP Learning Hub Subscribers

"Do you have a subscription to SAP Learning Hub?"

Technical Certifications

"How many technology-related certification programs have you completed within the past four years?"

Satisfaction with SAP Learning Hub

Overall Learning Hub Satisfaction

"How would you describe your overall satisfaction with SAP Learning Hub?"

Survey Methodology

This report is based on a Qualtrics web-based survey of 979 respondents from 56 countries. The survey ran for six calendar weeks between January 15th and March 1st, 2024. Ninety percent of the respondents invested ten minutes or less with the survey.

The survey was promoted via the SAP Community website and the SAP Developer Center, sap.com pop-up intercepts, social media posts.

Other References

The annual Stack Overflow Developer Survey is an excellent (and no-cost) reference for industry-wide habits of developers.

Creation of OData service with implementation of CRUD methods and `deep insert` method from scratch

2024-05-03T08:33:54.245000+02:00

Overview

-- Goal:

Using SAP instance with SAP NW 7.40 or higher without RAP and without BOPF be able to create OData service upon business data model with these specific requirements:

- inserting of main business record support deep inserting (we save main record of main entity and all enclosed records in child entity)

- all CRUD methods of modification records for entities should be supported .

- code after regenerating OData service after adding of new changes is under control of developer via implemented overridden methods.

-- Considered model:

-- Main steps of implementation:

Using Eclipse + ADT you will go through this main steps and with all necessary code:

1-- Prepare data model with data

2-- Create project for OData service

3-- Add data model and generate service

4-- Register service and do initial test

5-- Implementation of `deep insert` MODEL via override

6-- Implementation of entity modification methods

7-- Implementation of OData CRUD methods using override

8-- Testing CRUD methods by SAP Gateway Client

9-- Verification of achieved code

-- As result of you will have:

-- Transportable package ZMLODATA which includes:

-- Data model with samples of data

-- OData service ZML_TRAVELLING_ODT

-- Classes where _EXT implementation decupled from regenerating process of OData service

Package ZMLODATA will contain these files:

Service Project `ZML_TRAVELLING_ODT` will be like this one:

Process of implementation

1-- Prepare data model with data

1--1-- create package ZMLODATA

1--2-- create data elements in package

ZMLNAME

ZMLDATEFROM

ZMLDATETO

1--3-- create table ZML_TRAVEL

Using package ZMLODATA you create database table in Eclipse ADT by opening `New ABAP Repository Object` for `Database Table` and using this code definition:

@EndUserText.label : 'ZML_TRAVEL'
@AbapCatalog.enhancementCategory : #NOT_EXTENSIBLE
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #A
@AbapCatalog.dataMaintenance : #ALLOWED
define table zml_travel {
  key client    : abap.clnt not null;
  key travel_id : sysuuid_x16 not null;
  name          : zmlname;

}

1--4-- create table ZML_BOOKING

You add new Database Table `ZML_BOOKING` by this code into package ZMLODATA:

@EndUserText.label : 'ZML_BOOKING'
@AbapCatalog.enhancementCategory : #NOT_EXTENSIBLE
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #A
@AbapCatalog.dataMaintenance : #ALLOWED
define table zml_booking {
  key client     : abap.clnt not null;
  @AbapCatalog.foreignKey.screenCheck : false
  key travel_id  : sysuuid_x16 not null
    with foreign key [0..*,1] zml_travel
      where travel_id = zml_booking.travel_id;
  key booking_id : sysuuid_x16 not null;
  hotel          : zmlname;
  dayfrom        : zmldatefrom;
  dayto          : zmldateto;

}

1--5-- Create Class `zml_gen_data_travels`

In package ZMLODATA you add new ABAP class `zml_gen_data_travels` by this code:

CLASS zml_gen_data_travels DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.

    INTERFACES if_oo_adt_classrun .
  PROTECTED SECTION.
  PRIVATE SECTION.
ENDCLASS.



CLASS zml_gen_data_travels IMPLEMENTATION.
  METHOD if_oo_adt_classrun~main.

    DATA it_travel TYPE TABLE OF zml_travel.
    DATA it_booking TYPE TABLE OF zml_booking.

    DATA lv_long_time_stamp TYPE timestampl.
    GET TIME STAMP FIELD lv_long_time_stamp.
    DATA: l_uuid_x16 TYPE sysuuid_x16.
    DATA: system_uuid TYPE REF TO if_system_uuid.
    DATA: oref        TYPE REF TO cx_uuid_error.
    system_uuid = cl_uuid_factory=>create_system_uuid( ).

    TRY.

        it_travel =  VALUE #(
          ( client = sy-mandt travel_id = system_uuid->create_uuid_x16( ) name = 'Travel Minsk - Dubai' )
          ( client = sy-mandt travel_id = system_uuid->create_uuid_x16( ) name = 'Travel Minsk - Moscow' )
          ( client = sy-mandt travel_id = system_uuid->create_uuid_x16( ) name = 'Travel Minsk - Warsaw' )
          ( client = sy-mandt travel_id = system_uuid->create_uuid_x16( ) name = 'Travel Minsk - Dushanbe' )
          ( client = sy-mandt travel_id = system_uuid->create_uuid_x16( ) name = 'Travel Minsk - Batumi' )

        ).

        it_booking = VALUE #(
            ( client = sy-mandt booking_id = system_uuid->create_uuid_x16( ) travel_id = it_travel[ name = 'Travel Minsk - Dubai' ]-travel_id dayfrom = '20240101'  dayto = '20240104' hotel = 'Amirates Dubai' )
            ( client = sy-mandt booking_id = system_uuid->create_uuid_x16( ) travel_id = it_travel[ name = 'Travel Minsk - Moscow' ]-travel_id dayfrom = '20240105'  dayto = '20240107' hotel = 'Marriot' )
            ( client = sy-mandt booking_id = system_uuid->create_uuid_x16( ) travel_id = it_travel[ name = 'Travel Minsk - Warsaw' ]-travel_id dayfrom = '20240108'  dayto = '20240114' hotel = 'Outstanding WSW' )
            ( client = sy-mandt booking_id = system_uuid->create_uuid_x16( ) travel_id = it_travel[ name = 'Travel Minsk - Dushanbe' ]-travel_id dayfrom = '20240115'  dayto = '20240124' hotel = 'Marriot Hayat' )
            ( client = sy-mandt booking_id = system_uuid->create_uuid_x16( ) travel_id = it_travel[ name = 'Travel Minsk - Batumi' ]-travel_id dayfrom = '20240125'  dayto = '20240130' hotel = 'Amber Sea' )
        ).

        out->write( it_travel ).
        out->write( it_booking ).

*       delete existing entries in the database table
        DELETE FROM zml_booking.
        DELETE FROM zml_travel.


*       insert the new table entries
        INSERT zml_travel FROM TABLE @IT_travel.
        INSERT zml_booking FROM TABLE @IT_booking.

        out->write( |Demo data generated for tables...| ).

      CATCH cx_uuid_error.
        "handle exception
    ENDTRY.



  ENDMETHOD.

ENDCLASS.

1--6-- Run this class by pressing F9

You execute previously created class to add initial records into your data model by pressing F9.

5 records with travels and 5 records connected to each travel for bookings will be added after executing.

1--7-- at this moment you should have package with your dictionary and class

1--8-- you open data tables by preview of data to find that test records exist:

2-- create project for OData service

You press Alt-F8 and enter and run transaction: SEGW

In opened form you press icon of "Create project"

You fill in this information on form of creating project:

Project	ZML_TRAVELLING_ODT
Description	OData for travelling data
Package	ZMLODATA

You get a project `ZML_TRAVELLING_ODT` which has initial skeleton without connectivity to your model at this moment:

3-- Add data model and generate service

Using project `ZML_TRAVELLING_ODT` you do the next steps to import your entitles of model one by one, make necessary association between entities and generate project.

3--1-- Add Entity Type for ZML_TRAVEL table

Change project `ZML_TRAVELLING_ODT` to Edit mode.

Using context menu of Data model node you have to choose: Import -> DDIC Stucture

On first step of import wizard you provide the next information:

Name of type which we want create:	ZML_ITRAVEL
ABAP Structure (existing our table):	ZML_TRAVEL

On second step mark all fields:

On third step point the key of your records as TRAVEL_ID

In imported properties provide correctly operations:

if you open Entity Sets you should be able to find there `ZML_ITRAVELSet`

3--2-- Add Entity Type for ZML_BOOKING table

Again, you using context menu of Data model node choose Import -> DDIC Structure to open Wizard of importing.

On the first step of import wizard you provide:

Name of type which we want create:	ZML_IBOOKING
ABAP Structure (existing our table):	ZML_BOOKING

On second step of wizard you select all fields of entity.

And on the 3d step of wizard you point key id BOOKING_ID :

3--3-- Add association between ZML_ITRAVEL and ZML_IBOOKING

Using context menu on Association node you choose `Create` to start the wizard of creating association.

You should provide these parameters on Step 1 of association wizard:

Association Name	ZML_TRAVEL_TO_BOOKING
Principal Entity Type Name	ZML_ITRAVEL
Principal Cardinality	1
Principal Navigation Property	TO_BOOKING
Dependent Entity Type Name	ZML_IBOOKING
Dependent Cardinality	0..n
Dependent Navigation Property

On Step 2 of wizard association you point principal key TravelId for `Dependent Property`:

On Step 3 of wizard association you press Finish

You can check association in node Associations:

Also, you can check as `Navigation Property` with name `TO_BOOKING` if you expand Entity Types nodes in Data Model of project. The existence of this navigation property after applying association and the name `TO_BOOKING` we will use for `expand` functionality as well as for `deep insert` functionality

3--4-- Generate Runtime Objects of OData service

You press icon `Generate Runtime Objects`

As a result, 4 classes with prefix `ZCL_` will be generated in your package. Currently, all methods to serve ZML_IBTRAVELSET and ZML_IBOOKINGSET entity types will be pre-filled in with pattern of raising exception to generate message that method is not implemented yet. Later on, you will do implementation of each method in classes with `_EXT` suffix by overriding methods.

4-- Register service and do initial test

You should register service into SAP gateway and verify that service is maintained by initial test. It is better to do now, before you start implementation of methods to let you be ensured that service engin is generated correctly and you were able to maintain it correctly into SAP Gateway.

4--1-- Register service

In project open node `Service maintenance` and choose accessible SAP Gateway and press button `+Register` and then on prefilled form choose package ZMLODATA and save registration.

After registration you will be re-directed to Service Maintenance list ( also you can use transaction to be there in any time: /IWFND/MAINT_SERVICE ) where you can choose your service by technical name 1ZML_TRAVELLING_ODT`.

4--2-- Initial test

Once your service is registered you can test it by `SAP Gateway Client` through opening Maintenance list and then after choosing your service using ICF Nodes panel do pressing on `SAP Gateway Client` or you can directly start testing client form Service Maintenance of chosen gateway by pressing button `SAP Gateway Client` on form of Service registration.

Press `SAP Gateway Client` and and execute proposed URI and check that you have HTTP response with status 200 OK

change URI to ask provide operations with format JSON (just change format=xml to format=json)

/sap/opu/odata/sap/ZML_TRAVELLING_ODT_SRV/?$format=json

and execute to verify that you can get JSON response with status 200 Ok :

So currently OData which you created has information about your entities but if you try to use those entities (datasets) you will have error, because entities are not still connected to your data in databases.

if you will try to run this request:

/sap/opu/odata/sap/ZML_TRAVELLING_ODT_SRV/ZML_ITRAVELSet?$format=json

instead of data in response you will find error 501 and message "Method 'ZML_ITRAVELSET_GET_ENTITYSET' not implemented in data provider class"

In next steps (5,6,7) you will implement all necessary methods.

5-- Implementation of `deep insert` MODEL via override

As developer, you should modify class which is dedicated for extending object model of implementation: `zcl_zml_travelling_odt_mpc_ext` where name of class is proposed during generating service and the name of class for extending model by default is a combination: `ZCL`_ + <name_of_service> + `_MPC_EXT`

you will add manually the new deep structure there and do override of existing method `define` to be able map structure to certain entity.

This implementation is important to enable using structure for `deep insert` which will be needing to write correctly code for method CREATE of entity ZML_ITRAVELSet,.

5--1-- Add structure for `deep insert`

Open class for extending `zcl_zml_travelling_odt_mpc_ext` which is here:

You should add new type for structure of deep insert which is based on your types of data sets.

Goal to create hierarchy of types:

In public section of extension class zcl_zml_travelling_odt_mpc_ext you should add new structure:

    TYPES: BEGIN OF ty_s_trv_book.
             INCLUDE TYPE zcl_zml_travelling_odt_mpc=>ts_zml_itravel.
    TYPES:
             to_booking TYPE STANDARD TABLE OF zcl_zml_travelling_odt_mpc=>ts_zml_ibooking WITH DEFAULT KEY,
           END OF ty_s_trv_book.

Name of structure for this particular example is `ty_s_trv_book`.

5--2-- Override method `define`

Open in editor class zcl_zml_travelling_odt_mpc_ext and press Ctrl + space and choose Override `define`.

In overridden method is main aim is to map entity type of service to new structure of `deep insert`. Code of overridden method `define`:

  METHOD define.

    DATA lo_entity_type TYPE REF TO /iwbep/if_mgw_odata_entity_typ.

    super->define( ).

    lo_entity_type = model->get_entity_type( iv_entity_name = 'ZML_ITRAVEL' ).
    lo_entity_type->bind_structure( iv_structure_name = 'zcl_zml_travelling_odt_mpc_ext=>ty_s_trv_book' ).

  ENDMETHOD.

5--3-- Full code of extension method after preparation of `deep insert`:

CLASS zcl_zml_travelling_odt_mpc_ext DEFINITION
  PUBLIC
  INHERITING FROM zcl_zml_travelling_odt_mpc
  CREATE PUBLIC .

  PUBLIC SECTION.
    TYPES: BEGIN OF ty_s_trv_book.
             INCLUDE TYPE zcl_zml_travelling_odt_mpc=>ts_zml_itravel.
    TYPES:
             to_booking TYPE STANDARD TABLE OF zcl_zml_travelling_odt_mpc=>ts_zml_ibooking WITH DEFAULT KEY,
           END OF ty_s_trv_book.

    METHODS define REDEFINITION.



  PROTECTED SECTION.
  PRIVATE SECTION.
ENDCLASS.



CLASS zcl_zml_travelling_odt_mpc_ext IMPLEMENTATION.

  METHOD define.

    DATA lo_entity_type TYPE REF TO /iwbep/if_mgw_odata_entity_typ.

    super->define( ).

    lo_entity_type = model->get_entity_type( iv_entity_name = 'ZML_ITRAVEL' ).
    lo_entity_type->bind_structure( iv_structure_name = 'zcl_zml_travelling_odt_mpc_ext=>ty_s_trv_book' ).

  ENDMETHOD.

ENDCLASS.

6-- Implementation of entity modification methods

As developer, you should modify class which is dedicated for extending methods to work with data: `zcl_zml_travelling_odt_dpc_ext` where name of class is proposed during generating service and the name of class for extending data methods is combination of by default: `ZCL`_ + <name_of_service> + `_DPC_EXT`

Before start extending OData CRUD methods, you add 3 custom methods in this particular case:

6--1-- add custom method `zml_create_uuid` for getting UUID:

In protected section of class definition add:

    METHODS zml_create_uuid
      RETURNING VALUE(es_uuid) TYPE sysuuid_x16.

In implementation area of class add:

  METHOD zml_create_uuid.
    DATA lv_long_time_stamp TYPE timestampl.
    GET TIME STAMP FIELD lv_long_time_stamp.
    DATA: l_uuid_x16 TYPE sysuuid_x16.
    DATA: system_uuid TYPE REF TO if_system_uuid.
    DATA: oref        TYPE REF TO cx_uuid_error.
    system_uuid = cl_uuid_factory=>create_system_uuid( ).

    TRY.
        es_uuid = system_uuid->create_uuid_x16( ).
      CATCH cx_uuid_error.
        "handle exception
    ENDTRY.
  ENDMETHOD.

6--2-- add custom method `zml_modify_travel` for update or insert ZML_TRAVEL entity:

In protected section of class definition add:

    METHODS zml_modify_travel
      IMPORTING
                !ls_entity       TYPE zcl_zml_travelling_odt_mpc=>ts_zml_itravel
      RETURNING VALUE(es_entity) TYPE zcl_zml_travelling_odt_mpc=>ts_zml_itravel.

In implementation area of class add:

  METHOD zml_modify_travel.
    DATA:
      it_entity TYPE zcl_zml_travelling_odt_mpc=>ts_zml_itravel.
    MOVE-CORRESPONDING ls_entity TO it_entity.
    IF ( it_entity-client IS INITIAL ).
      it_entity-client = sy-mandt.
    ENDIF.
    TRY.
        it_entity-name = ls_entity-name.
        DATA itb_entity TYPE TABLE OF zml_travel.
        IF ( it_entity-travel_id IS INITIAL ).
          it_entity-travel_id = zml_create_uuid( ).
          itb_entity = VALUE #( ( it_entity )  ).
          INSERT zml_travel FROM TABLE @itb_entity.
        ELSE.
          itb_entity = VALUE #( ( it_entity )  ).
          MODIFY zml_travel FROM TABLE @itb_entity.
        ENDIF.
        es_entity = it_entity.
      CATCH cx_uuid_error.
    ENDTRY.
  ENDMETHOD.

6--3-- add custom method `zml_modify_booking` for update or insert ZML_BOOKING entity:

In protected section of class definition add:

    METHODS zml_modify_booking
      IMPORTING
                !ls_entity       TYPE zcl_zml_travelling_odt_mpc=>ts_zml_ibooking
      RETURNING VALUE(es_entity) TYPE zcl_zml_travelling_odt_mpc=>ts_zml_ibooking.

In implementation area of class add:

  METHOD zml_modify_booking.
    DATA:
    it_entity TYPE zcl_zml_travelling_odt_mpc=>ts_zml_ibooking.
    MOVE-CORRESPONDING ls_entity TO it_entity.
    IF ( ls_entity-client IS INITIAL ).
      it_entity-client = sy-mandt.
    ENDIF.
    IF ( ls_entity-travel_id IS NOT INITIAL ).
      TRY.
          DATA itb_entity TYPE TABLE OF zml_booking.
          IF ( it_entity-booking_id IS INITIAL ).
            it_entity-booking_id = zml_create_uuid( ).
            itb_entity = VALUE #( ( it_entity )  ).
            INSERT zml_booking FROM TABLE @itb_entity.
          ELSE.
            itb_entity = VALUE #( ( it_entity )  ).
            MODIFY zml_booking FROM TABLE @itb_entity.
          ENDIF.
          es_entity = it_entity.
        CATCH cx_uuid_error.
      ENDTRY.
    ENDIF.

  ENDMETHOD.

6--4-- add custom method `deep_insert_travel_booking` for insert ZML_TRAVEL and ZML_BOOKING entities:

In protected section of class definition add:

    METHODS deep_insert_travel_booking
      IMPORTING
        !io_data_provider TYPE REF TO /iwbep/if_mgw_entry_provider
      EXPORTING
        !es_s_trv_book    TYPE zcl_zml_travelling_odt_mpc_ext=>ty_s_trv_book
      RAISING
        /iwbep/cx_mgw_busi_exception
        /iwbep/cx_mgw_tech_exception .

In implementation area of class add:

  METHOD deep_insert_travel_booking.
    DATA: ls_travel_booking_data TYPE zcl_zml_travelling_odt_mpc_ext=>ty_s_trv_book.
    DATA: ls_entity TYPE zcl_zml_travelling_odt_mpc=>ts_zml_itravel.
    DATA: ls_childentity TYPE zcl_zml_travelling_odt_mpc=>ts_zml_ibooking.
    DATA: ar_childentities TYPE STANDARD TABLE OF zcl_zml_travelling_odt_mpc=>ts_zml_ibooking WITH DEFAULT KEY.
    io_data_provider->read_entry_data( IMPORTING es_data = ls_travel_booking_data ).
    MOVE-CORRESPONDING ls_travel_booking_data TO ls_entity.
    ls_entity = zml_modify_travel( ls_entity = ls_entity ).
    MOVE-CORRESPONDING ls_travel_booking_data-to_booking TO ar_childentities.
    LOOP AT ar_childentities INTO ls_childentity.
      ls_childentity-travel_id = ls_entity-travel_id.
      ls_childentity = zml_modify_booking( ls_entity = ls_childentity ).
      ar_childentities[ sy-index ] = ls_childentity.
    ENDLOOP.
    MOVE-CORRESPONDING ls_entity TO es_s_trv_book.
    MOVE-CORRESPONDING ar_childentities TO es_s_trv_book-to_booking.
  ENDMETHOD.

7-- Implementation of OData CRUD methods using override

7--1-- Start override methods

Open class `ZCL_ZML_TRAVELLING_ODT_DPC_EXT` (name of class is proposed during generating for overriding and the name of class is combination of by default: `ZCL`_ + <name_of_service> + `_DPC_EXT`

This is generated class and will be regenerated if you need put changes in model and generate service once again.

SAP has classes for extending generated code, and those classes will not be re-created during generating, so your changes will be applicable after regenerating once again.

You can override any method by using Ctrl + space and choosing method for override from list:

7--2-- override method `/iwbep/if_mgw_appl_srv_runtime~create_deep_entity` manually

This is single method which we do overriding manually and with definition in PUBLIC SECTION of class.

Add to PUBLIC SECTION this redefinition:

METHODS /iwbep/if_mgw_appl_srv_runtime~create_deep_entity REDEFINITION.

Add to implementation area:

  METHOD /iwbep/if_mgw_appl_srv_runtime~create_deep_entity.
    DATA: ls_travel_booking_data TYPE zcl_zml_travelling_odt_mpc_ext=>ty_s_trv_book.
    CLEAR: er_deep_entity.
    TRY.
        CALL METHOD deep_insert_travel_booking
          EXPORTING
            io_data_provider = io_data_provider
          IMPORTING
            es_s_trv_book    = ls_travel_booking_data.
        copy_data_to_ref(
         EXPORTING
           is_data = ls_travel_booking_data
         CHANGING
           cr_data = er_deep_entity ).
      CATCH /iwbep/cx_mgw_busi_exception.
    ENDTRY.
  ENDMETHOD.

7--3-- override method `zml_itravelset_update_entity`

  METHOD zml_itravelset_update_entity.
    DATA:
      ls_converted_keys TYPE zcl_zml_travelling_odt_mpc=>ts_zml_itravel,
      ls_entity         TYPE zcl_zml_travelling_odt_mpc=>ts_zml_itravel.
    io_data_provider->read_entry_data( IMPORTING es_data = ls_entity ).
    IF ( ls_entity-travel_id IS INITIAL ).
      io_tech_request_context->get_converted_keys(  IMPORTING es_key_values = ls_converted_keys ).
      ls_entity-travel_id = ls_converted_keys-travel_id.
    ENDIF.
    io_data_provider->read_entry_data( IMPORTING es_data = ls_entity ).
    CLEAR er_entity.
    er_entity = zml_modify_travel( ls_entity = ls_entity ).
  ENDMETHOD.

7--4-- override method `zml_itravelset_delete_entity`

  METHOD zml_itravelset_delete_entity.
    DATA: ls_converted_keys TYPE zcl_zml_travelling_odt_mpc=>ts_zml_itravel.
    io_tech_request_context->get_converted_keys( IMPORTING es_key_values = ls_converted_keys ).
    DELETE FROM zml_booking WHERE travel_id = ls_converted_keys-travel_id.
    DELETE FROM zml_travel WHERE travel_id = ls_converted_keys-travel_id.
  ENDMETHOD.

7--5-- override method `zml_itravelset_create_entity`

  METHOD zml_itravelset_create_entity.
    DATA: ls_entity TYPE zcl_zml_travelling_odt_mpc=>ts_zml_itravel.
    io_data_provider->read_entry_data( IMPORTING es_data = ls_entity ).
    CLEAR er_entity.
    er_entity = zml_modify_travel( ls_entity = ls_entity ).
  ENDMETHOD.

7--6-- override method `zml_ibookingset_get_entity`

  METHOD zml_ibookingset_get_entity.
    DATA:ls_keytab TYPE LINE OF /iwbep/t_mgw_name_value_pair.
    LOOP AT it_key_tab INTO ls_keytab.
    ENDLOOP.
    IF ( ls_keytab-name = 'BookingId' ).
      SELECT SINGLE * FROM zml_booking INTO CORRESPONDING FIELDS OF er_entity WHERE booking_id = ls_keytab-value.
    ELSEIF ( ls_keytab-name = 'TravelId' ).
      SELECT SINGLE * FROM zml_booking INTO CORRESPONDING FIELDS OF er_entity WHERE travel_id = ls_keytab-value.
    ENDIF.
  ENDMETHOD.

7--7-- override method `zml_itravelset_get_entity`

  METHOD zml_itravelset_get_entity.
    DATA:ls_keytab TYPE LINE OF /iwbep/t_mgw_name_value_pair.
    LOOP AT it_key_tab INTO ls_keytab.
    ENDLOOP.
    IF ( ls_keytab-name = 'BookingId' ).
      DATA: lv_travel_id TYPE zml_booking-travel_id.
      SELECT SINGLE travel_id FROM zml_booking INTO lv_travel_id WHERE booking_id = ls_keytab-value.
      IF sy-subrc = 0.
        SELECT SINGLE * FROM zml_travel INTO CORRESPONDING FIELDS OF er_entity WHERE travel_id = lv_travel_id.
      ENDIF.
    ELSEIF ( ls_keytab-name = 'TravelId' ).
      SELECT SINGLE * FROM zml_travel INTO CORRESPONDING FIELDS OF er_entity WHERE travel_id = ls_keytab-value.
    ENDIF.
  ENDMETHOD.

7--8-- override method `zml_ibookingset_get_entityset`

  METHOD zml_ibookingset_get_entityset.
    DATA:ls_keytab TYPE LINE OF /iwbep/t_mgw_name_value_pair.
    LOOP AT it_key_tab INTO ls_keytab.
    ENDLOOP.
    IF ( ls_keytab IS NOT INITIAL ).
      IF ( ls_keytab-name = 'BookingId' ).
        SELECT * FROM zml_booking INTO CORRESPONDING FIELDS OF TABLE et_entityset WHERE booking_id = ls_keytab-value.
      ELSEIF ( ls_keytab-name = 'TravelId' ).
        DATA: lv_travel_id TYPE zml_travel-travel_id.
        SELECT SINGLE travel_id FROM zml_booking INTO lv_travel_id WHERE travel_id = ls_keytab-value.
        SELECT * FROM zml_booking INTO CORRESPONDING FIELDS OF TABLE et_entityset WHERE travel_id = lv_travel_id.
      ENDIF.
    ELSE.
      SELECT * FROM zml_booking INTO CORRESPONDING FIELDS OF TABLE et_entityset.
    ENDIF.
  ENDMETHOD.

7--9-- override method `zml_itravelset_get_entityset`

  METHOD zml_itravelset_get_entityset.

    DATA: lv_source_entity_set_name TYPE /iwbep/mgw_tech_name.

    lv_source_entity_set_name = io_tech_request_context->get_source_entity_set_name( ).

    IF lv_source_entity_set_name IS INITIAL.

      SELECT * FROM zml_travel INTO CORRESPONDING FIELDS OF TABLE et_entityset.
    ELSE.
      SELECT * FROM zml_travel INTO CORRESPONDING FIELDS OF TABLE et_entityset.
    ENDIF.
  ENDMETHOD.

7--10-- override method `zml_ibookingset_update_entity`

  method zml_ibookingset_update_entity.
    DATA:
      ls_converted_keys TYPE zcl_zml_travelling_odt_mpc=>ts_zml_ibooking,
      ls_entity         TYPE zcl_zml_travelling_odt_mpc=>ts_zml_ibooking.
    io_data_provider->read_entry_data( IMPORTING es_data = ls_entity ).
    IF ( ls_entity-booking_id IS INITIAL ).
      io_tech_request_context->get_converted_keys(  IMPORTING es_key_values = ls_converted_keys ).
      ls_entity-booking_id = ls_converted_keys-booking_id.
    ENDIF.
    io_data_provider->read_entry_data( IMPORTING es_data = ls_entity ).
    CLEAR er_entity.
    er_entity = zml_modify_booking( ls_entity = ls_entity ).
  endmethod.

7--11-- override method `zml_ibookingset_delete_entity`

  method zml_ibookingset_delete_entity.
    DATA: ls_converted_keys TYPE zcl_zml_travelling_odt_mpc=>ts_zml_ibooking.
    io_tech_request_context->get_converted_keys( IMPORTING es_key_values = ls_converted_keys ).
    DELETE FROM zml_booking WHERE booking_id = ls_converted_keys-booking_id.
  endmethod.

7--12-- override method `zml_ibookingset_create_entity`

  method zml_ibookingset_create_entity.
    DATA: ls_entity TYPE zcl_zml_travelling_odt_mpc=>ts_zml_ibooking.
    io_data_provider->read_entry_data( IMPORTING es_data = ls_entity ).
    CLEAR er_entity.
    er_entity = zml_modify_booking( ls_entity = ls_entity ).
  endmethod.

8-- Testing CRUD methods by SAP Gateway Client

8--1-- GET all records from entities

8--1--1-- GET entities with query parameter $format=json

Check again by SAP Gateway Client that you can extract data from ZML_ITRAVELSet and for ZML_IBOOKINGSet

/sap/opu/odata/sap/ZML_TRAVELLING_ODT_SRV/ZML_ITRAVELSet?$format=json

/sap/opu/odata/sap/ZML_TRAVELLING_ODT_SRV/ZML_IBOOKINGSet?$format=json

8--1--2-- GET entities by using header parameters instead of query parameter

You need to be able to add header parameters because in json it is easier to operate and some operation will work only with header (POST, PATCH, PUT and DELETE)

So look at screenshots below how you can add parameters and all rest screenshots will have always header parameters for your understanding.

It is right to keep these two parameters added for all operations:

and add this parameter only for PATCH, PUT, and DELETE:

8--2-- GET specific record from entity

8--3-- GET specific record with details using EXPAND

8--4-- PUT change record to change.

8--4--1-- PUT for ZML_ITRAVELSet it will be:

8--4--2-- PUT for ZML_IBOOKINGSet it will be:

You can verify if data were successfully applied by GET:

8--6-- PATCH change only pointed parameters.

8--6--1-- PATCH for entity ZML_ITRAVELSet:

8--6--2-- PATCH for entity ZML_IBOOKINGSet:

You can verify if it was changes by GET:

8--8-- DELETE -remove record and all child records

8--8--1-- DELETE for entity ZML_ITRAVELSet

Your code you can check and in code we delete child records from ZML_IBOOKINGSet and then record from ZML_ITRAVELSet. But it is up to you have this logic. You can allow delete only if childe records were delete previously. Just for simplicity we do deleting as cascade.

Notice: parameter `if-match` should be removed from header, overwise you will have error.

8--8--2-- DELETE for entity ZML_IBOOKINGSet

Notice: parameter `if-match` should be removed from header, overwise you will have error.

8--9-- INSERT - add new records

8--9--1-- INSERT for entity set `ZML_ITRAVELSet`

You have implemented `deep insert` with deep structure. So you expect to create complex records when you POST entity ZML_ITRAVELSet. It will be one record for ZML_ITRAVELSet and related records (child records) for entity ZML_IBOOKINGSet. Deep structure supposes to use head structure from ZML_ITRAVELSet and child structure with name `TO_BOOK` from ZML_IBOOKINGSet. So you have to prepare request with such payload:

{
  "Client" : "001",
  "Name" : "Travel Minsk - Milano",
  "TO_BOOKING": [
    {
        "Client" : "001",
        "Hotel" : "Ahmat hotel",
        "Dayfrom" : "\/Date(1481760000000)\/",
        "Dayto" : "\/Date(1481760000000)\/"
    },
    {
      "Client" : "001",
      "Hotel" : "Yes hotel",
      "Dayfrom" : "\/Date(1481760000000)\/",
      "Dayto" : "\/Date(1481760000000)\/"
    }
  ]
}

you point this URI:

/sap/opu/odata/SAP/ZML_TRAVELLING_ODT_SRV/ZML_ITRAVELSet

and you choose method: POST

8--9--2-- INSERT for entity set `ZML_IBOOKINGSet`

You should know GUID of your parent record for ZML_ITRAVELSet

{
  "TravelId" : "0242ac11-0002-1eef-80aa-0315685dd657",
  "Hotel" : "Amirates Dubai stars",
  "Dayfrom" : "\/Date(1704067200000)\/",
  "Dayto" : "\/Date(1704326400000)\/"
}

Response contains payload about what has been added and and which Booking Id was created.

If you wish you can GET particular record by using (guid' value of Booking Id ') :

9-- Verification of achieved code

You can compare your code or if you feel that it is better to apply ready to use project and go through this document you can find this project here on GitHub:

https://github.com/lukcad/ZMLODATA.git

Also, you can verify your overridden methods for class zcl_zml_travelling_odt_dpc_ext here:

CLASS zcl_zml_travelling_odt_dpc_ext DEFINITION
  PUBLIC
  INHERITING FROM zcl_zml_travelling_odt_dpc
  CREATE PUBLIC .

  PUBLIC SECTION.


    METHODS /iwbep/if_mgw_appl_srv_runtime~create_deep_entity REDEFINITION.

  PROTECTED SECTION.
    methods zml_ibookingset_update_entity redefinition.
    methods zml_ibookingset_delete_entity redefinition.
    methods zml_ibookingset_create_entity redefinition.

    METHODS zml_create_uuid
      RETURNING VALUE(es_uuid) TYPE sysuuid_x16.

    METHODS zml_modify_travel
      IMPORTING
                !ls_entity       TYPE zcl_zml_travelling_odt_mpc=>ts_zml_itravel
      RETURNING VALUE(es_entity) TYPE zcl_zml_travelling_odt_mpc=>ts_zml_itravel.

    METHODS zml_modify_booking
      IMPORTING
                !ls_entity       TYPE zcl_zml_travelling_odt_mpc=>ts_zml_ibooking
      RETURNING VALUE(es_entity) TYPE zcl_zml_travelling_odt_mpc=>ts_zml_ibooking.

    METHODS deep_insert_travel_booking
      IMPORTING
        !io_data_provider TYPE REF TO /iwbep/if_mgw_entry_provider
      EXPORTING
        !es_s_trv_book    TYPE zcl_zml_travelling_odt_mpc_ext=>ty_s_trv_book
      RAISING
        /iwbep/cx_mgw_busi_exception
        /iwbep/cx_mgw_tech_exception .


    METHODS zml_itravelset_update_entity REDEFINITION.
    METHODS zml_itravelset_delete_entity REDEFINITION.
    METHODS zml_itravelset_create_entity REDEFINITION.
    METHODS zml_ibookingset_get_entity REDEFINITION.
    METHODS zml_itravelset_get_entity REDEFINITION.
    METHODS zml_ibookingset_get_entityset REDEFINITION.
    METHODS zml_itravelset_get_entityset REDEFINITION.

  PRIVATE SECTION.


ENDCLASS.



CLASS zcl_zml_travelling_odt_dpc_ext IMPLEMENTATION.

  METHOD zml_itravelset_get_entityset.

    DATA: lv_source_entity_set_name TYPE /iwbep/mgw_tech_name.

    lv_source_entity_set_name = io_tech_request_context->get_source_entity_set_name( ).

    IF lv_source_entity_set_name IS INITIAL.

      SELECT * FROM zml_travel INTO CORRESPONDING FIELDS OF TABLE et_entityset.
    ELSE.
      SELECT * FROM zml_travel INTO CORRESPONDING FIELDS OF TABLE et_entityset.
    ENDIF.
  ENDMETHOD.

  METHOD zml_ibookingset_get_entityset.
    DATA:ls_keytab TYPE LINE OF /iwbep/t_mgw_name_value_pair.
    LOOP AT it_key_tab INTO ls_keytab.
    ENDLOOP.
    IF ( ls_keytab IS NOT INITIAL ).
      IF ( ls_keytab-name = 'BookingId' ).
        SELECT * FROM zml_booking INTO CORRESPONDING FIELDS OF TABLE et_entityset WHERE booking_id = ls_keytab-value.
      ELSEIF ( ls_keytab-name = 'TravelId' ).
        DATA: lv_travel_id TYPE zml_travel-travel_id.
        SELECT SINGLE travel_id FROM zml_booking INTO lv_travel_id WHERE travel_id = ls_keytab-value.
        SELECT * FROM zml_booking INTO CORRESPONDING FIELDS OF TABLE et_entityset WHERE travel_id = lv_travel_id.
      ENDIF.
    ELSE.
      SELECT * FROM zml_booking INTO CORRESPONDING FIELDS OF TABLE et_entityset.
    ENDIF.
  ENDMETHOD.

  METHOD zml_itravelset_get_entity.
    DATA:ls_keytab TYPE LINE OF /iwbep/t_mgw_name_value_pair.
    LOOP AT it_key_tab INTO ls_keytab.
    ENDLOOP.
    IF ( ls_keytab-name = 'BookingId' ).
      DATA: lv_travel_id TYPE zml_booking-travel_id.
      SELECT SINGLE travel_id FROM zml_booking INTO lv_travel_id WHERE booking_id = ls_keytab-value.
      IF sy-subrc = 0.
        SELECT SINGLE * FROM zml_travel INTO CORRESPONDING FIELDS OF er_entity WHERE travel_id = lv_travel_id.
      ENDIF.
    ELSEIF ( ls_keytab-name = 'TravelId' ).
      SELECT SINGLE * FROM zml_travel INTO CORRESPONDING FIELDS OF er_entity WHERE travel_id = ls_keytab-value.
    ENDIF.
  ENDMETHOD.

  METHOD zml_ibookingset_get_entity.
    DATA:ls_keytab TYPE LINE OF /iwbep/t_mgw_name_value_pair.
    LOOP AT it_key_tab INTO ls_keytab.
    ENDLOOP.
    IF ( ls_keytab-name = 'BookingId' ).
      SELECT SINGLE * FROM zml_booking INTO CORRESPONDING FIELDS OF er_entity WHERE booking_id = ls_keytab-value.
    ELSEIF ( ls_keytab-name = 'TravelId' ).
      SELECT SINGLE * FROM zml_booking INTO CORRESPONDING FIELDS OF er_entity WHERE travel_id = ls_keytab-value.
    ENDIF.
  ENDMETHOD.

  METHOD zml_itravelset_create_entity.
    DATA: ls_entity TYPE zcl_zml_travelling_odt_mpc=>ts_zml_itravel.
    io_data_provider->read_entry_data( IMPORTING es_data = ls_entity ).
    CLEAR er_entity.
    er_entity = zml_modify_travel( ls_entity = ls_entity ).
  ENDMETHOD.

  method zml_ibookingset_create_entity.
    DATA: ls_entity TYPE zcl_zml_travelling_odt_mpc=>ts_zml_ibooking.
    io_data_provider->read_entry_data( IMPORTING es_data = ls_entity ).
    CLEAR er_entity.
    er_entity = zml_modify_booking( ls_entity = ls_entity ).
  endmethod.

  METHOD zml_itravelset_delete_entity.
    DATA: ls_converted_keys TYPE zcl_zml_travelling_odt_mpc=>ts_zml_itravel.
    io_tech_request_context->get_converted_keys( IMPORTING es_key_values = ls_converted_keys ).
    DELETE FROM zml_booking WHERE travel_id = ls_converted_keys-travel_id.
    DELETE FROM zml_travel WHERE travel_id = ls_converted_keys-travel_id.
  ENDMETHOD.

  method zml_ibookingset_delete_entity.
    DATA: ls_converted_keys TYPE zcl_zml_travelling_odt_mpc=>ts_zml_ibooking.
    io_tech_request_context->get_converted_keys( IMPORTING es_key_values = ls_converted_keys ).
    DELETE FROM zml_booking WHERE booking_id = ls_converted_keys-booking_id.
  endmethod.

  METHOD zml_itravelset_update_entity.
    DATA:
      ls_converted_keys TYPE zcl_zml_travelling_odt_mpc=>ts_zml_itravel,
      ls_entity         TYPE zcl_zml_travelling_odt_mpc=>ts_zml_itravel.
    io_data_provider->read_entry_data( IMPORTING es_data = ls_entity ).
    IF ( ls_entity-travel_id IS INITIAL ).
      io_tech_request_context->get_converted_keys(  IMPORTING es_key_values = ls_converted_keys ).
      ls_entity-travel_id = ls_converted_keys-travel_id.
    ENDIF.
    io_data_provider->read_entry_data( IMPORTING es_data = ls_entity ).
    CLEAR er_entity.
    er_entity = zml_modify_travel( ls_entity = ls_entity ).
  ENDMETHOD.

  method zml_ibookingset_update_entity.
    DATA:
      ls_converted_keys TYPE zcl_zml_travelling_odt_mpc=>ts_zml_ibooking,
      ls_entity         TYPE zcl_zml_travelling_odt_mpc=>ts_zml_ibooking.
    io_data_provider->read_entry_data( IMPORTING es_data = ls_entity ).
    IF ( ls_entity-booking_id IS INITIAL ).
      io_tech_request_context->get_converted_keys(  IMPORTING es_key_values = ls_converted_keys ).
      ls_entity-booking_id = ls_converted_keys-booking_id.
    ENDIF.
    io_data_provider->read_entry_data( IMPORTING es_data = ls_entity ).
    CLEAR er_entity.
    er_entity = zml_modify_booking( ls_entity = ls_entity ).
  endmethod.

  METHOD /iwbep/if_mgw_appl_srv_runtime~create_deep_entity.
    DATA: ls_travel_booking_data TYPE zcl_zml_travelling_odt_mpc_ext=>ty_s_trv_book.
    CLEAR: er_deep_entity.
    TRY.
        CALL METHOD deep_insert_travel_booking
          EXPORTING
            io_data_provider = io_data_provider
          IMPORTING
            es_s_trv_book    = ls_travel_booking_data.
        copy_data_to_ref(
         EXPORTING
           is_data = ls_travel_booking_data
         CHANGING
           cr_data = er_deep_entity ).
      CATCH /iwbep/cx_mgw_busi_exception.
    ENDTRY.
  ENDMETHOD.


  METHOD deep_insert_travel_booking.
    DATA: ls_travel_booking_data TYPE zcl_zml_travelling_odt_mpc_ext=>ty_s_trv_book.
    DATA: ls_entity TYPE zcl_zml_travelling_odt_mpc=>ts_zml_itravel.
    DATA: ls_childentity TYPE zcl_zml_travelling_odt_mpc=>ts_zml_ibooking.
    DATA: ar_childentities TYPE STANDARD TABLE OF zcl_zml_travelling_odt_mpc=>ts_zml_ibooking WITH DEFAULT KEY.
    io_data_provider->read_entry_data( IMPORTING es_data = ls_travel_booking_data ).
    MOVE-CORRESPONDING ls_travel_booking_data TO ls_entity.
    ls_entity = zml_modify_travel( ls_entity = ls_entity ).
    MOVE-CORRESPONDING ls_travel_booking_data-to_booking TO ar_childentities.
    LOOP AT ar_childentities INTO ls_childentity.
      ls_childentity-travel_id = ls_entity-travel_id.
      ls_childentity = zml_modify_booking( ls_entity = ls_childentity ).
      ar_childentities[ sy-index ] = ls_childentity.
    ENDLOOP.
    MOVE-CORRESPONDING ls_entity TO es_s_trv_book.
    MOVE-CORRESPONDING ar_childentities TO es_s_trv_book-to_booking.
  ENDMETHOD.

  METHOD zml_create_uuid.
    DATA lv_long_time_stamp TYPE timestampl.
    GET TIME STAMP FIELD lv_long_time_stamp.
    DATA: l_uuid_x16 TYPE sysuuid_x16.
    DATA: system_uuid TYPE REF TO if_system_uuid.
    DATA: oref        TYPE REF TO cx_uuid_error.
    system_uuid = cl_uuid_factory=>create_system_uuid( ).

    TRY.
        es_uuid = system_uuid->create_uuid_x16( ).
      CATCH cx_uuid_error.
        "handle exception
    ENDTRY.
  ENDMETHOD.

  METHOD zml_modify_travel.
    DATA:
      it_entity TYPE zcl_zml_travelling_odt_mpc=>ts_zml_itravel.
    MOVE-CORRESPONDING ls_entity TO it_entity.
    IF ( it_entity-client IS INITIAL ).
      it_entity-client = sy-mandt.
    ENDIF.
    TRY.
        it_entity-name = ls_entity-name.
        DATA itb_entity TYPE TABLE OF zml_travel.
        IF ( it_entity-travel_id IS INITIAL ).
          it_entity-travel_id = zml_create_uuid( ).
          itb_entity = VALUE #( ( it_entity )  ).
          INSERT zml_travel FROM TABLE @itb_entity.
        ELSE.
          itb_entity = VALUE #( ( it_entity )  ).
          MODIFY zml_travel FROM TABLE @itb_entity.
        ENDIF.
        es_entity = it_entity.
      CATCH cx_uuid_error.
    ENDTRY.
  ENDMETHOD.

  METHOD zml_modify_booking.
    DATA:
    it_entity TYPE zcl_zml_travelling_odt_mpc=>ts_zml_ibooking.
    MOVE-CORRESPONDING ls_entity TO it_entity.
    IF ( ls_entity-client IS INITIAL ).
      it_entity-client = sy-mandt.
    ENDIF.
    IF ( ls_entity-travel_id IS NOT INITIAL ).
      TRY.
          DATA itb_entity TYPE TABLE OF zml_booking.
          IF ( it_entity-booking_id IS INITIAL ).
            it_entity-booking_id = zml_create_uuid( ).
            itb_entity = VALUE #( ( it_entity )  ).
            INSERT zml_booking FROM TABLE @itb_entity.
          ELSE.
            itb_entity = VALUE #( ( it_entity )  ).
            MODIFY zml_booking FROM TABLE @itb_entity.
          ENDIF.
          es_entity = it_entity.
        CATCH cx_uuid_error.
      ENDTRY.
    ENDIF.

  ENDMETHOD.

ENDCLASS.

You can use this example of OData service as start point of developing your own package with own model and own project for OData by SEGW transaction. Now you have clear understanding how it can be implemented and fulfill business requirements, especially when those require none generative approach because particular changes of methods business consider as most effective approach on working production instances.

Thank you for your attention and happy programming,

Yours sincerely,

Mikhail.

PS: if you missed this link: https://github.com/lukcad/ZMLODATA.git

It's never been easier to invoke Machine Learning and Generative AI from an ABAP application

2024-05-03T08:34:43.224000+02:00

We have exciting news for SAP developers! You may remember that last year, IBM and SAP jointly announced a milestone collaboration around embedding AI into SAP solutions. One visible outcome was the adoption of Watson technology in the SAP Start and SAP Joule digital assistants.

And at the same time, IBM's been working on creating a watsonx Software Development toolKit (SDK) for SAP ABAP, complementing the existing Watson SDK that was refreshed in 2023.

I am pleased to confirm that the watsonx ABAP SDK version 1.0.0 is now live. It was released late March 2024 by the IBM SAP Software Engineering Team as expected. It is a separate release from its relative, the Watson SDK, who released a version 2 in Q4 2023. Both SDKs are open source and downloadable from GitHub.

If you develop SAP apps or have clients doing so, this is big news. It is truly a revolution in easily integrating Machine Learning and Generative AI, in just a few clicks, into an SAP ABAP application. Literally in 10 minutes!

The watsonx SDK comes in two flavors, allowing SAP developers to easily access watsonx from an ABAP application in a traditional SAP NetWeaver environment, and also in the latest SAP Business Technology Platform (BTP):

The SDK natively supports both the watsonx.ai (V1) and the Watson Machine Learning (V4). To get developers up to speed quickly, comprehensive examples are included in both of the APIs' documentation.

The sample code for the watsonx.ai sends a AI prompt to a generative AI model and collects the generated response. It uses the granite-13b-chat-v2 in the example but there are many other superb models available through watsonx.
The sample code for the Watson Machine Learning API lets you unleash the full capability of Watson Machine Learning (ML):
- Without going too far in the detail, to use watsonx ML you have to create a watsonx deployment space. This is where you will deploy your ML assets, which can be models, functions, or scripts.
- Python is a popular language for functions, in fact most frameworks in Watson ML rely on Python (or R). With a Python function, you can perform any ML task like creating, training, and using models.
  - For instance you can recognize hand-written digits, or to predict business area for a car rental company, etc.
  - You're welcome to write your own Python functions from scratch but in most cases you'd want to leverage existing example notebooks to save time
- Going back to the watsonx ABAP SDK: in the supplied sample code, the ABAP application deploys arbitrary Python code as a Python function on a watsonx deployment space and calls the deployed function. It also supplies a CURL command that can be used to easily call the deployed function from the command line
- So the SDK connects lets you use the full capabilities of watsonx ML with very little development effort. Then no further SAP programming knowledge is necessary, you can refer to the regular watsonx ML documentation. And of course, reuse the many examples of functions, models, and scripts provided by IBM and third parties.

See also the post by @christian_bartels on the same topic.

How to generate a wrapper for function modules (BAPIs) in tier 2

2024-05-06T16:10:39.975000+02:00

Introduction

In a tutorial Implement a Wrapper for the "Create Purchase Requisition" (BAPI_PR_CREATE) function module that was published recently it was shown how to deal with the case in which no convenient released API is available to create purchase requisitions.

The question that came to my mind was whether there would be a way to automate the steps described in this tutorial so that creating wrappers for other BAPIs would become more easy.

So I did some investigation and have build a prototype of such a wrapper that it based on the same framework as the transaction ACO_PROXY.

This transaction is already available for quite some time and can be used to generate a wrapper class for one or more function modules.

In order to leverage the generated code it would however be necessary to perform several manual steps to adapt the same. Since these steps can be automated I have build a helper class and a helper report that perform these tasks for your convenience.

RFC tier2 proxy generator

The RFC tier2 proxy generator is based on the same API that is used by the transaction ACO_PROXY which is described in the following tutorial. This transaction allows to generate a wrapper class for one or more function modules. The code can however not be used immediately since it contains a few statements that need to be adjusted (e.g. CLASS-METHODS statements and CALL DESTINATION _dest_ statements).

The transaction ACO_PROXY and its underlying API now also check if a data element that is used by a non released function module itself has been released. If this is the case, no shadow type will be generated.

The recommended approach (see the tutorial above) is also to use a C1-released interface and a C1-released wrapper class that intantiates the wrapper class being used in your ABAP Cloud coding.

So I developed a class that calls the same API

cl_aco_static_proxy=>create_static_proxy_by_rfc(
               EXPORTING
                 function_names         = i_function_modules
                 proxy_name             = i_proxy_class_name
                 destination_name       = 'NONE'
                 devclass               = i_package_name
                 trkorr                 = i_transport_request
                 classic_exceptions     = abap_false
                 bapi_exceptions        = abap_false
                 generate_inactive      = abap_false
                 destination_by_constructor = abap_false
                 do_not_create_released_type = abap_true
             ).

and which in addition

creates an interface and a factory class
moves part of the code generated by the API mentioned above to the interface
changes the code of the generated wrapper class to use the interface
C1-release the factory class and the interface

How to get the source code of the RFC tier2 generator

The source code of the RFC tier2 generator has been published in the following repository on Github.com

SAP-samples/tier2-rfc-proxy

Prerequisites

- You have to have a system based on SAP S/4HANA 2022 or 2023 on premise.
- You have to have enabled Developer extensibility
- You have to apply the following notes
- [SAP Note 3444292 - ACO Proxy creates unnecessary shadow types](https://me.sap.com/notes/3444292)
- [SAP Note 3457580 - SAP ACO - Duplicate Types for Table Parameters](https://me.sap.com/notes/3457580)

How to use the RFC tier2 generator

When you have downloaded the class and the report simply start the report zr_gen_rfc_tier2_proxy.

Here you can select one or more function modules that will be wrapped by one single class.

(e.g BAPI_PR_CREATE, BAPI_PR_CHANGE, BAPI_PR_GETDETAIL, ...)

Now you have to specify additional parameters such as the target package where the wrapper objects are going to be generated.

Then there there are two radio buttons that allow you to choose between the generation of an interface, a wrapper class and a factoy class (option 1, recommended) or just one wrapper class (option 2).

As described in the above mentioned tutorial the approach of using an interface and a factory class is the recommended one.

Last not least you have to provide the names of the repository objects that will be generated.

When the reports finishes successfully it will list the generated repository objects.

The objects can then be checked in the target package.

Hope this will help to speed up the process of creating wrappers for non-released function modules.

ToDo's

What is left to do is to change the value help of the report such that only function modules can be selected that are marked as stable.

How to find SAP APIs for SAP S/4HANA 3-tier extens... - SAP Community

SAP/abap-atc-cr-cv-s4hc: ABAP test cockpit cloud readiness check variants for SAP S/4HANA Cloud (github.com)

Future Outlook

In future the idea is to provide such a generator as well in the ABAP development tools for Eclipse.

This will be possible with the next S/4HANA release and the ADT generator framework.

Increase width of Dynpros generated by table maintenance generator

2024-05-08T17:49:34.459000+02:00

If you want to adjust the width for Dynpros generated by the table maintenance generator, follow this guide.

Create a new package for the objects created in this guide (e. g. Z_ADJUST_GEN_DYNPRO_WIDTH)
Right-click on the new package and choose "Create -> Other (1) -> SET/GET Parameter ID" and name it Z_DYNPRO_GEN_WIDTH (or whatever name you choose). This will contain the new width-value for the generated dynpros.
Open include MSVIMF21. This include contains the ABAP coding which generates Dynpros for maintenance views. Show the implicit enhancement options via Edit -> Enhancement Options -> Show Implicit Enhancement Options and click the Enhance button (swirl icon; shortcut is Shift+F4).
Find the end of form CREATE_DYNP_HEADER, click on the enhancement line (""""""...) and create a new enhancement implementation for coding. Insert the coding from code snippet below.
Find the end of form CREATE_DYNP_CONT, click on the enhancement line (""""""""...) and create a new enhancement implementation for coding. Insert the coding from the other code snippet below.
Add parameter Z_DYNPRO_GEN_WIDTH to every user who wants to generate dynpros with the adjusted width and set the parameter value to the new width you desire (200 worked well for me).
Activate both enhancement implementations, if not done

You might want to provide a different source for the dynpro width, e. g. a customizing table or even a fixed value.

Code snippet for CREATE_DYNP_HEADER enhancement:

  DATA lv_dynpro_gen_width(3) TYPE c.

  " By default dynpros are limitted to a width of 83 characters.
  " Modern screens are larger, so we can extend the max. width.
  " The width is determined by user parameter Z_DYNPRO_GEN_WIDTH.
  GET PARAMETER ID 'Z_DYNPRO_GEN_WIDTH' FIELD lv_dynpro_gen_width.

  IF sy-subrc = 0.
    p_header-columns = CONV #( lv_dynpro_gen_width ).
  ENDIF.

Code snippet for CREATE_DYNP_CONT enhancement:

  IF p_mode = '11'.
    READ TABLE p_cont ASSIGNING <w_cont> WITH KEY
     type = rpyty_dynp_ctype-table_control name = cont_name.
    IF sy-subrc <> 0. rc = sy-subrc. EXIT. ENDIF.

    DATA lv_dynpro_gen_width(3) TYPE c.
    " By default dynpros are limitted to a width of 83 characters.
    " Modern screens are larger, so we can extend the max. width.
    " The width is determined by user parameter Z_DYNPRO_GEN_WIDTH.
    GET PARAMETER ID 'Z_DYNPRO_GEN_WIDTH' FIELD lv_dynpro_gen_width.

    IF sy-subrc = 0.
      <w_cont>-length = CONV #( lv_dynpro_gen_width ).
    ENDIF.
  ENDIF.

Enjoy! Feedback is welcome.

How to Bring Generative AI to Your ABAP Program Using the ABAP SDK for IBM watsonx

2024-05-08T17:49:41.177000+02:00

Introduction

IBM watsonx is an all-in-one platform to train, validate, tune and deploy models for generative AI. It comes with a compilation of deployed generative AI models that can be used out-of-the-box. The ABAP SDK for IBM watsonx is a set of ABAP classes and data types that allows generative AI inferencing by pure ABAP means.

It is assumed that you have some basic knowledge in generative AI, in particular prompt engineering. Otherwise get familiar with the most important terms, for example by reading this blog.

Follow the steps in this blog to implement a generative AI test data generator in ABAP. The program will

generate a prompt based on data available in the system
execute that prompt on a model hosted on watsonx.ai
process the generative AI response

Throughout this blog all parts that are related to watsonx are explained in detail. Other parts are only mentioned and not elaborated. However, at the end of this post you find the full code of a working demo program. Use this as a reference.

Create a watsonx Project

If you do not already have an IBM watsonx or an IBM Cloud account, "Start your free trail" on https://www.ibm.com/watsonx and proceed through the onboarding process.

After login to watsonx, you get to the home screen. See the right upper corner for the region where your watsonx instance resides. You need this information later.

Create a new project by clicking the plus sign next to the "Projects" header line.

Enter a name and a description for your project and click "Create".

Inside the watsonx project, click tab "Manage" and copy and save the "Project ID". You will need it later.

You must associate a Watson Machine Learning service to your project. Click on "Service & integration", tab "IBM services". Click "Associate service", check service of type "Watson Machine Learning" and click "Associate"

If there is no service of type "Watson Machine Learning" that can be selected, click "New Service" and instantiate a new Waston Machine Learning service.

Next you must generate an apikey. To do so, click on the navigation menu at the left upper corner and select "Administration" → "Access (IAM)". Select "API keys" and click "Create". Enter a name and a description and click "Create". An apikey is created and shown to you. Copy and save the apikey; you will not be able to see it again.

You need to identify the URL to the watsonx API. It complies to scheme
https://<region code>.ml.cloud.ibm.com
where <region code> is the region code of the region where your watsonx instance resides (see above). For exmaple eu-de for Europe (Frankfurt) or us-south for Dallas.

Finally, you have the credentials that are needed to access watsonx. (Certainly, the values below are invalid and for demonstration only.)

url: https://eu-de.ml.cloud.ibm.com
apikey: t8a0OQpVgs6z9jZNKGt9Ghk498f0biyZvRf-E4eqw11K
project_id: e8db8f7c-36f6-40ca-804a-238c6e557c46

Prepare the ABAP Environment

You must import the ABAP SDK for IBM watsonx using abapGIT pull. If your runtime environment is NetWeaver 7.50 (or above) or S/4HANA on premise, follow instructions on https://github.com/IBM/abap-sdk-nwas-x. For the BTP ABAP Environment, follow instructions on https://github.com/IBM/abap-sdk-btp-x.

For this tutorial a set of tables with some contents is required. If such tables are not available or not known to you, import the ABAP Flight Reference Scenario to your environment and generate the demo data.

Select or create a database table that you want to populate with generative AI data. For example, create package ZWATSONX under structure package ZLOCAL and create table ZIBM_CUSTOMER in that package. This table can be a copy of table /DMO/CUSTOMER. Thus, the database table definition may look like below.

@EndUserText.label : 'Copy of table /DMO/CUSTOMER'
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #A
@AbapCatalog.dataMaintenance : #RESTRICTED
define table zibm_customer {

  key client      : abap.clnt not null;
  key customer_id : /dmo/customer_id not null;
  first_name      : /dmo/first_name;
  last_name       : /dmo/last_name;
  title           : /dmo/title;
  street          : /dmo/street;
  postal_code     : /dmo/postal_code;
  city            : /dmo/city;
  country_code    : land1;
  phone_number    : /dmo/phone_number;
  email_address   : /dmo/email_address;

}

Prompt Generation

You must build a prompt that instructs the generative AI model to generate test data. This works best if you use few-shot prompting, which means to include some examples in the prompt. For the sake of convenience and flexibility, do not hard-code those examples. Instead, implement some ABAP code that reads a small portion of the contents and the data dictionary information of some given tables and generates examples for the prompt. A single example can be added to the prompt using this format:

[example]
records: n
format: <table field names and types>
data: <n table records in JSON format>
[end]

The complete prompt looks like this:

Generate data in JSON format as shown in examples below. Insert tag [end] after given number of records.
[example]
<example data generated from table #1>
[end]
[example]
<example data generated from table #2>
[end]
[example]
<example data generated from table #3>
[end]
[input]
records: n
format: <table field names and type of target table ZIBM_CUSTOMER>
data:

The tables that are used to generate the examples should in total include all data types that appear in the target table. They should be client-dependent if (and only if) that target table is client-dependent.

Calling watsonx Generative AI

After the prompt has been generated, you can call watsonx to execute the prompt and thus generate test data. First you must provide watsonx.ai credentials. You can either specify those in your ABAP code or, recommended, configure table ZIBMX_CONFIG accordingly.

CONSTANTS c_url        TYPE string VALUE 'https://eu-de.ml.cloud.ibm.com'.
CONSTANTS c_apikey     TYPE string VALUE 't8a0OQpVgs6z9jZNKGt9Ghk498f0biyZvRf-E4eqw11K'.
CONSTANTS c_project_id TYPE string VALUE 'e8db8f7c-36f6-40ca-804a-238c6e557c46'.

Next instantiate the wrapper class for watsonx.ai.

DATA: lo_watsonx_ai TYPE REF TO zcl_ibmx_watsonx_ai_ml_v1.
zcl_ibmx_service_ext=>get_instance(
    EXPORTING
        i_url     = c_url
        i_apikey  = c_apikey
        i_version = '2023-05-29'
    IMPORTING
        eo_instance = lo_watsonx_ai ).

Now you can call method text_generation. It calls watsonx and returns the generative AI inference result.

As parameters, you must specify the prompt that has been generated before, the model id and a set of model parameters like decoding method and the maximal number of generated tokens. watsonx supports several generative AI models, for example IBM's Granite models.

Also, you must provide the id of the watsonx project that you have created before.

TRY.
    lo_watsonx_ai->text_generation(
      EXPORTING
        i_textgenrequest = VALUE zcl_ibmx_watsonx_ai_ml_v1=>t_text_gen_request(

          " prompt
          input = <prompt>

          " model parameters
          model_id   = 'ibm/granite-13b-chat-v2'
          parameters = VALUE zcl_ibmx_watsonx_ai_ml_v1=>t_text_gen_parameters(
            decoding_method    = 'greedy'
            max_new_tokens     = 2000
            repetition_penalty = '1.05'
            stop_sequences = VALUE #( ( `[end]` ) )  " stop at [end] tag
          )

          " watsonx project id
          project_id = c_project_id
        )
      IMPORTING
        e_response = DATA(ls_generated_document) ).
  CATCH zcx_ibmx_service_exception INTO DATA(lo_service_exception).
    " handle exception
ENDTRY.

The inference result is returned in an internal table that contains a single record which holds the generated data in JSON format as indicated in the prompt. Insert the data into the target database table using a JSON parser.

DATA lr_data TYPE REF TO data.
CREATE DATA lr_data TYPE TABLE OF ZIBM_CUSTOMER.
/ui2/cl_json=>deserialize( 
  EXPORTING 
    json = ls_generated_document-results[ 1 ]-generated_text
  CHANGING 
    data = lr_data->*  ).
INSERT ZIBM_CUSTOMER FROM TABLE _data->*.

Run the Application

Now you are ready to run your ABAP code. After the program has finished, check the data in your table.

CLIENT    CUSTOMER_ID    FIRST_NAME    LAST_NAME    TITLE    STREET             POSTAL_CODE    CITY          COUNTRY_CODE    PHONE_NUMBER        EMAIL_ADDRESS        
100       001001         John          Doe          Mr.      34 South Road      12345          Anytown       US              +1 212-555-1212     johndoe@email.com    
100       001002         Jane          Smith        Ms.      43 East Street     67890          Emeryville    US              +1 415-555-1234     janesmith@email.com  
100       001003         Jim           Johnson      Dr.      56 North Avenue    55111          Seattle       US              +1 206-555-5678     jimjohnson@email.com 
100       001004         Anna          Miller       Mrs.     71 West Lane       33333          London        GB              +44 20-7654-5309    annamiller@email.com 
100       001005         Bob           Williams     Mr.      89 Maple Street    12345          Toronto       CA              +1 416-555-1111     bobwilliams@email.com

Conclusion

You learnt how to generate a prompt, execute that prompt on a generative AI model deployed on watsonx and process the response. All this is done with ABAP code only while the complexity of the API calls is hidden by the ABAP SDK for IBM watsonx.

The same technique can be used to include generative AI in any business process that is implemented in ABAP.

Addendum

Here is the full code of a demo program. It was implemented on BTP ABAP Environment and runs as a console application. To run it on a NetWeaver system or on S/4HANA on premise, remove or replace all references to interface if_oo_adt_classrun, including the out->write statements. In all cases you have to adjust watsonx credentials before running the application.

CLASS zwatsonx_genai_data_generator DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun .
  PROTECTED SECTION.
  PRIVATE SECTION.
    METHODS field_data
      IMPORTING
        i_tabname     TYPE string
      RETURNING
        VALUE(e_text) TYPE string.
    METHODS content_data
      IMPORTING
        i_tabname     TYPE string
        i_count       TYPE i
      RETURNING
        VALUE(e_text) TYPE string.
    METHODS prompt_section
      IMPORTING
        i_kind        TYPE string
        i_tabname     TYPE string
        i_count       TYPE i
      RETURNING
        VALUE(e_text) TYPE string.
    METHODS insert_json
      IMPORTING
        i_json         TYPE string
        i_tabname      TYPE string
      RAISING
        cx_sy_open_sql_db.
ENDCLASS.



CLASS zwatsonx_genai_data_generator IMPLEMENTATION.

  METHOD if_oo_adt_classrun~main.

    CONSTANTS c_url        TYPE string VALUE 'https://eu-de.ml.cloud.ibm.com'.                " <-- ADJUST
    CONSTANTS c_apikey     TYPE string VALUE 't8a0OQpVgs6z9jZNKGt9Ghk498f0biyZvRf-E4eqw11K'.  " <-- ADJUST
    CONSTANTS c_project_id TYPE string VALUE 'e8db8f7c-36f6-40ca-804a-238c6e557c46'.          " <-- ADJUST
    CONSTANTS c_tabname    TYPE string VALUE 'ZIBM_CUSTOMER'.
    CONSTANTS c_count      TYPE i VALUE 5.

    " compile prompt (featuring 3-shot prompting)
    DATA(lv_prompt) =
      " instruction
      `Generate data in JSON format as shown in examples below. Insert tag [end] after given number of records.` && cl_abap_char_utilities=>newline &&
      " examples
      prompt_section( i_kind = 'example' i_tabname = '/DMO/AGENCY' i_count = 2 ) &&
      prompt_section( i_kind = 'example' i_tabname = '/DMO/AIRPORT' i_count = 4 ) &&
      prompt_section( i_kind = 'example' i_tabname = '/DMO/FLIGHT' i_count = 3 ) &&
      " input
      prompt_section( i_kind = 'input' i_tabname = c_tabname i_count = c_count ).

    " instantiate wrapper class for watsonx.ai API
    DATA: lo_watsonx_ai TYPE REF TO zcl_ibmx_watsonx_ai_ml_v1.
    zcl_ibmx_service_ext=>get_instance(
        EXPORTING
          i_url     = c_url
          i_apikey  = c_apikey
          i_version = '2023-05-29'
        IMPORTING
          eo_instance = lo_watsonx_ai ).

    " run text generation
    TRY.
        lo_watsonx_ai->text_generation(
          EXPORTING
            i_textgenrequest = VALUE zcl_ibmx_watsonx_ai_ml_v1=>t_text_gen_request(

              " prompt
              input = lv_prompt

              " model parameters
              model_id   = 'ibm/granite-13b-chat-v2'
              parameters = VALUE zcl_ibmx_watsonx_ai_ml_v1=>t_text_gen_parameters(
                decoding_method    = 'greedy'
                max_new_tokens     = 2000
                repetition_penalty = '1.05'
                stop_sequences = VALUE #( ( `[end]` ) )  " stop at [end] tag
              )

              " watsonx project id
              project_id = c_project_id
            )
          IMPORTING
            e_response = DATA(ls_generated_document) ).
      CATCH zcx_ibmx_service_exception INTO DATA(lo_service_exception).
        out->write( `ERROR when generating text: ` && lo_service_exception->get_longtext(  ) ). EXIT.
    ENDTRY.

    " collect generated texts (single record in ls_generated_document-results is expected)
    DATA(lv_json) = ``.
    LOOP AT ls_generated_document-results INTO DATA(ls_result).
      lv_json = lv_json && ls_result-generated_text.
    ENDLOOP.

    " if LLM has generated [end] tag, remove it
    REPLACE ALL OCCURRENCES OF '[end]' IN lv_json WITH ''.

    " insert JSON data into table
    TRY.
        insert_json( i_json = lv_json i_tabname = c_tabname ).
      CATCH cx_sy_open_sql_db INTO DATA(lo_osql_exception).
        out->write( `ERROR when inserting data: ` && lo_osql_exception->get_longtext(  ) ). EXIT.
    ENDTRY.

    " success message
    out->write( `Data in table ` && c_tabname && ` that has been generated by watsonx generative AI: ` ).
    DATA lr_data TYPE REF TO data.
    CREATE DATA lr_data TYPE TABLE OF (c_tabname).
    SELECT * FROM (c_tabname) INTO TABLE _data->*.
    out->write( lr_data->* ).

  ENDMETHOD.


  METHOD field_data.
    " generates field type information
    " example: table has CHAR field of length 8, INT field and STRING field
    "   e_text = FIELDNAME1,C(8) | FIELDNAME2,I | FIELDNAME3,g |
    DATA ref_descr TYPE REF TO cl_abap_structdescr.
    DATA lt_comp   TYPE abap_compdescr_tab.

    " initialize return value
    e_text = ``.

    " get field type information
    ref_descr ?= cl_abap_typedescr=>describe_by_name( i_tabname ).
    lt_comp[] = ref_descr->components[].

    " compile fields type list
    LOOP AT lt_comp INTO DATA(ls_comp).

      " get type length info
      DATA(lv_length) = ``.
      CASE ls_comp-type_kind.
        WHEN 'C' OR 'N'.
          lv_length = condense( CONV string( ls_comp-length DIV 2 ) ).   " UTF-16 length to number of chars
        WHEN 'P'.
          lv_length = condense( CONV string( ls_comp-length ) ) && `,` && condense( CONV string( ls_comp-decimals ) ).
      ENDCASE.
      IF NOT lv_length EQ ''. lv_length = `(` && lv_length && `)`. ENDIF.

      " add field data to return value
      e_text = e_text && ls_comp-name && `,` && ls_comp-type_kind && lv_length && ` | `.
    ENDLOOP.
  ENDMETHOD.


  METHOD content_data.
    " returns first rows of a table in JSON notation
    DATA lr_data TYPE REF TO data.

    e_text = `[`.
    DATA(lv_separator) = ``.

    " read table content
    CREATE DATA lr_data TYPE TABLE OF (i_tabname).
    SELECT *
      FROM (i_tabname)
      INTO TABLE _data->*
      UP TO @i_count ROWS.

    " serialize record-wise and add newlines
    LOOP AT lr_data->* ASSIGNING FIELD-SYMBOL(<ls_reocord>).
      e_text = e_text && lv_separator && /ui2/cl_json=>serialize( data = <ls_reocord> ).
      lv_separator = `,` && cl_abap_char_utilities=>newline.
    ENDLOOP.
    e_text = e_text && `]`.
  ENDMETHOD.


  METHOD prompt_section.
    " returns example table data to be added to prompt, i.e.
    " [example]
    " records: 2
    " format: PET,C(8) | AGE,I | COMMENT,g |
    " data:
    " [{"PET": "cat", "AGE": 4, "COMMENT": "my pet"},
    " {"PET": "dog", "AGE": 3, "COMMENT": "your pet"}]
    " [end]
    e_text =
      `[` && i_kind && `]` && cl_abap_char_utilities=>newline &&
      `records: ` && condense( CONV string( i_count ) ) && cl_abap_char_utilities=>newline &&
      `format: ` && field_data( i_tabname = i_tabname ) && cl_abap_char_utilities=>newline &&
      `data:` && cl_abap_char_utilities=>newline.
    IF i_kind EQ 'example'.
      e_text = e_text && content_data( i_tabname = i_tabname  i_count = i_count ) && cl_abap_char_utilities=>newline &&
        `[end]` && cl_abap_char_utilities=>newline && cl_abap_char_utilities=>newline.
    ENDIF.
  ENDMETHOD.


  METHOD insert_json.
    " inserts JSON data into database table
    DATA lr_data TYPE REF TO data.
    CREATE DATA lr_data TYPE TABLE OF (i_tabname).

    /ui2/cl_json=>deserialize( EXPORTING json = i_json CHANGING data = lr_data->*  ).

    DELETE from (i_tabname).
    INSERT (i_tabname) FROM TABLE _data->*.
    COMMIT WORK.

  ENDMETHOD.

ENDCLASS.

SAP EWM. Displacement from picking to storage area. Idea & step-by-step implementation (with ABAP).

2024-05-09T23:04:45.225000+02:00

SAP EWM. Displacement from picking to storage area. Idea & Step-by-step implementation.

This blog-post written in collaboration with ABAP-developer Victor Pupynin

Intro.

Typical warehouse layout contains next functional areas:

Loading and unloading area
Goods reception area or warehouse entrance area
Repackaging area
Warehouse quarantine area
Sample selection area
Storage area
Picking area
Order preparation area
Warehouse technical area
Warehouse administrative area

Problem solved in this blog-post related to Storage area and Picking and order preparation areas.

So let's do a closer look to activity in it.

Look at collage photo. This is typical warehouse landscape.

Level 1 - Picking area

Level 2 and higher - Storage area

also in the foreground - Order preparation area

Typical business scenario:

ERP-operator create in ECC(or S/4HANA) and distribute to EWM Outbound delivery
EWM-operator:

2.1. Create wave

2.2. Assign 1..N outbound deliveries to created wave

2.3. Release wave

2.4. SAP EWM creates WO/WT according to standard and customer-specific logic

2.5. One possible scenario:

if WT quantity > quantity in pallet at storage area: route for pallet is: Storage Area -> Console -> Order preparation area

If WT quantity < quantity in pallet at storage area. Route for pallet is: Storage area - > Picking Area - > partial aggregation through source pallet to target pallet - > Order preparation area

3.Work in the aisles looks as:

For upper tiers:

High Reach Forklift (Turret Trucks) Something like: Yale MTC10-15L, Hyster C1.0–1.5 or Jungheinrich ETR 230

Remove the pallet from the upper tiers (Storage area) and put it on the lower tier (Picking area) or Console

4.Work at the Console looks as:

Forklift something like Jungheinrich EFG 213

Remove the pallet from Console and put it on the Picking area

Work at the lower tier looks as:

Workers with trolley "Rocla" carry out the picking process in Picking area. They are partial repack stock from source pallet to target pallet and move target pallet to order preparation area

Hydraulic "Rocla" trolley Authors photos.

Business problem.

Possible problem on Step 2.3.

For a lot of reasons situation when all storage bins at a picking area are full can be occurred.

At this case:

Wave Release status - (E) Error

EWM-operator at warehouse wind-up face-to-face with not easy to understand wave release log.

Resolution

Create automatic displacement from picking to storage area manually and during wave release.

Possible sequence (manually via custom report) :

Step 0. Auxiliary table.

ZLGTYP_ROLE - Lgtyp Role (Storage, Transit, Picking, etc).

LGTYP_PICK - Relation between storage and picking area.

Step 1. Selection screen

Options:

Range of Outbound deliveries.

Range of Waves.

Range of planed GI dates.

Ideas for Screen implementation - selection_screen_1.abap

main.abap

selection.abap

Step 2. Logic for Scenario when all fields on selection screen on Step 1 were empty.

Select all Outbound deliveries without GI from the period from STVARV variable.

Ideas for selection from STVARV variable - stvarv.abap

Step 3. Get items Outbound deliveries according to the criteria defined in the Steps 1,2

Idea for Get Outbound deliveries according Range of Waves - get_wave.abap

Ideas how Get items from Outbound deliveries according Range of Outbound deliveries - get_delivery_item.abap

Step 4. Divide items from Outbound deliveries from Step 3 into 2 Lists

List 1. Item with batch.

List 2. Items without batch.

Idea for Divide implementation - divide_into_2_lists.abap

Step 5. Get available stock for items from Outbound deliveries reсeived on Step 4

Idea for implementation -

get_stock_for_wt.abap

get_available_stock.abap

Step 6. Remove bins with open warehouse tasks or under inventory from List received on Step 5

Idea for implementation -

get_stock_for_wt.abap

get_stock_for_wt_class.abap

Step 7. Get bins in picking area for displacement.

Idea for implementation - Displacement/get_displacement_bins.abap

Step 8. Create warehouse tasks for displacement for Stock/bins received on Steps 7 and 8

Idea for implementation - create_tasks.abap

Testing.

Prerequisite: Outbound delivery crated and integrated from S/4HANA to EWM.

Transaction /SCWM/WAVE

Assign Outbound Delivery (Warehouse Requests)

Available Stock. HU located at the storage area.

Storage Bin at Aisle 01

No Empty (or not blocked) storage bins. Displacement inevitably.

Deplanement in action.

Conclusion.

Approach for displacement from picking to storage area was provided.

SAP Community - ABAP Development

Dynamic BDC in Table Control

Introduction

Implementation

Conclusion

A journey of discovery and a prime example for utilizing dynamic logpoints

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

Background: the System Workload App

Default Configuration: Capture Workload Statistics with Static Thresholds

Default Configuration: Capture Workload Statistics Dynamically

Capture Your Own Workload Statistics in the Capture Request Statistics App

Getting Notified About Specific Workloads

Summary

SAP Developer News, April 18th, 2024

Debugging transaction MD04 in SAP S/4HANA

Analyze Expensive ABAP Workload in the Cloud with Work Process Sampling

Sampled Work Process Data App vs. Other Tools

Get an Overview of the ABAP CPU Time Consumption

Analyze Concurrent Workload and Resource Consumption

Reveal the Root Cause of Performance Problems

Verify the Impact of Performance Improvements

Conclusion

New way to maintain settings in ABAP

After installation navigate to screen #2

ABAP Cloud Developer Trial 2022 Available Now

ABAP License

Update, 23rd April, 2024: 2022 as a Cloud Appliance (CAL)

Highlights of the 2022 Edition

ABAP Cloud Development: Developer Extensibility Scenario

ABAP RESTful Application Programming Model (RAP) - 2022

Git-Enabled Change and Transport System (gCTS)

abapGit

Custom Code Migration with the ABAP Test Cockpit (ATC)

SAP Cloud Connector

Other Highlights of ABAP Platform 2022: Overview

Guides, Tutorials, FAQ, Troubleshooting

App to automatically configure a new ABAP Developer System

TL:DR

Background

Enter

How To Use abapDevSysInit

Installing:

Configuring:

Running:

Addendum: My Setup

How to improve the ADT Class Runner with additional Features

What is a Class Runner?

What can be improved?

How does it look like?

Methods write() and out->write()

Uncaught exceptions

How does it look under the hood?

Summary

Customer & Partner Roundtable for SAP BTP ABAP Environment #12

👉 The call for contributions for one of the upcoming roundtables is open!

Introduction

Meeting Information

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

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

Custom Code Transformation Using abapGit

Evaluation of On-Premise code for Compatibility

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

On-Premise

As an Eclipse Plugin

Transform code form on-premise to cloud

Get started with SAP BTP ABAP Environment: Trial Account vs. Free Tier Option

Trial Account

Free Tier Option

Selecting the appropriate choice

Category

Trial Account

Free Tier Option

The 2024 Developer Insights Survey: The Report

Part I: Introduction and General Information​

Key Findings from the 2024 Survey​

General Topics​

Employment Status and Relation to SAP​

SAP Developer Community Age Distribution

​

Part II. Narrowing the Response Set​

Part I: Introduction and General Information

Key Findings from the 2024 Survey

General Topics

Employment Status and Relation to SAP

Part II. Narrowing the Response Set

Where are the Developers?

Development Job Roles

Development Domains

Recent SAP Project Experience?

Popular Programming Languages

Popular Programming Frameworks

Application and Business Technology Platform Architectures

Popular IDEs

Potential / Use of Generative AI for Developers

Use of Select SAP Technologies

Developer Satisfaction with SAP

BTP Developers Guide

Cloud Insights

Low / No Code Tools

Learning and Help Resources

Satisfaction with SAP Learning Hub

Survey Methodology

Other References