The amount of memory an ABAP program consumes depends on the amount of data being processed, which is typically stored in some type of in-memory structure (such as internal tables) that grows dynamically to accommodate the stored data. If the amount of stored data to be loaded into system memory exceeds the size of available storage area, the program terminates, possibly with the runtime errors such as SYSTEM_NO_ROLL or TSV_TNEW_PAGE_ALLOC_FAILED.

  Because these errors can arise for a variety of reasons, the root cause may not be immediately obvious .For example, the runtime error TSV_TNEW_PAGE_ALLOC_FAILED occurs when the system can’t increase the size of an internal table due to insufficient available memory. However, this internal table might not be the reason why memory is exhausted. What you need in this situation is a tool to help you determine the real reason that the application has run out of memory.

The ABAP Memory Inspector provides you with an overview of dynamically allocated data (that is, all dynamic in-memory structures) at a particular time, which can be very helpful for diagnosing memory consumption problems, as well as a specialized transaction for analyzing this data.

Using the ABAP Memory Inspector

Analyzing the memory consumption of an application typically consists of two types of scenarios:

• You’re interested in the current memory consumption of a running program in order to check if it is unexpectedly high.

• Youwant to compare the memory consumption of a program at different times in order to find out if it increases in an undesirable way and to identify which memory objects contribute to the increase.

Creating the Memory snapshots

There are several ways to create a memory snapshot:

• When debugging an application, select Development->Memory analysis->Create Memory snapshots from the ABAP debugger menu bar .A completion message indicates when the file is ready.
• Enter the command /hmusa in the command field on any SAPGUI screen –you don’t need to be in the debugger .When the file is ready, you will see the same completion message shown for the previous option.

Analyzing and Comparing Memory Snapshots

The ABAP Memory Inspector provides a dedicated transaction for displaying the content of stored memory snapshots.

You start this transaction via S_MEMORY_INSPECTOR, or Memory analysis ->Compare Memory snapshots from the menu bar.

For Example:

Lets say you want to analyze the memory consumption of some program (demo program : ZTEST_MEMORY)

Run the report ZTEST_INDEX

You will get the output as below.

Now enter /hmusa in the command field.

Message will be displayed at the bottom indicating that memory snapshot is created.

To the view the memory snapshot go to the transaction S_MEMORY_INSPECTOR.

Double-click on an entry in the list to open a screenshot and display its contents in the lower part of the screen. You can have up to two snapshots open at one time. Opening a third snapshot automatically closes one of the others based on the difference in creation time. The first opened snapshot is referred to as (t_0);second as (t_1) .To select an open snapshot for display ,use the (t_0) and (t_1) buttons in the application at the top of the screen, or use the Memory Snapshot dropdown list located above the display tree in the lower part of screen.

The IDOc WPUWBW for goodsmovement, has a Basic Type WPUWBW01 which has some segments:

As you can notice in the image, the IDOc has three segments:

• E1WPG01: Header segment which will have the information of the transaction (IT_TRANSACTION information)
• E1WPG02: Item segment which will have the information of Goodsmovement (TRANSACTION-GOODSMOVEMENT)
• E1WXX01: This segment is used to map some extra information (customer enhanmecent).

In my POSDM system, the information of GOODSMOVEMENT is not mapped so I have to map them with the information of RETAILLINEITEM. For this purpose I need to implement the /POSDW/TASK badi, and in the CALL method of my implementation, I receive these parameters:

Furthermore, in this method I call the FM  /POSDW/IDOC_OUTPUT_WPUWBW, which creates the IDOc.

At this point, the IDOc will be generated and for each transaction we will be able to see two segments (one E1WPG01 header and one or more E1WPG02 segments with goodsmovement information) in the IDoc. If you need to add some enhancement data to the IDoc, you will need to map the GOODSMOVEMENT-EXTENSIONS table in the CALL method that I showed before. This table has three main fields:

And the E1WXX01 segment has the same fields but with other names:

For each EXTENSIONS entry that you map in the CALL method there will be a E1WXX01 segment in the IDoc.

For example: I have mapped one EXTENSIONS entry in the GOODSMOVEMENT-EXTENSIONS table:

The result of my IDoc is:

In addition, if you need to do some extra modifications on the IDoc information, you can implement the /POSDW/IDOCOUTPUT badi to modify EDIDC  or EDIDD data. The CALL method of this badi receives as parameters the CT_EDDID table which contains all segments that have been created for all transactions.

Hi SCN community,

This blog post is a logical follow-up from this blog post of mine, where I share my design for a region specific implementation framework using ABAP OO and the factory pattern strategy design (what a fancy name!). From the discussion that followed the idea came up to try and make use of the BAdI technology available in SAP, and this is my proposal for a design using this technology!

This proposal is based in a lot of other blog posts, like this one by Andrea Olivieri, this one by Thomas Weiss, and many others. Check my bookmarks, I usually bookmark interesting stuff. These blogs show a more or less static view over BAdIs. What I found out while designing and implementing this approach, is that actually the BAdI technology is amazingly flexible and powerful. Hopefully you'll share my point of view after reading this post.

Thanks to Debopriyo Mallick and Suhas Saha and their valuable contributions in the comments I have revised my design and, consequently, this blog post. I believe the design is now one step closer to that "idyllic", probably non-existent, perfect solution. By the way, if you're looking for an interesting way to activate/deactivate several BAdI implementations at once on different levels you should check this blog post that Suhas shared in the comments.

The premise

The premise remains pretty much the same as before, so I'm not going to go into it again in great detail. If you're working in a system shared internationally, or by different regions, eventually you'll get user-exits with so many IF and CASE statements, and shared by so many developers, that you will definitely want to have a framework put in place to cope with the specific requirements for each region/country/sales organization/whatever.

In my previous blog, the solution presented doesn't have any flaws "per se" (not that I can think of), but it does represent a very strict and formal solution. If you want more flexibility and freedom, while retaining the same advantages, I think this BAdI design might be the way to go. It also doesn't feel like you're redesigning the wheel

Let's get to it! I'm going to showcase this design with the user-exit INCLUDE MV45AFZZ. Anyone that has ever developed anything for SD should probably know this user-exit, so I think it's the perfect candidate.

Oh, by the way, this is NOT meant to teach you how to create a BAdI. If you are unfamiliar with BAdIs, please take a look into the blog posts I mentioned above.

Let's go!

We start by creating the BAdI definition. The multiple use definition is arguable. For this example I will leave it on, and I guess this would be pretty much standard unless you want to make sure that ONLY ONE implementation of the BAdI is executed. You should keep in mind that when using this option you cannot have parameters defined as exporting/returning, as this would be against the idea behind it. Read in the comments for a more detailed explanation, or press F1 on it . Developers implementing this (and any multiple use) BAdI should pay attention to the fact that other implementations could also be executed and affect variables they are trying to determine, so proper documentation and descriptions of the BAdIs is not a bad idea. Also, in my first version of this blog post, I had defined one BAdI for the entire MV45AFZZ include, with one method per routine. After Debopriyo pointed out, and rightfully so, that this would mean many unimplemented methods in the BAdI implementations, I decided to revise this and have one BAdI definition per routine. I agree this makes more sense.

Figure 1 - BAdI definition

Now, in my situation, we have different clients per region, so a filter that will come very handy for sure will be the client filter. So I set it up straigh from the start.

Figure 2 - BAdI filter definition

In the discussion in the comments it was also pointed out that a BAdI with many parameters in the interface was a BAdI poorly designed, and this could be a problem in user-exits from include MV45AFZZ, since there is no formally defined interface. To "solve" this problem, I thought of defining one structure for the BAdI's interface, like this.

Figure 3 - Defining a structure to use in the BAdI's interface

In this case I've already defined internal item table XVBAP, but if you don't think you're going to need anything special for now, you can just declare some dummy field, or don't create this structure at all and create it only when you need it. It will not cause you any pain afterwards, even if you already have BAdI implementations created, as they will simply not use the newly created parameters. So, after revising the design thanks to the discussion in the comments, the BAdI interface now has only one method (in this example I'm showing the method for userexit_move_field_to_vbak).

Figure 4 - BAdI method definition

And that's it for the BAdI definition (for now)! It wasn't that difficult. Now all you have to do is call it from your routine.

Figure 5 - Calling the BAdI from your user-exit

Ok so now we implement it! For this implementation, the requirement is specific to client 077. Couldn't be easier.

Figure 6 - Implementing a BAdI with a filter value

The rest of it is standard, yes? All you have to do is implement the method with the requirement you want. Personally I think the best would be one implementation per requirement. Major advantage is total independence per requirement. You can have one developer per requirement working at the same time on as many requirements as you'd like, no problems with object locking. The disadvantage could be low-awareness between developments. Meaning that a developer implementing a new requirement should take a look at already existing implementations to check if there's not going to be some conflicting implementations (like a field being overwritten or something).

Now comes the really interesting part for me. What if a new requirement comes along which needs a new parameter? At first glance I would think this would mean a lot of trouble. Going through every implementation and adjusting. Well, not really... or at least I could do it without much trouble (but I guess you'd better not change the parameters already existing, just add new ones)! You change the structure we created earlier and add your new parameters:

Figure 7 - Adjusting the BAdI's interface

Now we need to populate this variable in the code and that's it. The interface will update every implementations method signature, and if the parameters aren't used... well... they're not used, no problems there.

Figure 8 - Adjusted BAdI call

You can now implement your second requirement easily. So, we now have implemented two BAdIs, filtered to be executed only for client 077. What if now we get a third requirement, which is to be executed globally? A core requirement? It also couldn't be easier, we implement a filterless BAdI!

Figure 9 - Implementing a filterless BAdI

The rest you already know. What happens in runtime? In runtime, regardless of which client you are on, the filterless BAdI is executed, and if you happen to be in client 077, the previous BAdIs get executed as well. As you should already know, there is no guarantee to which BAdI runs first, so make sure one implementation does not rely on a result from another implementation, and also try not to change the same fields, because only one value will prevail, and you have no idea which one. It means you can't implement some default values for the "core" implementation and hope that the specific implementations will prevail, you have to implement this accordingly.

Ok, last but not least, let's say that even if we have successfully separated implementations per client, we're still getting many conflicts. We want a new filter, per sales organization. That's also not a problem, we change the BAdI's definition! This is mostly valid if you are implementing multiple requirements in the same BAdI implementation, but I'll keep this here for educational purposes.

Figure 10 - Adding a filter to the BAdI's definition

The existing implementations will not care! They will keep being executed as long as the values for their filters match. How cool is that? But of course, you will have to adjust the BAdI's call, otherwise you'll get a nasty runtime error!

Figure 11 - Adjusting the BAdI's instantiation for the new filter

Done properly, this will allow you to have a nice overview of your enhancements and requirements implemented in your system. You can also use the search feature in the enhancement spot implementation "implemented BAdIs" tab to search for filter value! Which is nice.

Figure 12 - Enhancements overview

Figure 13 - Checking BAdI implementations for a certain filter value combination

Conclusions

That's it from me! I'll admit, I think this approach is very elegant and powerful. Some care must be taken to make sure there are no conflicting implementations, but I don't think there's any way you can avoid that risk.

Let me know what you think and what you would do differently!

All my best,

Bruno

Recently, have come across a requirement to send output of report developed based on SALV as an excel attachment. To achieve the same we can use the method TO_XML of class CL_SALV_TABLE. This method will have the formatted output content as XSTRING value.

Here are the steps.

a. Variable Declaration.

b.Data Selection/ALV Customizing calls.

c.Call to Convert ALV Output as internal XML Format.

d.E-Mail Data Declaration.

e.EMail - Content Conversion/Body/Attachment Creation

Send E-Mail

Excel Output

we can also use TO_XML method to download the content as an XLS or XML documents  in Abap Web dynpro based applications .

Here is the sample source code for this approach.

Hi all,

I just thought making a new blog about some good behavior when getting a ABAP-developer.

Ok, most of the points hit all developers, I think.

First I thought, maybe this is a blog for all the freshers out there, but when I was collecting the facts and what I think, everybody should do, I recognized, that I work through a lot of coding and it is more than just the new developers, which need to know that (again). No, I’m not saying, they don’t do so, but I think, some maybe have to get the focus on such points again, so that they (includes me, of course) remember the facts.

Ok, let us have a look at the list.

Of course, everybody is invited to add additional points in the comments. A very cool thing would be, if we get a document in the end. I searched SCN, but all I found, was a lot of good content, but not a big guide or wiki.

1^st of all, know your guidelines!

Make yourself familiar with the programming guidelines given you by your customer or company. Don’t mess up with the guidelines. I f there are rules in, follow them. It’s not up to you to change the rules. If there might be a mistake, and yes, there might be some, report them to the person, which is responsible for that. I’m sure, the person will give a hand and explain or change the rule.

The 2^nd point is, introduce yourself to the consultants.

Make sure, you and the guys given you input talk on a same level. You can easily achive that, by repeating his concept in your own words and send it to the consultant. It confuses me everytime I see people developing things, which are not that, what the other side imagine. Make sure, that not you are the wrong guy in the chain!

The 3^rd point: Be a smart developer and do not start coding as the world collides tomorrow.

Most of our developing will run for more than just a few months. Make sure, if you have to enhance or rebuild something, that you took the correct spots. You can easily prove the spot by searching SCN. If I wasn’t that sure, I found most of the times another, which get answered the question already. If not, be the first asking. By the way, talking to colleagues about things like that always helps and gives another perspective on it. Luckily I’m surrounded by  some

The 4^th point is, think about your developing twice.

Before starting, as mentioned above and afterward. It is not wasted time, to work through your coding again and make comments, where comments are missing. It is not a good programming style, to be the only one to understand what it’s going on inside. You will get in trouble if you do so, for sure!

Use variables, that speech to the people and saying things like that:

“Hi, I’m Mr. Table, I store the dataset, which is used for proving the orders”. (Ok, I'm a bit silly at the moment, you know what I mean)

^5thUse good technics inside your written code

Today it is more and more important, that we have to make a cut between the view and the coding itself. Use the Patterns and technics which people teached you. MVC is a big thing right now and it might be more important than ever before. What technics to prefer and stuff like that, I (we) can’t just summarize in such a few sentences here, that’s why I’m not trying it.

6^th Use the codeinspector!

This is the easiest way to prove the coding. Back to the 1^st point. Use it, if there is a profile in the system. If not, ask the author of the guidelines, why there isn’t one. If there is none, use the default variant, better use that one, than not using it at all.

The Codeinspector helps to make everybody’s development saver and easier. Again, use this awesome feature. If you got a newer release, there might be the ATC (ABAP Test Cockpit) available. But that would be too much at the moment.

7^th Implement unit tests if possible

You know, unit test might be a messie work at the moment, but there is no program, which is guarded against changes. Most of the developing lives and the customer/users get new ideas, what they want to do with it. So the unit-tests help you right at the moment not that much, but if the object returns,

you needn’t to fight what done earlier, just press the button and see, if all scenarios work fine, after developing new cases with it. (That is another big story to tell, there are a lot out there, perhaps I bring another to the binaries, someday)

8^th Make performance tests.

Don’t just say yourself, it’s working with my data. Think about the scenarios hitting your coding in productive areas. Make sure, that you tested or better told other to test your developing in different scenarios. You are the developer and you know the critical things inside. So do not leave them alone, make it public and tell the people what they have to focus in your eyes.

9^thDon’t waste too much time with a technical documentation.

     Only waste time with TDs if your're going to make AWESOME ones

  Give the result to another developer and just let him look at it for 10 minutes. It just should be a feeling, if it is understandable what you are doing there. It doesn’t matter if he can understand everything, but the feeling should be there. When writing the technical docu remember this blog here:

Stop writing Technical Documentation nobody will ever read

We discussed about it in the office and yes, he is absolutely right.

As usual, a question in the end:

Who knows, when working through the guidelines of your company last time. How often is this document updated? Is there also a styleguide included?

Thanks for reading to the end. If I'm wrong with a point, let me know and I can rethink it.

Regards

Florian

PS: It just popped up in my mind, so I added the Star Wars picture*haha*

18.02.14: Updated point number 9 out of the comments. I agree with Mauricio Cruz  and Bruno Esperanca that the mentioned description gives a better clue, what is meant

Calling all ABAP developers who need/want to learn JavaScript...

In Kevin Small's excellent blog he informed ABAP developers that:

a) Its OK to take other programming languages seriously   :-)

b) JavaScript is one such language

c) You really need to learn this language

So for those ABAPers who now want to take the next step and plunge into the low-level details of the language, I have revamped and released some training slides I wrote about a year ago.

One of the main conceptual differences ABAPers will need to understand is that fact that JavaScript is a highly dynamic language!  This then requires you to think in a completely different manner about how you construct your software.  I attempt to explain the differences in a step-by-step manner, without asking you to make any leaps of understanding.

These slides cover the JavaScript language from the ground up and have been designed with the assumption that the reader has no prior knowledge of the language.  You will be guided in gradual steps from the simplest concepts of language syntax and data types, right up to advanced topics such as creating prototype chains and the use of the functional programming style (as opposed to the more familiar imperative programming style used by ABAP)

Chapter 1: Introduction

Chapter 2: Data Types

Chapter 3: Syntax

Chapter 4: Scope

Chapter 5: Functions

Chapter 6: Inheritance

Chapter 7: Functional Programming

Since these slides are focused only on the JavaScript language itself, they do not cover the use of JavaScript within the specific context of a browser (E.G. DOM programming and event handling are not covered); neither are JavaScript frameworks such as jQuery, Sencha or SAPUI5 covered. These subsequent topics should be addressed only after you have built a solid foundation in the language itself.  For instance, once you have gone through these slides, you will be completely ready to start SAPUI5 training.

All seven chapters are contained in this ZIP file in PowerPoint SlideShare format.  Because the low level details of learning a language can be rather dry, I've taken a somewhat tongue-in-cheek approach and thrown in a few amusing comments and asides just to lighten things up.  :-)

Unfortunately, I have had no time to create any exercises to accompany these slides; however, if you open the Chrome or Firefox browser and then open the Developer Tools, you will have access to a JavaScript console in which you can execute JavaScript commands and create simple objects.

Alternatively, if you're feeling somewhat more adventurous, you could install NodeJS and then have a JavaScript runtime environment that does not require a browser (server-side JavaScript).

Hope that helps!

Chris W

An easter egg always is a nice way to let others enjoy your programming. But placing evil hacks inside the code can be slightly too-much:

And for those who think that all this internet stuff is eternal, here comes a warning:

Thanks God there is no commit after the internet closing. Last one turns the lights off.

I was recently debugging a sales order user exit and wanted to see data present in all the internal tables at that point.

Since all internal tables had header line, their records count was not visible in Variable Fast Display of New Debugger.

As a result, it was inconvenient to double click on 226 internal tables only to find that most of them are empty.

This blog will cover:

1. How to filter the internal tables' names from a huge list of variables in New Debugger.
2. How to easily see the record count of a given list of internal tables (esp. the ones with header line)

Scenario demonstration

A breakpoint is set in USEREXIT_READ_DOCUMENT of program MV45AFZZ and a sales order is displayed.

Navigate to Variable Fast Display > Globals tab in New Debugger.

The table icon in second column indicates that it is internal table.

We can't know whether the table has any record by just looking at Globals tab.

To see the number of records, we need to suffix the internal table names with [].

Entering the names manually is time consuming, adding the suffix is even more time consuming.

Filtering internal tables from global variables list

We can first sort the globals list so that all internal tables are together.

There is no sort button visible, but it can be done by clicking on settings button on right side.

Select the second column, click on settings and do sort.

The sorted list now shows 20+ items at a time.

Since there were 226 internal tables, Block selection (Ctrl+Y) and PageDown cycle wasn't so good to copy the names.

So, I used same settings button again to save the list to local spreadsheet.

We now have the list of internal tables, but they need to be suffixed with [].

Adding suffix to a list

I used Notepad++ to select every line using (.*) and regex replaced it with \1[] to add [] to all names.

However, MS Excel can also be used to do it easily using concatenation.

Just like ABAP has concatenate and && operator, MS Excel has & operator to join values.

Below screenshot shows the formula used to add suffix. Column A has the list, Column B has [].

Column C has formula =A[RowNumber]&B[RowNumber].

If I didn't know concatenation operator, I would have pasted Column A and B to Notepad and replaced TAB character with nothing.

Variables 1 tab will be able to show records for this data.

Unfortunately "paste from clipboard" option is not present in Variables 1 tab.

The visible area allows me to display only 25 variables at once.

I copied the suffixed names in batches of 25 to see the records.

This method may seem lengthy, but it is better than double-clicking on 226 internal table names.

In the Application Performance Engineering, all phases are equally crucial right from identifying the performance test scenario to the Analysis & tuning. Performance improvement is normally an iterative process until the product reaches a stable performance state abiding by all the performance standards.

     1. Identifying what to test

In this phase, if we do not identify the precise performance test scenarios the complete cycle will focus on inappropriate areas for performance tuning. In this step we need to establish the performance tuning goals and performance baseline. The difference between both is the performance gap which the process is targeted to eliminate.
While choosing the performance test scenario, we should also consider that different business scenarios would involve different portions of program code. If performance test case is not related to performance issue, then the “bad” code would not be traced. So it is critical to performance tuning process that a right performance test case is identified.

     2. Performance tracing & Measurements

In this phase, with the help of performance tools, measurements & tracing for the scenario is done. The various traces and tools available are, ST30 for capturing the statistical data from STAD, ST05 trace for capturing SQL, RFC, Buffer, HTTP, Enqueque trace, SE30/SAT for the ABAP Trace.

While tracing any scenario, you should first execute the scenario twice or thrice in order to eliminate the buffering impact on performance.
If the scenario is too time consuming, you should do several traces at different time during the test execution instead of one trace.

     3. Identifying Performance Issues & tuning opportunities

In this phase we need to analyze performance traces to identify the violations in ABAP logic or SQL operation
To pin point the problem in ABAP coding, we can analyze the SE30 ABAP trace, the major performance issues which causes the high CPU time are mostly inappropriate implementation of Internal tables either in terms of loop or read or sort.

If the DB Time of your application is high, we can refer to the SQL trace for getting to the root cause of the issue.

3.1 Analysis Steps for DB Time Analysis

      3.1.1 Identical Selects:

Get into the ST05 trace and summarize it by SQL statements, now sort descending the column for identical selects. All the statements with identical selects value greater than zero can be the candidate for performance tuning.

The various issues due to which identical selects occur

     1. Buffering not allowed on the table, solution can be to buffer the table according to the scenario, if this is not possible we could           implement Buffer Module. Also, if the same data is fetched again and again we could append the data into an internal table on the first           access to the data base and later read it from the internal table.

     2. Buffering is allowed but bypassed, there are certain queries which bypass the buffer and hit the data bases. For eg.[refer the list below].

     3. Buffering allowed but there is not data fetched by where clause and thus no records are found in the buffer and database table is           accessed multiple times. Solution is to implement a No found buffer.

3.1.2 Buffer Bypass:

Arrange the column BfTp in descending order; the statements on the tables with buffering switched off will have this column as blank, if otherwise the statements are the candidate for performance optimization. Here we need to analyze why the buffers are bypassed and what can be done to avoid the same.

3.1.3 Proper Indexes

Arrange the Summarized SQL statements in descending order of time/execution.

If the time/execution of the statement is greater than 10ms, it can be the candidate for performance tuning. The various issues due to which this occurs:

     1. No index is present on the table, which a where clause can use. Solution: if possible a new index needs to be created, or we can re-write           the where clause in order to use the existing index.

     2. The index is available, but the statement is written in such a way that is doesn’t use the index. For. Eg. A query with order by a,x,c           whereas the table has an index a,c,x; such a query will not use the index . Solution: is to re-write the query in such a way it uses the           index.

     3. Insert/Update statements on a few tables might take a lot of time, which may be because the table has too many indexes and the           time/execution also includes the time to update these indexes.

3.2 Analysis Steps for CPU Time Analysis

If the CPU time for the application is too high, the analysis can be done using the ABAP trace (SAT/SE30),

3.2.1 ABAP trace (SAT/SE30),

The SAT Traces help to identify hot spots in an application. This can be done by getting into the trace and sorting in descending order by net time. Here you may encounter issues due to

1. Expensive operations on internal tables
2. Unnecessary calls to processing blocks or entire code branches
3. Long running modularization units
4. Nested loops

3.2.2 Volume Scalability Single User Check

The major performance issues occur in an application when it handles large volume of data, (Customer like data), such huge data volume scenarios are generally difficult to simulate and analyze for the flow of data.
But, the SAT Runtime Analysis tool provides the option of testing the scalability of the application without creating huge volume of data. This is done by comparing the traces of the same scenario where different amount of data is handled.

This tool displays the comparison of various statements in both traces with respect to data processed in the statement/call and the net time taken by it, if both of these are in the same ratio then the application is scalable else that statement/call is the candidate for performance tuning.

Mostly these issues are due to the erroneous implementation of the internal table for e.g. sorting each time after append, using different & multiple sort order for an internal table etc.., which can be easily analyzed using the debugger.

3.3.3 Roundtrips & Network Delay

If the application has roundtrips of more than 2, the CPU time as well as response time would be high depending upon the location of your test system & server, due to network delay.

In SAT trace you can analyze the same, the net time of event RFC wait would be high and could be located in the SAT trace, or else the flush call could be searched in the trace.

Such calls directly for the application programs should be avoided.

4. Performance Tuning, Re-test & Analysis

In this phase the solutions need to be implemented to improve the performance.
If testing shows that program performance with the change is still short of expectation, you have to repeat the whole process again. It is important that we should execute the same test scenario and in the same SAP system with exactly same data before and after the change. Using different testing box is just adding another variable which makes performance measure harder.

SAP transaction SCI known as “SAP Code Inspector” can be used to scan through ABAP code to identify common performance pitfalls like SQL statement without where-clause etc. This is a static performance check. Output from this can be a part of improvement proposal together with what from trace analysis. Static code check is relatively simple is a good habit to use SCI.

Calculate Dunning charges through BTE ‘00001071’ at the time of Dunning(Tcode-F150)

This is the scenario regarding calculate dunning charges and posting in customer line item. This calculates the charges of dunning on the basis of the dunning levels of the customers.

Following is the job log when we Dunn the customer through the transaction code F150.

We can see the posted dunning charges for first level in FBL5N transaction code.

This is implemented by using the BTE ‘00001071’. Following is the enhancement details.

Got o transaction code FIBF. Then Settings->Products->of a customer. Suppose we created product here as ZDUNN.

Then Go to again settings->process modules->of a customer .And activate the BTE.

Create function module by coping ‘SAMPLE_PROCESS_00001071’ to Z_EVENT_001071

So assign the product ZDUNN to above created FM. This is shown as below:

Write the below code in function module Z_EVENT_001071

DATA : l_is_documentheader   TYPE bapiache09,                "Document Header
         l_is_customer         TYPE bapiacar09,
         l_it_customer         TYPETABLEOF bapiacar09,  “account relievable
         l_is_currencyamount   TYPE bapiaccr09,
         l_it_currencyamount   TYPETABLEOF bapiaccr09,  "Currency amount
         l_is_accountgl        TYPE bapiacgl09,
         l_it_accountgl        TYPETABLEOF bapiacgl09,
         l_it_return           TYPETABLEOF bapiret2,  "Bapi return Messages

"Fixed G/L Account
    l_gl_account = '123456789'.

    "Conversion for the G/L account
    CALLFUNCTION'CONVERSION_EXIT_ALPHA_INPUT'
      EXPORTING
        input  = l_gl_account
      IMPORTING
        output = l_gl_account.

"Filling the structure of BAPI_ACC_DOCUMENT_POST
    "Document header
    l_is_documentheader-bus_act    = 'RFBU'.
    l_is_documentheader-username   = sy-uname.
    l_is_documentheader-header_txt = 'Charges'.            
    l_is_documentheader-comp_code  = i_mhnk-bukrs.
    l_is_documentheader-doc_date   = i_mhnk-laufd.
    l_is_documentheader-pstng_date = i_mhnk-laufd.
    l_is_documentheader-doc_type   = 'XY'.

    l_item_count             = l_item_count + 1.

    "Acount Recievable (Customer)
    l_is_customer-itemno_acc = l_item_count.
    l_is_customer-customer   = i_mhnk-kunnr.
    l_is_customer-comp_code  = i_mhnk-bukrs.
    APPEND l_is_customer TO l_it_customer.

    "Currency Amount
    l_is_currencyamount-itemno_acc = l_item_count.
    l_is_currencyamount-currency   = i_mhnk-waers.
    l_is_currencyamount-amt_doccur = c_mhngh.
    APPEND l_is_currencyamount TO l_it_currencyamount.

    l_is_currencyamount-itemno_acc = l_item_count + 1.
    l_is_currencyamount-currency   = i_mhnk-waers.
    l_is_currencyamount-amt_doccur = -1 * c_mhngh.
    APPEND l_is_currencyamount TO l_it_currencyamount.

    "GL Account
    l_is_accountgl-itemno_acc =  l_item_count + 1.
    l_is_accountgl-gl_account =  l_gl_account.
    l_is_accountgl-pstng_date = sy-datum.
    APPEND l_is_accountgl TO l_it_accountgl.


    " Document posting
    CALLFUNCTION'BAPI_ACC_DOCUMENT_POST'
      EXPORTING
        documentheader    = l_is_documentheader
      TABLES
        accountgl         = l_it_accountgl
        accountreceivable = l_it_customer
        currencyamount    = l_it_currencyamount
        return            = l_it_return.

DELETEADJACENTDUPLICATESFROM l_it_return COMPARINGtypeidnumber
                                                       message_v1 message_v2
                                                       message_v3 message_v4.

    LOOPAT  l_it_return INTO l_is_return.
      IF l_is_return-typeEQ'S'.
        CALLFUNCTION'BAPI_TRANSACTION_COMMIT'
          EXPORTING
            wait = l_c_x.

      ELSEIF l_is_return-typeEQ'E'OR l_is_return-typeEQ'A'.
        CALLFUNCTION'BAPI_TRANSACTION_ROLLBACK'.
        "MESSAGE 'Error in posting the document' TYPE 'E'.
      ENDIF.
    ENDLOOP.

  ENDIF.

Hi, please be gentle, as I dare to enter my first blog-post.

The following might be a bit simple and child knowledge for you all, but I wish someone would have told me this little trick, when I first started developing Smartforms.

I used to get this question a lot: “Martin – we have a problem with the invoice print, and we can’t re-create the error in the development system. Can you please debug and find the error in the production system?”

I really needed to create a session break-point directly into the Smartform in the production system, but how? – where was the button in the smartforms transaction?.No way was I going to create a transport request with the smartform holding a coded breakpoint.

Sure I could go to VF03 and use ‘/h’, but that is kind of a tedious way to go.

Instead I did this:

     1. Go to Smartforms transaction and type in the smartform name and hit “test”. Then you get the function module name that triggers the smartform print in      the given system.

     2. Copy the FM name to clip holder and go to SE80. 

     3. Select program and paste the name in.

4. Put an ‘L’ just before the last name and end it with a ‘F01’ and hit enter.

You now get the include, that holds all form routines representing every node in the smartform. Search for the one you need, and create your session breakpoint in the productive system.

(Global initialization in the smartform is in subroutine ‘GLOBAL_INIT)

Please note that this does not work for all smartforms but in my experience most SD forms can be debugged this way in productive and QA-systems.

/Martin

Are Comments overrated?

Comments are a wonderful tool to document what you intended with certain program logic. You can place it directly where that logic resides: In the source code. As comments are non-functional, they are not getting compiled and hence, not executed. However, I’ve got the feeling that sometimes we should really think about how to use comments and how not to use them. These points are neither fundamentally new nor innovative to developers at all, but I still have the feeling, that these are the most commonly violated principles.

Antipattern #1 – Comments do not replace program structure

Usually, developers should tell the reader of their code why they are doing something, not what they are doing. Before you start to comment by describing what the next few lines of code should do, stop and think about it.

Consider the following example. What do you think would be better to read?

*   parse header from excel    lv_row = 2.    lv_column = zcl_excel_common=>convert_column2int( lv_range_start_column ).    lv_current_column = 0.    WHILE lv_column <= lv_highest_column.      lv_current_column = lv_current_column + 1.      READ TABLE mt_fcat INTO ls_fcat INDEX lv_current_column.      CHECK sy-subrc = 0.      lv_col_str = zcl_excel_common=>convert_column2alpha( lv_column ).      io_excel_worksheet->get_cell(        EXPORTING          ip_column = lv_col_str          ip_row    = lv_row        IMPORTING          ep_value = lv_value      ).      ASSIGN COMPONENT ls_fcat-fieldname OF STRUCTURE ls_scale TO <lv_value>.      CHECK sy-subrc = 0.      CASE ls_fcat-inttype.        WHEN 'D'.          <lv_value> = zcl_excel_common=>excel_string_to_date( lv_value ).        WHEN OTHERS.          <lv_value> = lv_value.      ENDCASE.      lv_column = lv_column + 1.    ENDWHILE.    lv_column = zcl_excel_common=>convert_column2int( lv_range_start_column ).    lv_row = lv_row + 1.
*             …Some more coding…    lv_highest_row = io_excel_worksheet->get_highest_row( ).
*   parse items from excel    WHILE lv_row <= lv_highest_row.      lv_column = 2.      lv_col_str = zcl_excel_common=>convert_column2alpha( lv_column ).      io_excel_worksheet->get_cell(        EXPORTING          ip_column = lv_col_str          ip_row    = lv_row        IMPORTING          ep_value = lv_value      ).      lv_catyp = lv_value.      lv_column = 1.      lv_col_str = zcl_excel_common=>convert_column2alpha( lv_column ).      io_excel_worksheet->get_cell(        EXPORTING          ip_column = lv_col_str          ip_row    = lv_row        IMPORTING          ep_value = lv_value      ).
*                           some more coding…      lv_row = lv_row + 1.    ENDWHILE.

Basically, the comments tell me what the next few lines of code will do. But there is no benefit. You just don’t understand immediately, what the code does, no matter if there are comments available or not.

Even worse, more comments would not make clear what the code does. Furthermore, as you shift code to another part of your program, the comments might lose their relationship to the code – as they are non-functional and not taken into account by the compiler. This will eventually lead to comments that are misleading users in the best case.

Consider this refactored example:

    parse_header_from_excel( io_excel_worksheet = io_excel_worksheet io_scale = ro_scale ).    parse_items_from_excel( io_excel_worksheet = io_excel_worksheet io_scale = ro_scale ).

Actually, replacing comments by special methods with a useful name does not reduce complexity – but it increases readability dramatically.

By the  way, that’s why I think that code scanners which measure the ratio of comments and source code are useless – as the goals that they proclaim to address cannot be addressed by such simple measurements.

Normally, I try to produce code which has no comments in the middle of some logical program unit like a method. If there are comments, they are at the top of the code – or nowhere.

Antipattern #2 – Commented code

Having code that is getting useless by the time will lead to the end of its lifecycle. Usually most of the developers just comment this piece of code out. How often have they ever read this program logic again?

I personally do not read it as it might lose track of its relationship to the surrounding source code by the time. My eyes just went over these comments. Whenever I need to delete some coding that I might miss in the future, I generate a new version of the ABAP source code and delete the code. Code Versioning systems are meant for this kind of tasks. When I miss something in the code, I take a look at the versions – This immediately allows me to compare two versions by the changes that have been applied in the meantime.

Previously we have discussed how to generate QRcode with SAP standard functionality:

1. Generate QRcode with ABAP Webdynpro

2. Generate QRcode with ABAP Code plus Adobe form template

Both solutions will generate QRCode within a PDF file. If your requirement is to generate the QRCode in a picture file, you can use the solution described in this blog.

There are lots of websites which provide free QRCode generation service. Just google it:

I prefer to use this one http://www.qrstuff.com: just choose "Plain Text" and we can input some characters in Text field. There is a AJAX call which will generate QRCode immediately after some characters are typed.

Now question is how we automate the character input via ABAP.

I use Chrome to explore what has happened when we input some char in webpage. Click F12 to launch Chrome developer tool, input some char and observe the information displayed in the "Network" tab:

The request URL is found: http://www.qrstuff.com/generate.generate

The request method is GET.

Also it is necessary to identify http form fields and they are also listed in Chrome:

We need to copy all of those form fields into our ABAP code except preview=1, since we don't need the preview functionality, we just need the generated png file.

here below is the simple report to generate QRCode from hard coded string "testforQRCode". ( The bold text are just copied from Chrome developer tool )

The source code of zcl_http_tool could be found from attachment.

DATA:     ls_form   type zcl_http_tool=>ty_name_pair,     lt_form   type zcl_http_tool=>tt_name_pair,     lv_code   type xstring.
ls_form = value #( name = 'type' value = 'TEXT' ).
APPEND ls_form TO lt_form.
ls_form = value #( name = 'foreground_color' value = '000000' ).
APPEND ls_form TO lt_form.
ls_form = value #( name = 'ecc_level' value = 'L' ).
APPEND ls_form TO lt_form.
ls_form = value #( name = 'width_pixels' value = '200' ).
APPEND ls_form TO lt_form.
ls_form = value #( name = 'dpi' value = '72' ).
APPEND ls_form TO lt_form.
ls_form = value #( name = 'file_type' value = 'png' ).
APPEND ls_form TO lt_form.
ls_form = value #( name = 'text' value = 'testforQRCode' ).
APPEND ls_form TO lt_form.
zcl_http_tool=>send_request( EXPORTING iv_url      = 'http://www.qrstuff.com/generate.generate'                                       iv_req_type = if_http_request=>co_request_method_get                                       it_form     = lt_form
IMPORTING ev_response = lv_code ).

And this is QRCode scanned from my mobilephone:

Hi SCN community!

Ever wanted to get the line in a table where the max value for a certain field was? I had to last week, and I remembered just how awful it was to do it. Declare an auxiliary table of the same structure, copy the entire contents, sort for the right field, get the first line, correct?

I thought that there had to be a better way to do this, and I searched for it, and couldn't find it. And I was actually challenged by Manish Kumar to create a class for this, and so I did.

What I'm sharing is a simple class for internal table manipulations. So far it has 4 methods:

• GET_MAX_LINE - Get the line with the maximum value for a certain column
• GET_MIN_LINE - Get the line with the minimum value for a certain column
• GET_MAX_VAL - Get the the maximum value for a certain column
• GET_MIN_VAL - Get the the minimum value for a certain column

I'm trying to set up github so that we can all work on this together, hopefully we will be able to work on other utility classes like this one.

If you have any suggestions or contributions please feel free to join

I'm sharing a slinkee that you can import using SAPLINK and also a source code-based class implementation that you can copy paste in SE24. The slinkee is the file called "CLAS_ZCL_ITAB.txt" and you'll have to change the extension to 'slnk'.

Best,

Bruno

Recently, I got into issue of getting local structure declared in another program.

Initially, I though of re-declaration again in current program than I thought of searching of generic function or class which can give me locally declared structure from different program.

After due diligence & search I found FM - GET_COMPONENT_LIST.

SO I have created program A which has local declaration of structure as below.

TYPES: BEGIN OF ty_headout,

        out001(40)     TYPE c,

        out002(40)     TYPE c,

        out003(40)     TYPE c,

        out004(40)     TYPE c,

        out005(40)     TYPE c,

        out006(40)     TYPE c,

        out007(40)     TYPE c,

        out008(40)     TYPE c,

        out009(40)     TYPE c,

        out010(40)     TYPE c,

     End OF ty_headout.

Data: wa_output       TYPE  ty_headout.                         "#EC NEEDED

By using FM - GET_COMPONENT_LIST, we can get list of structure component.

Regards,

Sameer

After participating in a wonderful discussion OO style ABAP Programming Vs Procedural ABAP Programming, I could not stop from thinking over it and as I possess limited or almost no expertise in this area, I thought of presenting a simple skeleton that I would use for a report program. The case here is a classical report. The requirement can be anything, but for sure, it will allow user to enter something, validate the user input, fetch data, process data and finally display it on screen. I am trying to discuss the concept here, so for the time being, I have kept the code away.The best part is, it is really tiny piece to read.

Most of the times, I end up developing a class for UI, Data Processing and Output. Usually, if I hear the client saying they need lots of reports based on this screen & data, I create a global Z class. Otherwise, I create a local class. This class has methods to validate selection screen elements and throw exceptions. Each method will accept an input of appropriate type, or as an alternate, I can assign user input as attributes of the class. Every method of the class raises exceptions. However, I have not mentioned complete signature anywhere below. Just trying to communicate what I prefer doing.

If everything goes well, then the data fetching starts, I call methods of another Z class. This class has private methods to fetch data, process it and return final table(s) .

Finally all the data goes to the output class. This class has internal methods to instantiate and display ALV.

I thought another way of doing this can be create a parametrized constructor for the class. Parameters will be the selection screen elements. So just one call to the class and the you will see the output. However, I felt the 1st approach each better and continued with it.

In a nutshell, something like this will happen. I know END-OF-SELECTION is not really required but I think no harm if I use it.

AT SELECTION SCREEN

     Call method of the ZInputClass for validation / additional data

START-OF-SELECTIN

    BusinessCLASS=>Fetch_Data

END-OF-SELECTION

    DisplayClass=>Show_data

Help and Guidance welcome!!! Hope someone will find it worth responding.

Regards

Abhi

Hello everyone!

This one is for all of those and me too. Most of the posts I have seen on SDN where people asking for alternative READ_TEXT alternative fuvtion module for read_text | SCN or mass usage of READ_TEXT. Some good or better developers - I must say - are worried about performance issues. Few newbies are still looking for the usage of READ_TEXT. Lol. FM - READ_TEXT issue with data declaration | SCN

I was also looking for some alternate solution but all in vain. I found one good wiki about the usage of the FM: Function Example READ_TEXT ABAP wrapper function - Enterprise Information Management - SCN Wiki. This one is great but obviously I have two main concerns. 1. Performance, 2. Mass usage of reading long text of any object. There is another way to achieve mass read of long text by looping the READ_TEXT (lol, that's funny), I don't need this either because I need performance. I don't want Basis guys cursing me!

So, what I came with was to avoid READ_TEXT, now the question is HOW? You might think of a big NO! Not possible! But remember

Lots of time people say no when they don't know.

Let me assure you one thing I have done this and it is ready working like a charm.

All you need to do is just fetch the data, first from STXH then from the line item table STXL. Only question left is how to decompress the long text? Well, that's pretty easy and not a big deal all you need is the use of IMPORT statement.

Now let's see what we have to and how to do it? Below is the code that's is working 4 to 5 times faster than READ_TEXT performance and is as simple as anything!

*&---------------------------------------------------------------------*
*& Report  ZMA_READ_TEXT
*&
*&---------------------------------------------------------------------*
*&
*&
*&---------------------------------------------------------------------*
REPORT  ZMA_READ_TEXT.
TYPES: BEGIN OF TY_STXL,          TDNAME TYPE STXL-TDNAME,          CLUSTR TYPE STXL-CLUSTR,          CLUSTD TYPE STXL-CLUSTD,        END OF TY_STXL.
DATA:  T_STXL TYPE STANDARD TABLE OF TY_STXL.
FIELD-SYMBOLS: <STXL> TYPE TY_STXL.
* compressed text data without text name
TYPES: BEGIN OF TY_STXL_RAW,          CLUSTR TYPE STXL-CLUSTR,          CLUSTD TYPE STXL-CLUSTD,        END OF TY_STXL_RAW.
DATA:  T_STXL_RAW TYPE STANDARD TABLE OF TY_STXL_RAW.
DATA:  W_STXL_RAW TYPE TY_STXL_RAW.
* decompressed text
DATA:  T_TLINE TYPE STANDARD TABLE OF TLINE.
FIELD-SYMBOLS: <TLINE> TYPE TLINE.
DATA: T_STXH TYPE STANDARD TABLE OF STXH,       W_STXH TYPE STXH.
SELECT TDNAME TDOBJECT TDID   FROM STXH     INTO CORRESPONDING FIELDS OF TABLE T_STXH.
*AND THEN
* select compressed text lines in blocks of 3000 (adjustable)
SELECT TDNAME CLUSTR CLUSTD        INTO TABLE T_STXL        FROM STXL        PACKAGE SIZE 3000        FOR ALL ENTRIES IN T_STXH "WITH APPLICATION DATA AND TDNAME        WHERE RELID    = 'TX'          "standard text          AND TDOBJECT = T_STXH-TDOBJECT          AND TDNAME   = T_STXH-TDNAME          AND TDID     = T_STXH-TDID          AND TDSPRAS  = SY-LANGU.   LOOP AT T_STXL ASSIGNING <STXL>.
*   decompress text     CLEAR: T_STXL_RAW[], T_TLINE[].     W_STXL_RAW-CLUSTR = <STXL>-CLUSTR.     W_STXL_RAW-CLUSTD = <STXL>-CLUSTD.     APPEND W_STXL_RAW TO T_STXL_RAW.     IMPORT TLINE = T_TLINE FROM INTERNAL TABLE T_STXL_RAW.
*  access text lines for further processing     LOOP AT T_TLINE ASSIGNING <TLINE>.       WRITE: / <TLINE>-TDLINE.     ENDLOOP.   ENDLOOP.   FREE T_STXL.
ENDSELECT.

Here is the output: I have not restricted it to any object (obviously you can do it for your need) and boy it pulls more then 1300 records within a nano second!

Boom!!

There is another Function Module to fetch multiple texts: RETRIEVAL_MULTIPLE_TEXTS but I haven't used it.

Now the last thing, I want to thank Mr. Julian Phillips and Mr. Thomas Zloch. Thankful to Julian because he posted and Thomas gave the solution. Same solution I implemented with some additions. Here is the post I referred to: Mass reading standard texts (STXH, STXL)

I hope you will reuse this code to fetch multiple long text and your comments, suggestions and complaints are welcome!

Note: Sourcecode attached!

Today, I will share a short tip with you guys. It's related to Module Pool programming and very handy when used. If you have ever worked on Screen Programming then you would definitely have noted one thing while working on the longer screens (screens with scroll).

It's very common when you design and develop a screen and it contains scroll then it already jumps to the top when you fire any event at the bottom of the screen or in the middle of the screen. For example you have one module pool screen with multiple sub-screens, text edit control, text-boxes (with labels of course), some combo-boxes and few other controls. Now your screen will definitely have a scroll bar (vertical one).

By default screen jumps to the top when you hit ENTER or fire any other event on the screen. To avoid this we have a simplest solution by following the KISS (Keep it Simple Sir) phenomenon.

For example you are working on screen as shown below:

This above shown screen has a definite vertical scroll and it's a very large screen and if you trigger any user command anywhere on the screen it will jump to initial state to avoid this follow the following solution.

Here you can see there is a group box named "Settings". Just check "Hold Scroll Position" and your screen will not give you any awkward behavior like jumping or uneven scroll.

Today, we learnt how to stop Module Pool screen from jumping up when any user command is fired.