Posts on Abapinho

Who triggered the exception?

Mon, 22 Jun 2026 09:00:00 +0100

Exceptions can be passed back, method by method, bubbling up, and caught by a method that has nothing to do with the one that raised it. And how will you find it?

Attributes that are global variables in disguise

Mon, 08 Jun 2026 09:00:00 +0000

There’s nothing worse than seeing code that abuses variables. They’re so delicate, and yet they’re treated so badly. Poor things. And to those who have to read them. The worst way to treat a variable is to make it global. It’s hard to believe, but in 2025 this crime continues to plague our systems. Well, here’s a way to show them some love.

I hate magic numbers

Mon, 27 Apr 2026 09:00:00 +0000

Those who work in SAP think it’s normal for everything to be represented by obscure codes that mean nothing. But it doesn’t have to be this way. Stop it! Create human-readable codes please.

VALUE #( ) and nothing else

Mon, 20 Apr 2026 09:00:00 +0000

I once wanted to test a class whose constructor took several parameters, each requiring an instance of a different interface. These instances weren’t easy to create and weren’t relevant to the test. After some experimenting, I found a way to work around the problem.

Test boolean methods implicitly

Mon, 13 Apr 2026 09:00:00 +0100

A quick reminder. I thought this was obvious but I keep seeing IF statements that explicitly test the result of a boolean method against ABAP_TRUE or using INITIAL. There’s no need! ABAP is clever in this regard.

Thank you, Martin Jonen

Mon, 23 Mar 2026 09:00:00 +0000

It’s great to find peers who are equally interested in improving and evolving, not just as a programmer but also as a human being. I recently found one.

Execute code after a COMMIT

Mon, 16 Feb 2026 09:00:00 +0100

Remember how with CALL FUNCTION IN UPDATE TASK you could delay some actions until the moment of a COMMIT?

Tech Radar

Mon, 19 Jan 2026 09:00:00 +0000

I found this amazing chart of SAP technologies.

FILTER

Mon, 03 Nov 2025 09:00:00 +0000

The FILTER function is new and still relatively unknown. I will give you an example of how it can be used.

Set a baseline for your ATC

Mon, 20 Oct 2025 09:00:00 +0100

Did you know that you can set a starting point for ATC and, thanks to that, be able to run ATC in legacy code?

Kintsugi

Mon, 13 Oct 2025 09:00:00 +0100

When a porcelain object breaks in Japan, sometimes instead of throwing it away, they mend it. But they don’t mend it just any old way; they mend it with gold. This technique is called Kintsugi.

Why always MODIFY?

Mon, 06 Oct 2025 09:00:00 +0100

It is a common practice in ABAP to use MODIFY instead of INSERT and UPDATE. Do you do it too? Tell me why. Is it laziness? Is it fear? Is it just a matter of “whatever”? Or is it more like “screw it”?

On broken windows

Mon, 09 Jun 2025 09:00:00 +0100

The broken window theory says that if a window in a building is broken and not repaired quickly, people will be tempted to throw stones and break the other windows.

Everything Everywhere All At Once

Mon, 02 Jun 2025 09:00:00 +0100

Sometimes it’s useful to look at two areas of the code at the same time. If the areas are in different classes, just open them both. But what if they’re in the same class? For example, if you want to make a method inspired by or related to another.

Case insensitive SELECTs

Mon, 26 May 2025 09:00:00 +0100

In SAP it’s normal to have tables in the database with a NAME field and another NAME_SEARCH which is filled in with exactly the same thing as NAME but in upper case.

Then, when you want to do case-insensitive searches you use NAME_SEARCH. You don’t need to do this anymore.

It's normal to not get it right the first time

Mon, 07 Apr 2025 09:00:00 +0000

In the ABAP world, the rule is to do it once and never touch it again. Once done, forever frozen. What nonsense.

Where? Who? What? How?

Mon, 17 Mar 2025 09:00:00 +0000

You’ve been asked to create a new feature. You’re ready to build it. But hold your horses. Before you start, I suggest you find answers to a few questions. Finding a good answer to each of them is fundamental to ensuring that what you build is solid and elegant.

Reconstants

Mon, 17 Feb 2025 09:00:00 +0000

In my current project constants are all over the place, with confusing or wrong names. It’s a mess. I’ve found a way to reorganize and rearrange the constants so that the new code can use pretty constants without messing up the old code, which can continue to use the confusing ones.

We finally have FINAL

Mon, 03 Feb 2025 09:00:00 +0000

There’s nothing worse than seeing people abusing variables. They’re so delicate and yet so badly treated, poor things. Here’s a way to show them some love.

How do you like your blank lines?

Mon, 30 Dec 2024 09:00:00 +0000

Everyone uses blank lines to better organize their code. But where to use them and how many? Let’s talk about that.

Eclipse converts database data into VALUEs

Mon, 18 Nov 2024 09:00:00 +0000

Sometimes you need to take data from the database and replicate it declaratively in ABAP using the VALUE command. For example, to build ABAP Unit tests.

In Eclipse ADT you can open an object in another client

Mon, 07 Oct 2024 09:00:00 +0100

Historically, it has always been impossible to jump from one SAP system to another without losing context. Now it’s possible.

Eclipse ADT Data browser is much better than SE16N

Mon, 30 Sep 2024 09:00:00 +0100

The tools that SAP provides for viewing the contents of database tables have always been very sketchy.

eclipse-adt-extract-method

Sun, 30 Jun 2024 14:34:34 +0100

When you have a very large method, you should subdivide it into several smaller ones.

In Eclipse ADT you can always undo

Mon, 17 Jun 2024 09:00:00 +0100

They say: Don’t go back to where you were once happy. But the truth is that in many cases, if you could go back, you would.

Eclipse ADT has lots and lots of keyboard shortcuts

Mon, 10 Jun 2024 09:00:00 +0100

I like keyboard shortcuts. If I could do my job without taking my hands off my keyboard I’d be an even happier programmer.

In Eclipse ADT you can share links to your code

Mon, 20 May 2024 09:00:00 +0100

Until recently, ABAP has never been one for big collaborations.

Rename a lot of things automatically in Eclipse ADT

Mon, 06 May 2024 09:00:00 +0100

Those who still programme monolithically probably don’t feel the need for this. But anyone who uses multiple classes with multiple methods knows that it’s normal (and even desirable) to change your mind about the name of these things. Ideas aren’t born ready-made in our heads. Ideally, code is mouldable and can be shaped until we find the desired form.

Eclipse ADT puts ABAP Doc to good use

Mon, 29 Apr 2024 09:00:00 +0100

ABAP Doc is an excellent way of integrating documentation into the code.

The magical F2 in Eclipse ADT

Mon, 22 Apr 2024 09:00:00 +0100

Eclipse ADT calls it Code element information.

In Eclipse ADT you continue where you left off

Thu, 04 Apr 2024 21:40:41 +0100

Did you know that in Eclipse ADT you can work even without a connection to the server?

No constant context changes in Eclipse ADT

Mon, 01 Apr 2024 09:00:00 +0000

Every time you switch contexts, you lose the thread slightly. It’s human nature. So the less you do, the better.

In Eclipse the compiler is not lazy

Mon, 25 Mar 2024 09:00:00 +0000

Still using SAPGUI instead of Eclipse ADT? Get ready to be made fun of.

Languages shape thought

Mon, 05 Feb 2024 09:00:00 +0000

I read somewhere that Eastern mathematicians tend to solve a different kind of mathematical problem than Western mathematicians do.

To all those whole criticize 7.4 syntax

Mon, 15 Jan 2024 09:01:01 +0000

This post is addressed to the collective character that represents all the people who have told me that they like some things in the new 7.4 functional syntax but think that you shouldn’t overdo it and should avoid using REDUCE and all the other unnecessarily weird things because the code gets more obscure, it’s slower and they don’t see any advantages.

Are you serious?

Use BASE to not ruin what you already have

Mon, 06 Nov 2023 09:00:00 +0000

We used to use the APPEND and INSERT commands to add rows to internal tables. Now that ABAP has grown, we can use VALUE, REDUCE, CORRESPONDING, etc. But what if the internal table already has rows and we don’t want to lose them?

INNER JOIN instead of FOR ALL ENTRIES

Mon, 30 Oct 2023 09:00:00 +0100

A while ago I showed you that you could SELECT from an internal table. And then I asked myself: if that is possible, shouldn’t INNER JOIN be possible too?

YAGNI

Mon, 16 Oct 2023 09:00:00 +0100

You Ain’t Gonna Need It means Do what you want, but don’t say I didn’t warn you. Just kidding. Not really.

Copy from SAPGui to the clipboard

Mon, 25 Sep 2023 09:00:00 +0100

Did you know that your ABAP programme can copy content to your operating system’s clipboard?

SELECTing from an internal table

Mon, 28 Aug 2023 09:00:00 +0100

Now you can SELECT from an internal table.

SELECT SINGLE vs SELECT UP TO 1 ROWS

Mon, 12 Jun 2023 09:00:00 +0100

Man, this is one of those endless discussions that will never get anywhere. Ditto trying to decide if you deserve to go on living if you put pineapple on your pizza or Philadelphia cheese on your sushi.

Call SM30 or SM34 from a function module

Mon, 05 Jun 2023 09:00:00 +0100

If you want to call the SM30 from a program you can use CALL TRANSACTION but there is a simpler way.

Use a dictionary instead of IF or CASE

Mon, 29 May 2023 09:00:00 +0100

The fewer IFs and CASEs the better, right? Every branch of an IF or a CASE is an exception. And we like rules better than exceptions. Here’s one more technique to achieve that.

Fix prefixes

Mon, 01 May 2023 09:00:00 +0100

It’s very easy to mess up with object names in SAP. I recently found a way to minimize that problem: set rules to fix per-package prefixes for certain object types.

I package everything that moves

Mon, 03 Apr 2023 09:00:00 +0100

I obsessively package everything that moves.

exclamation-point

Fri, 24 Mar 2023 19:09:52 +0000

Undo with abapGit

Mon, 06 Mar 2023 09:00:00 +0000

Did you know that you can finally make radical changes to a development without fear because there is a simple way to undo all those changes?

The 3 exception parents

Mon, 20 Feb 2023 09:00:00 +0000

OO exceptions always need a parent. They always have to inherit from somebody. And ABAP gives them 3 alternatives.

Message collector

Mon, 16 Jan 2023 09:00:00 +0000

SAP messages are all managed centrally through the SE91 transaction, but can appear to a program in a variety of formats.

SELECT single record using an incomplete key

Mon, 28 Nov 2022 09:00:00 +0000

I was always told that, when selecting a single record, I should use UP TO 1 ROWS whenever the key was not fully provided. My elementary school teacher told me that I should always aks why: why? Nobody ever told me why.

Use & in SAPSript texts

Mon, 14 Nov 2022 09:00:00 +0000

Let’s say you want to show an url in a SAPScript layout. You place the url in a SAPSCript text and assume everything will work fine. Because most times everything does work fine. It’s just that sometimes…

Clean data declarations

Mon, 07 Nov 2022 09:00:00 +0000

While writing code, you should always keep present how easy it will be to maintain. This is particularly important in data declarations. And so easy to do right.

Let go of SE24

Mon, 03 Oct 2022 09:00:00 +0100

In SE24 the class code is partially hidden from the programmer behind a GUI. This is apparently convenient but ultimately limitative.

I finally got rid of prefixes

Mon, 12 Sep 2022 09:09:00 +0100

It took me a long time but I finally got rid of the damn prefixes.

Don't MESH with ABAP

Mon, 29 Aug 2022 09:00:00 +0100

ABAP 7.4 brought a lot of lauded novelties. Of all of them, the one less talked about is MESH. Let’s analyse it and see how unfair that has been.

Use Python to rewrite ABAP code

Mon, 01 Aug 2022 09:00:00 +0000

When you need to make mass changes to ABAP code, the SAPGui IDE isn’t of much help. Eclipse ADT is better, especially if you just want to rename stuff. But there are lots of changes which you won’t be able to automate there. Namely, changes that most be done hundreds of times and which cannot be done with a simple find and replace. In these cases you probably end up changing everything manually. But it doesn’t have to be that way.

SELECT FOR UPDATE

Mon, 23 May 2022 09:09:09 +0100

When you’re going to modify existing records of a database table it is common to first SELECT them to see how they are and only then UPDATE them with what they will be.

Table with all development keys

Mon, 16 May 2022 09:00:00 +0100

When I get to a new project the system administrator generates a development key for each development system assigned to our SAP username. Usually it’s sent to me by e-mail. Usually I lose track of it.

Easily modify internal table record

Mon, 09 May 2022 09:00:00 +0100

The new way to get data from internal tables is also the new way to put data into internal tables.

IF branches should be small

Mon, 02 May 2022 09:00:00 +0100

Picture yourself as a monkey hanging from a tree branch. You want to jump to another branch but it’s so far away that you cannot see it. If you jump you’ll probably fall to the ground. That’s bad.

We manually implemented 1000 SAP notes

Mon, 18 Apr 2022 09:00:00 +0100

In the last years of the previous century, an SAP project manager stubbornly opposed to upgrading the SAP system. Instead, he decided that all the SAP notes belonging to that upgrade were to be manually implemented. All 1000 of them.

Podcast Sem especificação

Thu, 14 Apr 2022 17:26:46 +0100

This Tuesday I was invited by Renan Correa to participate in his podcast “Sem especificação”.

Trotting debugger

Mon, 11 Apr 2022 09:00:00 +0100

There are many excuses not to use the new functional syntax of ABAP 7.4. One is complaining that it’s impossible to debug.

But it is not.

Escape from hackers

Mon, 28 Mar 2022 09:00:00 +0000

Data entered by the user is one of the main vulnerabilities of a programme.

Can your users hack your SQL?

Mon, 21 Mar 2022 09:00:00 +0000

Are you sure your SQL is bulletproof?

Do just one task per LOOP

Mon, 14 Mar 2022 09:00:00 +0000

When ABAP programmers run into a LOOP they like to use it to get as many things done as possible. Even if that LOOP ends up having hundreds or thousands of lines.

Avoid obsolete ABAP

Mon, 07 Mar 2022 09:00:00 +0000

ABAP evolves (even though it stood mostly still for too many years). And as it evolves, it leaves behind some commands and syntax constructions which are replaced by better ones.

Besides learning what’s new it is also important to learn what becomes obsolete.

A program is an animal

Mon, 28 Feb 2022 09:00:00 +0000

When a program is bad because it has duplicate code, it usually becomes shorter once we rewrite it to make it better. But, if its problem is not being properly structured into several classes and methods, if we rewrite it according to the best practices, it will probably end up longer.

Try poligamy

Mon, 21 Feb 2022 09:00:00 +0000

Most ABAP programmers are like swans. They marry ABAP forever and are eternally faithful.

Keep code blocks short

Mon, 07 Feb 2022 09:00:00 +0000

Unfortunately that is not what happens in most of the Z code I have seen in my life as an ABAP programmer. Both IFs and LOOPs tend to grow bigger than anyone can deal with. I recently ran into a LOOP with over 1500 lines.

ABAP inside SQL statements

Mon, 31 Jan 2022 09:01:01 +0000

Did you know that, if you SAP is recent enough, you can use complex ABAP expressions in the middle of SQL commands?

Farewell Wordpress, hello Jamstack

Fri, 21 Jan 2022 09:00:00 +0000

After over 10 year using Wordpress, the world evolved and Abapinho decided it’s time to evolve with it.

if you love your neighbour, avoid CLEAR

Mon, 13 Dec 2021 09:00:59 +0000

Please stop. Too many regressions happen because someone forgets to CLEAR or to not CLEAR a variable.

Don't be so negative

Tue, 30 Nov 2021 09:00:14 +0000

Legibility is very important in all written text. Except, maybe, in concrete poetry.

As a follow up to the previous post, here are a couple of rules to help you deal with the negative in boolean expressions.

IF conditions should be simple to read

Mon, 01 Nov 2021 09:00:45 +0000

Because…why should they be complex to read? It would only make it harder to maintain in the future.

Just because an IF condition is complex doesn’t mean it has to be complicated.

SELECT with CASE

Mon, 25 Oct 2021 13:20:22 +0000

ABAP SQL is becoming more and more interesting and powerful. My latest discovery is the ability to use CASE in SELECT.

I already miss you Sérgio!

Mon, 02 Aug 2021 09:00:55 +0000

My dear friend Sérgio Fraga passed away. Abapinho also belongs to him. Forever. Thank you my friend for everything you were.

The RANGEs double negatives

Mon, 26 Jul 2021 09:00:15 +0000

RANGEs have interesting properties.

SELECT WHERE field IN (*, x)

Mon, 19 Jul 2021 09:00:53 +0000

Ok let’s go slowly on this one.

Picture a scenario in which you have a customizing table with several levels of detail which may or may not be defined:

BUKRS (empresa)
WERKS (plant)
LGORT (depósito)

When one of the fields is empty, we treat it as a wildcard, meaning all values are valid.

Insert without raising exception in internal table with unique key

Mon, 05 Jul 2021 09:00:51 +0000

How many times in your ABAP consultant life did you have to deal with dumps happening as a consequence of a program trying to insert duplicate lines into an internal table defined with a UNIQUE KEY?

Enough.

Manually populate a LISTBOX

Mon, 14 Jun 2021 12:47:10 +0000

In 2012 I wondered why LISTBOX is so rarely used. I taught how to use it with standard data elements, which automatically populate it. Today I’ll teach you how you can populate it yourself.

SELECTION-SCREEN FUNCTION KEY N

Mon, 07 Jun 2021 09:00:33 +0000

There’s so many things you can do on the selection screen. Here’s another one: five buttons in the toolbar.

Send emails to a distribution list

Mon, 31 May 2021 09:00:56 +0000

When you need to send an email to multiple email addresses, the usual approach is to store that list of email addresses in a custom table and then add each one as recipient to the BCS request.

But I recently learned a much nicer way to achieve the same result.

Change selection screen texts without hard coding them

Mon, 24 May 2021 09:00:11 +0000

Even though many ABAP programmers tend to forget this, the less texts you hard code in your program the simpler it will be to translate it.

Here’s a simple but rather obscure way to manipulate selection screen texts while still being able to translate then. This way you can, for example, prefix them with icons.

Call RFC functions AS SEPARATE UNIT

Mon, 17 May 2021 09:00:43 +0000

Imagine that you are calling an RFC function module several times in a row. Maybe you think that each call is completely independent from the others. It is not. The remote function group remains in memory and so does its global data. That global data will be reused on every call. This is probably irrelevant in most cases. But there will be scenarios in which, for some reason, the function module being called is storing data in global variables which will negatively affect the outcome of the subsequent calls.

Local dummy functions named after remote RFC functions

Mon, 10 May 2021 09:00:54 +0000

I recently started working in a new customer and noticed something they do here which I really liked. Whenever they need to call a remote function module by RFC in another SAP system, they create a local function module with the same name and leave it empty, except for a comment explaining that it is a dummy function for that remote function call. Thanks to this simple trick, one can use the where-used tool to find out where it is being called.

Goodbye Evernote, hello Osidian

Thu, 17 Dec 2020 09:00:33 +0000

After 10 years using Evernote, this year I finally started looking for better alternatives. At first Evernote was great. But it never evolved and the world moved on. So many new concepts have appeared: jardins digitais, backlinks, Zettelkasten, Evergreen notes, MOCs, etc. And Evernote is still the same, forcing you to be a note taker instead of a note maker.

Reset SAP note implementation

Thu, 13 Aug 2020 09:00:32 +0000

I remember when SAP notes had to be inserted by hand. Copy paste and pray that no mistake was made. Wild.

I actually remember a project which, for some strange obscure reason, instead of upgrading, decided to implement hundreds and hundreds of notes by hand. They printed them all and made a huge pile of paper and about 10 ABAP consultants spent the whole weekend trying to process the whole pile. We did it. But I have no idea what were the consequences and how many bugs were introduced. Many for sure.

Farewell Evernote, hello Notion

Wed, 15 Jul 2020 11:20:11 +0000

One of the first posts in Abapinho was about Evernote. Well, it was actually about the importance of taking notes. But it suggested Evernote was the best tool for the job.

It feels like yesterday but this was 10 years ago. 10 years using Evernote to take notes. Unfortunately whoever makes Evernote probably stopped taking notes many years ago because, since then, Evernote hardly evolved. Actually, it got worse, especially in its iOS version. After 10 years, they weren’t even able to (try to?) make a decent table editor. They’re either lazy or dumb.

Table lookup without having to deal with CX_SY_ITAB_LINE_NOT_FOUND

Mon, 15 Jun 2020 09:00:08 +0000

Before the modernization of ABAP in 7.40, a table lookup required an auxiliary variable and at least 4 lines of code.

Convert amount to numeric external format

Tue, 02 Jun 2020 09:09:10 +0000

As is well known, SAP stores amounts internally in variables with 2 decimal places. When we want to convert it to its external format, we use WRITE with the CURRENCY option. But WRITE writes to an alphanumeric variable. What if we need to write it to a numeric variable?

Quick Cut and Paste

Tue, 26 May 2020 09:00:36 +0000

I learned yet another small obscure SAPGui functionality. How to speed up copy and paste.

Clean ABAP

Wed, 13 May 2020 12:54:21 +0000

For many years, when confronted with ABAP OO, most ABAPers I talked to, acknowledged that OO is great for most languages but never saw any real advantage in adopting it for ABAP. So they carry on using FORMs, INCLUDEs and CALL FUNCTIONs. The standard SAP code sets the example by trying to make something work while breaking every possible programming best practice.

NOT

Tue, 28 Apr 2020 12:08:03 +0000

No, ABAP will never have the NOT operator.

MOVE-CORRESPONDING between two tables with automatic look up

Mon, 23 Mar 2020 09:00:04 +0000

Abapinho hasn’t been talking a lot about 7.40 because most of the new possibilities have already been widely discussed in other sites and we don’t want to reinvent the wheel.

But, here and there, I find small useful jewels which seem to still be under the radar. This is one of them.

Get unique values of an internal table field

Mon, 16 Mar 2020 09:00:08 +0000

In SQL you can get a list of unique values of a field using DISTINCT. When the data is already in an internal table, before ABAP 7.40 you had to use a LOOP and a COLLECT.

But now that we live in more modern times, there is a simpler and more elegant way to achieve the same with a single command.

How to render CL_GUI_ALV_GRID in background

Mon, 09 Mar 2020 09:00:48 +0000

Someone decided to run an editable ALV (based on CL_GUI_ALV_GRID) in background. It dumped. The solution is simple but not that obvious.

Use CL_GUI_ALV_GRID without having to create a screen

Mon, 02 Mar 2020 09:00:14 +0000

Nowadays I rarely use CL_GUI_ALV_GRID because SALV is so much better. But when I am asked to make an editable ALV I still use it. Until very recently, I thought that, in order to use it, I needed a screen with a container. And because I’m using ABAP OO, I’d need a function group to host it and a function module to call it. Painful.

How to resize an ALV grid to fill the whole window

Mon, 10 Feb 2020 13:22:15 +0000

Sometimes the simplest things take the longest time to do. For instance, we recently needed an ALV grid to automatically resize to fill the whole window. But how? But how? But how?

All SAP demo code under the same roof

Thu, 23 Jan 2020 09:00:03 +0000

When I was a little boy, back in the 80’s, I had to type LOAD "" and then wait for several minutes staring at stripes in a TV and listening to strange noises before a ZX Spectrum game was ready to be played. Many years later, when I already had a PC, I found an emulator which had a menu with hundreds of ZX Spectrum games. I just had to pick one from the list and start playing immediately.

I started using " instead of * for comments

Wed, 15 Jan 2020 09:00:18 +0000

I have always used * to comment my code. I only used " for pseudo-comments or to leave small comment at the end of a line.

But I recently learned that using " makes much more sense.

abapBlame - My new open source project

Mon, 16 Dec 2019 10:53:08 +0000

ABAP’s versioning system is terribly bad. Besides all its faults, it doesn’t provide an easy way to determine who did what and when. Git, which is a decent versioning tool, let’s you do this through its git-blame command.

Due to this, many ABAP programmers got used to sign the code with their name and date every time they add, delete or modify lines in a program. And the more that program is modified, the more difficult it becomes to read it and understand what’s there.

The simplest route to go from SELECT to RANGE

Wed, 13 Nov 2019 10:21:31 +0000

Today we’ll try to optimize the code to convert a SELECT into a RANGE

It's now so simple to convert a MESSAGE into an EXCEPTION

Mon, 04 Nov 2019 10:30:44 +0000

Some years agor I showed how to convert a normal MESSAGE into a typified exception. Meanwhile ABAP evolved a lot and now, since version 7.40, that complex solution is no longer needed.

Tree of Z packages - A modest proposal

Wed, 23 Oct 2019 09:00:46 +0000

If you regularly read Abapinho you probably know by now that I can’t live without ABAP Package Concept. Nowadays the first thing I do when starting a new development is creating an encapsulated package to hold all its objects (in the most complex scenarios, I create it as a main package and then create multiple child sub-packages).

I lay here a modest proposal (unlike the original one, mine is not sarcastic) to help organize thing a bit at system level.

Show internal table content on an ALV

Mon, 30 Sep 2019 09:00:54 +0000

I don’t know for how long has this been available but I just now found out about it. In the debugger it is, after all, super easy to see the content of an internal table in an ALV.

Magical shortcuts to menus

Tue, 10 Sep 2019 09:00:02 +0000

If you, who are reading this, believe that everything written in Abapinho is literally true, what I’m about to tell you will be a disappointment: when I said magical I didn’t mean that it was supernatural. It is just a nicer way of saying it is surprising and unexpected. I took this liberty just as you’d say “I could kill for a glass of water” knowing that you would never do it. Having made this clear, let’s continue.

Shortcut to save list local file

Wed, 04 Sep 2019 09:00:54 +0000

SAP is full of hidden corners rarely visited. Abapinho is happy to shed some light on them.

The command %pc is equivalent to the menu option System/List/Save/Local file:

IF without IS INITIAL in boolean methods

Tue, 27 Aug 2019 09:00:07 +0000

My current client’s system is finally being upgraded to 7.50 and, after all these years stuck with the old ABAP, I am now finally able to enjoy the wonders introduced in 7.40.

There are dozens of these wonders and I don’t intend to start making a post on all of them as there is already so much quality information on most of them. Besides, Abapinho always tries to write about something new or, at least, not very known.

But this simple functionality, although not that extraordinary, pleases me: you no longer need to add IS INITIAL in an IF command when the condition is a method returning a boolean.

SAAB activation variants

Thu, 25 Jul 2019 09:00:00 +0000

Some time ago we spoke about SAAB and its advantages as a tool to analyse, debug and find problems in our code. In that article we didn’t explore an important aspect of it: Activation variants.

Implicit enhancements in data structures

Mon, 13 May 2019 09:00:00 +0000

We have all used implicit enhancements to add code to the beginning or end of a standard function, form or method. But you may not know that it can also be used to add fields to data structures, whether they’re declared as TYPES or directly as DATA.

Save XML data in an ST (Simple Transformation)

Mon, 01 Apr 2019 09:00:59 +0000

Some days ago I was using an ST (Simple Transformation) and thought that, even though its job is to convert an input into an output, it is can be used to store XML data.

Let’s asy we have the following XML:

 <cocktails>
 <cocktail id=&quot;gt&quot; nome=&quot;Gin Tonic&quot;/>
 <cocktail id=&quot;ws&quot; nome=&quot;Whiskey Sour&quot;/>
 <cocktail id=&quot;cl&quot; nome=&quot;Campari Laranja&quot;/>
 </cocktails>

When code smells

Mon, 25 Feb 2019 09:00:12 +0000

It happens very often that, while programming, I smell something strange. It’s usually hard to identify it right away. It usually starts like a faint fragrance. But, as I become more aware of it, eventually it starts stinking and I understand where it comes from. Even then it is not immediately clear why that particular thing smells bad.

You don't encapsulate for it to be reused

Mon, 18 Feb 2019 09:00:18 +0000

Since 1998, I hear some ABAPer colleagues saying that it’s not worth encapsulating a particular piece of code in a function or method because it will never be reused again. And then they go to SE38 and create yet another report full of includes.

The idea that you should encapsulate your code for it to be reused by you or by others is one of the biggest misunderstandings of the history of our planet.

Refactoring: Extract method

Wed, 02 Jan 2019 09:00:23 +0000

In SAP’s world, ABAP code will forever stay wherever you leave it.

On one given day, Manuel did something badly because he was on a rush or didn’t know any better. One year later António is asked to make a small change to it. António spots Manuel’s mess but he doesn’t improve it because, for some reasons, in SAP, changing something which is working, even if it’s badly implemented, is a tabu. Instead, António will add his code to the existing one and forget about it.

This attitude, when adopted by everyone, contributes to an inevitable erosion of the system’s code which, some years later, becomes unmanageable. And still, that’s the rule.

The way I see it, this is wrong and goes against the customer’s best interests. Actually, even if the customer doesn’t want me to modify old code because it’s working… I still do it. Who is he to tell me how to program?

A comment on comments

Mon, 26 Nov 2018 09:00:19 +0000

We learn in school that all code should have comments. Then, in real life, we find that not everyone was paying attention to what was said in school. As a consequence, most code is obscure and without proper comments.

I was always careful to comment every relevant step of my code, specially the parts which are obscure or not self-explanatory.

But since I recently read Uncle Bob’s Clean Code , my opinion on this changed. Today I believe that the less comments the better. And yet, I don’t see this as contradictory to what I used to think.

The multiple clocks of your SAP system

Mon, 22 Oct 2018 09:00:08 +0000

Even though you look at an SAP system as a whole, it is composed by several distinct and interconnected parts. There is a small standard program which checks if each part’s clock is correct and synchronised.

It probably won’t be of much use for your daily work. Still, it’s an interesting curiosity.

ABAP, the lobotomizer

Mon, 15 Oct 2018 09:27:05 +0000

João studies Computer Science at his College where he learns Java, polymorphism, encapsulation and a lot of other programming techniques and best practices. When he graduates, he decides to join a company to work in SAP. At the introduction training which his new company offers, the first thing he learns is how to make a program in ABAP. Here’s how they teach it:

_“Go to transaction SE38, create program ZJOAO and then create includes ZJOAO_TOP, ZJOAO_FRM and ZJOAO_SEL. You declare all variables in _TOP, the selection screen you put in _SEL and all the FORMS must go into FRM. Then write START-OF-SELECTION and under that put all the SELECTs and finally write END-OF-SELECTION and there you show the results in an ALV. It’s that simple. Welcome to ABAP.”

Inject ABAP commands into a productive system

Mon, 08 Oct 2018 09:00:50 +0000

The view below shows how simple it is to create the conditions to inject ABAP commands into programs in a productive system. I considered whether to publish this. But, as it already happened in the past, I believe it is better for this to be known because it is very important for system administrators to be aware of this so they can protect their systems against this threat. Thank you Ricardo Monteiro for the tip.

Transport a local table with its maintenance screens

Mon, 01 Oct 2018 12:47:47 +0000

Some time ago you created a table and its maintenance screens as local objects.

When, later, you regret it and decide to transport the table, how will you be able to also transport the maintenance screens?

Transporting the maintenance screens function group together with the table is not enough.

Test a sequence of function modules in SE37

Mon, 09 Jul 2018 09:00:17 +0000

I was sure I had already posted about this before but I can’t find it so here it goes (again?).

Some function modules save global data which must then be used by another function module belonging to the same function group. So, if you need to test them, they must run in sequence inside the same transaction.

Everybody knows you can use SE37 to test a function module. What few people know is that you can also use SE37 to test a sequence of function modules inside the same transaction. Those who don’t know this end up creating a small program to call those functions in sequence and that’s also ok. But here’s how you can avoid that.

Test function module with data loaded from a file

Mon, 04 Jun 2018 09:00:33 +0000

Transaction SE37 lets you test function modules. Sometimes these function modules use tables. And sometimes you need to load these tables with a lot of data records. But the only way to do it is manually. Or maybe not…

Here’s a trick to do it using a file.

Have extra control over your selection screen

Mon, 12 Mar 2018 09:00:08 +0000

The PARAMETERS and SELECT-OPTIONS already have some configuration options. But sometimes you need more control, more customising. Interestingly, although it’s not simple nor obvious, it can be done through a standard function module.

Debug on a user without debug permissions

Mon, 05 Mar 2018 09:00:48 +0000

In a well protected system, normal users don’t have debug permissions. Very often, this makes it harder for ABAP programmers to help solve the users’ problems, not being able to debug directly in their session.

But there is a legit, albeit obscure, work-around for this problem.

Edit standard programs without a key

Mon, 12 Feb 2018 09:00:22 +0000

Here we are again facing a dilemma: hide something because it is dangerous and someone can do bad things using this information or teach it because it would be condescending to presume the readers are not responsible enough to know it. Dictatorships usually go for the first: burning books, censorship, etc. Abapinho like to believe that its readers are responsible people and deserve the right to know.

Thus, here it is. No, it’s not a user manual on how to enrich uranium nor a formula for homemade nitroglycerin. But it’s something similar: a trick that allows you to change standard objects without the need for a key.

Edit transport requests even if they don't let you

Mon, 22 Jan 2018 09:00:15 +0000

As we all know, system adminstrators are very bad, cold blooded and cruel people. To prove it you just need to read the Bastard Operator from Hell.

We, ABAP programmers, are hopeless victims in the hands of these evil creatures.

But not always do we have to be smashed under their hairy fingers.

Show values in SE16N without conversion exit

Mon, 11 Dec 2017 09:00:35 +0000

By default SE16N always shows the values in the external format, applying the conversion exit to all of them. Until recently, I used to go the ancient SE17 whenever I needed to see them in their internal format. But Rui Nunes told me how to do it in SE16N.

Serialization - Clone Dolly in ABAP

Mon, 30 Oct 2017 09:00:20 +0000

This article was written by José Vília:

The Dolly sheep was alive in ABAP and I didn’t know about it.

Having created a class instance, I’d like to share it with another totally independent program to use it as if the instance had been created there.

It’s an ABAP Dolly sheep factory we’re talking about here, people. Serialization in the ABAP world.

Abracadabra reveals secret parameter

Mon, 23 Oct 2017 09:00:29 +0000

Here’s a not very orthodox wat to deal with a report’s selection screen. Sometimes you may need to have a special parameter which you prefer to hide from normal users but still need access to. Example: a flag to activate a debug/trace mode. I’ll show you how you can do this by just typing the magic word, ABRACADABRA. It goes like this: DATA: unhide_parameters TYPE flag. PARAMETERS: p_debug AS CHECKBOX. AT SELECTION-SCREEN.

ALV Grid built in error protocol

Mon, 11 Sep 2017 09:00:20 +0000

We’re all lazy. It’s just human. Programmers are human. We’re often lazy when it comes to the way we program something. And usually being lazy when making a program will result in someone else having more work when maintaining it.

Let he who is free of laziness throw the first rock.

I won’t!

PlantUML - Finally UML became simple to use

Tue, 05 Sep 2017 09:00:59 +0000

Foreword

When I say that I like to use UML class diagrams to document my code, people think I’m crazy.

Introduction

The UML has gained a bad reputation because people think that, first you make the classes diagram in UML and only then write the program. But that was in 1996, when you the good practices said the first thing to do was the whole technical spec, even if no one really did it.

Nowadays, fortunately, we are no longer ashamed to say that the very act of programming is already in itself a way of drawing.

Classe para garantir segurança em programação dinâmica

Wed, 26 Jul 2017 09:00:33 +0000

I recently found a program which was generating an SQL statement by concatenating several variables with fixed SQL parts. But, either by not paying attention or simple ignorance, the person who did it, thought it would make sense to associate a text-symbol to each of these variables with. Something like this:

SALV consistency report

Tue, 18 Jul 2017 09:00:08 +0000

Sometimes a SALV has inconsistencies which can go unnoticed. For example, if its structure has an amount field which doesn’t have an associated currency field:

Go into a transaction skipping its selection screen

Wed, 12 Jul 2017 09:00:53 +0000

Once again SAPGui surprises me with yet another obscure shortcut I didn’t know about. Let’s use the customer display transaction XD03 as an example: Go into the transaction’s selection screen with /NXD03 Fill in the customer number an press ENTER to display its details Do whatever it is you want to do there and get out of it Suddenly… you remember that you needed to do something else there Instead of /NXD03 type /*XD03

Copy a Code Inspector variant to another system

Mon, 08 May 2017 09:00:09 +0000

In my current customer, I have three development systems. There used to be only one. And that’s where I customized and fine tuned the Code Inspector_ variant I use to run Abap Test Cockpit. When the other two appeared, before manually copying the variant into them, I decided to investigate a little bit. Much to my surprise, I found in GitHun project upDOWNci which does exactly what I needed: export and import Code Inspector Now, copying the variant was a piece of cake.

Physical vs logical folders

Mon, 20 Mar 2017 09:00:30 +0000

If in your report called APP1 you need to save a file in a server folder (ex.: /export/app1/) and you don’t want it to be a selection screen parameter, how do you do it?

Automatically close the doors you open

Mon, 13 Mar 2017 09:00:21 +0000

You’re in the editor. You type ( or [ or { or ’ and SAP is dumb and doesn’t close it right away like a proper IDE would. Well, Click on the lower right corner icon which gives you access to the SAPGui options where you configure code templates. In the formatting option, activate Enable Auto Brackets and voilá, SAP will now automatically close any doors you open. I don’t see why this isn’t set by default.

ABAP used to like inverting dates

Mon, 27 Feb 2017 09:00:40 +0000

Every day I learn something new in ABAP. Sometimes I’d rather not learn them. Like this one.

Table T056P has a date field. While SELECTing this table using the date as criteria I couldn’t get any result even though the code seemed correct. Using SE16N I found that the date range was also not working as expected: it would only should results if the final date was put in the LOW field and the initial date in the HIGH. Bizarre.

The transaction who wanted to call another and couldn't

Mon, 06 Feb 2017 09:00:24 +0000

John created transaction ZFB01 and associated it with program ZFB01 which, after doing some stuff, does a CALL TRANSACTION on FB01. Then came his friend Mike and ran transaction ZFB01.

He managed to start running it because he had permissions to do it. But half way through he got an error because he doesn’t have permissions to run transaction FB01.

Both John and Mike knew that the system administrators would never ever give Mike permission to run FB01.

ASSERT vs Exception

Mon, 23 Jan 2017 09:00:56 +0000

If you read Abapinho you already know how much I like exception classes. But this is not the only ABAP mechanism for dealing with errors.

There is another one, called ASSERT, which should be used more often.

Get the deepest text of chained exceptions

Mon, 16 Jan 2017 10:34:04 +0000

If you’re not already using ABAP Objects you’re chicken.

If you use them, I do hope you’re following the best practice of using class exceptions.

And if you’re using class exceptions you better understand the best way of using them, particularly the advantages of chaining them.

This said, here’s what brings us here today. In the post about chained exceptions I showed a way to get the text of the deepest exception in the chain by using a WHILE loop:

How to not screw up when returning a REF TO DATA

Mon, 02 Jan 2017 09:00:26 +0000

I’ve been using more and more references in ABAP.

I used to use REF TO only for classes but I’ve been finding more and more advantages in using them for other data types. But, just like in C++, care must be used when dealing with data references. Things can easily go very wrong.

In this article, I’ll try to show you how to use and how not to use REF TO DATA. Let’s start by an example of how not to do it.

The curious case of the partially protected structure

Mon, 26 Dec 2016 09:00:10 +0000

The other day I was trying (and failing) to modify a line of a SORTED TABLE.

Weird things happen when you pass SY-TABIX as a parameter

Mon, 19 Dec 2016 09:00:47 +0000

The other day a very strange thing happened to me. I was sending SY-TABIX as a parameter into a method. Before the call it contained 1 but, once inside, the parameter’s value was 0. Weird. o_thingalizer->very_strange_thing(sy-tabix). I was hearing “Why?! Why?!” repeatedly inside my head. But suddenly I understood it! When you send some field of the SYST as a by parameter you have to pass it by value and not by reference.

Convert class exception to BAPIRET2

Mon, 12 Dec 2016 09:00:06 +0000

Some time ago I wrote an article explaining a way to automatically convert classic exceptions to exception classes. Today I use this technique in almost all the exception classes that I create (and I’ve even improved it, but I’ll leave that for another post).

This tip explains the exact opposite.

Ignore indentions when comparing version

Mon, 05 Dec 2016 09:00:31 +0000

Sometimes, when comparing versions, several differences show up even when we did not make changes to the code. These differences may simply be a consequence of a Pretty Printer that altered code indentations. This makes comparing the versions confusing. But ABAP Workbench lets you configure the diff tool to ignore indentations and even comments. Just press F5 while there or go to the “Display Format> Settings” menu and adapt it to your needs:

Use a Standadrd GUI status without copying it

Mon, 28 Nov 2016 09:00:02 +0000

When you want to use CL_GUI_ALV_GRID in a CONTAINER you must copy a standard Status GUI from another program. For example, the GUI Status “STANDARD” of the function group SALV. And then, in the screen’s PAI you do:

SET PF-STATUS ‘STANDARD’.

And thus the little standard buttons show up on your screen.

ABAP popular saying

Tue, 22 Nov 2016 14:09:20 +0000

Don’t put off until tomorrow what you can do SY-DATUM.

Create templates in SE80 by dragging stuff into the code

Mon, 14 Nov 2016 09:00:26 +0000

While coding, it’s always good to have ways to speed up what we’re doing. A good one is automatic generation of templates for function and method calls.

I know 3 ways to achieve this.

Local $PACKAGES

Mon, 07 Nov 2016 09:00:37 +0000

Any object created in SAP must belong to a package.

Until recently, whenever I needed to create a program for a quick test I’d put it in the $TMP package. This way I was sure that it would never be transported to another system.

But sometimes I have the need to create stuff in the development system which, even though it should never be transported, should stay there forever. For example, development tools like ZSAPLINK and abapGit. But if we put everything under package $TMP it will soon be a big mess.

DDIC structure key

Wed, 02 Nov 2016 09:00:39 +0000

Today when I want to create a SALV I always create a DDIC structure with the data elements already set to show the texts I need. This avoids the need for code to manipulate the field catalog.

Find everything at once

Mon, 24 Oct 2016 09:00:11 +0000

The ABAP editor is full of functionalities yet to be discovered.

When I do CTRL-F to search for text, the option I usually choose is “Find next”.

APPEND STRUCTURES do more stuff than I thought

Mon, 17 Oct 2016 09:00:06 +0000

During all my ABAPian life I was convinced that APPEND STRUCTURES had one single purpose: to add new extra fields to an existing standard table.

But I recently learned that they let you do two more things after all:

INSERT wa INTO itbl REFERENCE INTO ref. Bug?

Mon, 03 Oct 2016 09:00:43 +0000

Every day I use more reference variables in ABAP. First I used REF TO just for classes but, as I become more familiarized with its advantages, I start using them more and more for data structures, instead of field-symbols.

But I recently found na unfortunate behavior of the following command:

INSERT wa INTO itbl REFERENCE INTO ref.

Let me give you some context before I complain about it.

We should be accountable for the crap we make

Mon, 19 Sep 2016 09:00:33 +0000

If, when building a bridge, a civil engineer makes a mistake in one of the calculations, the bridge falls. But the bridge won’t fall alone. Most probably that engineer will also fall with it. He is accountable for what he did because he must sign his projects.

ABAP programmers don’t have that kind of problems.

Search form methods, attributes, types, events, etc

Wed, 24 Aug 2016 09:00:51 +0000

You remember having written a method some years ago which you need now. You know it had the word MALMEQUER somewhere in its name. But what now? How will you find it? You could use transaction SE24 to look at every class you worked on since then. But that would probably keep you busy for ages. Don’t do that. Try using transaction SE84 instead:

Yet another way to see a method's parameters

Mon, 01 Aug 2016 09:00:26 +0000

Let’s say you want to call a method for which you don’t know the parameters. What do you do?

You used to have to use the “pattern” button. Or open the class in a new window to look at the method’s parameters. But then the ABAP Editor evolved and we got auto-complete which made everything much more easy.

But there is yet another way.

ABAP Code PushDown in HANA

Mon, 25 Jul 2016 09:00:10 +0000

[Guest post by Artur Moreira]

From ABAP version 7.4, SAP introduced the code pushdown concept, which means using more database for calculations (data aggregation, sums and previous calculations).

Incremental search

Mon, 18 Jul 2016 09:00:21 +0000

When I want to search for a word in an ABAP program I usually press CTRL-F to use the normal search feature of the ABAP editor. I enter the word I want to find and then press “NEXT” to look for it.

But there is another way. And it’s not better nor worse. Just different: the incremental search.

Pass internal tables by value is good

Mon, 11 Jul 2016 09:00:21 +0000

When a method returns a value as a RETURNING parameter this is always done by value and not by reference. Several of my methods return internal tables, some of them quite large. It always worried me the idea that, since it’s being passed by value, ABAP would be returning a copy of the internal table, impacting both performance and the program’s used memory.

Fortunately, I recently learned that this is not a problem.

INSERT dbtab ACCEPTING DUPLICATE KEYS

Thu, 07 Jul 2016 09:00:10 +0000

When you try to insert a record with a key which already exists in the table the program dumps. This, in some cases, is not desirable because, even if you don’t care, it forces you to check if the keys already exist before trying to insert then. But ABAP has a solution for these situations: INSERT dbtab FROM TABLE itab [ACCEPTING DUPLICATE KEYS]. Don’t worry because this will not violate the first law of thermodynamics: the duplicate records are not inserted.

Export and import the ABAP Workbench settings

Mon, 13 Jun 2016 09:00:16 +0000

Sometimes a thing is right under your nose and your still don’t see it.

At my current client I daily work with a lot of different systems. When I make a change in a setting of one system, either because I’m lazy or because I forget, I end up not applying it to all the others.

But there is a simple way to copy all the ABAP Workbench settings at once from one system to the other.

Use the Split Screen Editor in the version comparison

Mon, 06 Jun 2016 09:00:57 +0000

By default, the ABAP version comparison tool is horrible. It displays both versions in a single column and, even though the differences are highlighted, it’s awfully confusing. But it doesn’t have to be this way. Press the “settings” button at the top and you’ll find that there are 3 different display modes (besides some other nice options): one-column, two-columns and, surprise, the Split Screen Editor. This is probably the option you’ll want to choose since it’s the most powerful.

Spot the differences with SE39

Mon, 30 May 2016 09:00:21 +0000

Earlier today I was doing a QC review to a new program named ZSDFAKSPE with almost 1000 lines and no comment whatsoever. An obvious clone of a standard program called SDFAKSPE.

So I decided to use the Spli-screen editor, found in transaction SE39. Having entered both programs I could then compare them side-by-side.

Source-code based class development

Mon, 23 May 2016 11:08:44 +0000

Being used to develop in Java and C++, the way transaction SE24 forces you to navigate between each of its parts and the fact that every method has its own include was very confusing to me when I first started using it. Why does SAP always have to make things so complicated? I eventually got used to it. At some point in time SE24 introduced the option source-code based which shows the class and all its methods in a single text.

Jump to your last change

Wed, 18 May 2016 15:03:12 +0000

Imagine that you’re editing one of those ancient programs with thousands of lines (yes because today you know that it’s wrong not to modularize (it’s a sin really) your methods (yes because today you always use methods) don’t have more than 200 lines).

I call you and you call me

Mon, 09 May 2016 18:36:30 +0000

You you call a function via RFC you need to provide the RFC DESTINATION for the remote system:

CALL FUNCTION ‘ZSNEEZED’
 DESTINATION ’sistema_longe_daqui’.

What if, for some reason, the function running in the remote system needs to call a function in the original system? How would you do it?

Undo in debugger layout

Mon, 02 May 2016 09:00:56 +0000

Although a substantial part of an ABAP programmer time is spent debugging code, most programmers I know don’t invest much in getting to know the ABAP debugger. Maybe because they spent too many years working with its previous version which was truly archaic and worthless. But the new one can do much more than you usually ask of it. And Abapinho intends to teach you how.

Today I’ll teach you just a simple key.

Debugging with baby steps

Mon, 25 Apr 2016 09:00:50 +0000

When you debug you use F5 key to move to the next statement (or go inside a sub-routine). But imagine an IF with multiple conditions:

IF A = 1 AND B = 2 AND C = 3.
 WRITE 'I like the word glauc'.
ENDIF.

When you debug through that IF using F5 and one of the expressions is false you’ll step out of the IF without knowing which of the three was false.

But the new debugger has a new very neat functionality which can help you to better understand what happened there.

SAP helps you translate to any language

Mon, 18 Apr 2016 09:00:16 +0000

Every once in a while I find yet another hidden SAP virtue. I just found out that there is a transaction which, for a given word in a given language, will help you translate it to another language by showing you which other translations already exist for that same word. How cool is that? Ok, it’s not Google Translate, but it’s a nice help. Oh, I almost forgot. The transaction is called STERM.

Native SQL

Mon, 28 Mar 2016 09:00:01 +0000

Sometimes ABAP SQL doesn’t allow you to do something you’d be able to do using the database’s native SQL. It can still be done.

GROUP BY in LOOPs on internal tables

Mon, 21 Mar 2016 09:00:57 +0000

We’ve all sorted internal tables to use AT NEW on a LOOP. But starting from 7.40, we can use GROUP BY on LOOPs.

The ability to group by values based on expressions or even methods is great.

The grouping is done on the first LOOP and can be processed afterwards. Try running the code below and I bet you’ll be as impressed as I was.

Fix bug in SAP standard using an implicit enhancement

Mon, 14 Mar 2016 09:00:57 +0000

You just found a bug in a standard FORM (or FM or METHDO): FORM EQUAL_VALUE CHANGING W_DATE TYPE SYDATUM. W_DATE = SY-DATUM - 1. ENDFORM. You report the error to SAP but you know it will take them several days, weeks or months to publish a correction. And you need it corrected right now. You decide to act. So you use the implicit enhancement at the start of the FORM to replace the standard code with your own (just until the correction arrives, of course):

Can you really do it right the first time?

Mon, 07 Mar 2016 09:00:13 +0000

Checkpoints is a very powerful ABAP framework which almost nobody uses. Why? Probably for the same reason hardly anyone listens to Sun Ra and knows that Frank Zappa has 102 albums. Because, even though really good, it’s obscure and not commercial. Checkpoints are, indeed, really good and not commercial. But they should be more like Mozart and the Beach Boys which are both good and commercial.

STA Ticket System improve SAP incident handling times

Mon, 29 Feb 2016 09:00:53 +0000

Today we have a guest, Tamás Holics. He owns STA Consulting, a Hungarian company which has created 2 very interesting SAP products. In this article Tamás presents the STA Ticket System.

The problem

A lot of time is wasted in SAP software testing and maintenance processes due to incomplete or incorrect error reports from users and testers. Support people (analysts, developers) usually have to ask for more information about the error. This takes a lot of valuable working time from both the reporters of the error and support people. Solving the problem is often blocked until every information is available.

The rot is noble after all

Mon, 22 Feb 2016 09:00:45 +0000

For many years I’ve been complaining about how backward ABAP development ecosystem is and how long it takes to evolve. Every time he heard me saying it a good friend of mine would wisely advise me to never bite the hand that feeds you.

But how can a man not speak out?

Software design patterns in ABAP

Mon, 15 Feb 2016 09:00:26 +0000

We are constantly learning. But once in a while we learn something which is a leap forward forcing us to look in a new way to everything we do. The last time this had happened was when I started using OO in ABAP. OO was not new to me as I had already used it extensively in Java, C#, C++, etc. But to finally be able to apply these precious concepts on my daily job was a relief and a big improvement in the quality, flexibility and speed of my work.

Disable value history for a single field

Mon, 08 Feb 2016 09:00:08 +0000

SapGUI usually keeps a history of the last values entered on each field. This is usually a good thing. But you may very well not want it to happen (in case you’re entering pornographic values in a specific field for example). You could always turn it off globally in the SapGUI settings.

But what if you just want to disable it in one particular field? Abapinho tells you how to do it.

Add parameters to standard methods and functions

Mon, 01 Feb 2016 09:00:50 +0000

We are all aware of SAP implicit enhancements which allow you to add code to the top or bottom of any block of standard code (methods, functions, etc). We’ve all used it to make a change to a BAPI or other standard piece of code.

But only recently did I find that you can also use these implicit enhancements to add parameters to standard methods and functions.

ZTOAD - Editor de SQL

Mon, 01 Feb 2016 09:00:10 +0000

Toad is a very famous SQL tool which allows you to build and execute SQL queries in an easy and interactive way. And now, thanks to Mr. Sébastien HERMANN, SAP has a simplified version of this wonderful tool. I’ll let him explain. Thank you Sérgio Fraga for spotting this. Greetings from Abapinho.

Internal table secondary indexes

Mon, 25 Jan 2016 09:00:47 +0000

This is how internal tables used to be declared:

DATA: itbl TYPE TABLE OF bkpf.

Program the program programming

Mon, 18 Jan 2016 09:00:47 +0000

One of the few things that separates us humans from all the other animals is our ability to think about thoughts.

A sparrow may think I’m scared, I’ll say chirp chirp chirp and, as a direct consequence, whoever stands close to it will hear chirp chirp chirp.

Use the "where used" tool in a program

Mon, 11 Jan 2016 09:00:11 +0000

The “where used” tool is very dear to any ABAP developer. Through it one can find out where a given object is used. Doesn’t look like much but we all know how important this is.

Class CL_GUI_FRONTEND_SERVICES

Mon, 04 Jan 2016 09:00:43 +0000

Class CL_GUI_FRONTEND_SERVICES is commonly used to upload and download files from and to the user’s local computer. But it can do many more good things. For example:

SAP can take selfies!

Mon, 28 Dec 2015 09:00:35 +0000

I just found out that SAP can take selfies. I still don’t see why one would need it. But that’s understandable because I never really understood the need for selfies anyway.

Here’s how SAP can take a selfie:

Do you know the ASCII code for CR_LF and its buddies?

Mon, 21 Dec 2015 09:00:56 +0000

I don’t.

And I don’t want to. Why waste memory on stuff like that?

And I don’t need to because ABAP has a class just for that.

SELECT from a set of known values

Mon, 14 Dec 2015 09:00:36 +0000

Someone asks you to select records based on a criteria for which you’ll have a small set of known values which you’re told will never change. Did you know you can do it directly in the SELECT?

You can save variants in SE16N

Mon, 07 Dec 2015 09:00:18 +0000

And that’s it really. That’s the whole tip right there at the title. This has always been right under your nose but you probably never thought about it: you can save variants in SE16N. And they can even be user-specific. So useful and so little known. Thank you Sérgio Fraga for the tip. Thank you Cloudtail for the photo. Greetings from Abapinho.

Limitar execução em background ou foreground

Mon, 30 Nov 2015 09:00:36 +0000

You’ve developed a report which you know will take over 12 hours to run. So you don’t want anyone to try to run it in foreground. I’ll show you a way to make sure it doesn’t happen.

How to sabotage standard texts

Mon, 23 Nov 2015 09:00:43 +0000

Some times I don’t like the names SAP gave to things. So I change them.

For example, one day I was very angry and thought all customers were parasites.

So I did the following:

Formating variables when concatenating strings using pipes

Mon, 16 Nov 2015 09:00:22 +0000

Pipes are the new trend when it comes to manipulating strings:

str = |Hi { sy-uname }, | &
 |today's date is { sy-datum }.|.

Besides looking cool, it’s way more practical than using the dreaded CONCATENATE.

But I only recently found out that you can directly apply formatting to the variables:

Is the GUI available?

Mon, 09 Nov 2015 09:00:41 +0000

To check if a program is running in background usually one takes a peek at SY-BATCH. SY-BINPT can also be used to check if the background program is a BDC session. You usually check one of these.

There is a similar but not exactly equal question, though. How do you ask if the GUI is available? Most times both questions will have the same answer. But not always.

It’s like saying the Sun can be seen during the day while the Moon can be seen during the night. If the sky is cloudy you won’t be seeing them.

How to avoid timeout when running a program

Mon, 02 Nov 2015 09:00:52 +0000

Usually SAP systems have a predefined time limit for running a program interactively. If the program takes longer to run than that you’ll get a runtime execution error. A dump.

In ABAP's name, I baptize you

Mon, 26 Oct 2015 09:00:05 +0000

When we learn ABAP, we are taught a series of rules on how to name variables. Not everyone uses the same rules but, still, some strict rules are shared between many people:

Local variables must start with L: L_BUKRS;
Global variables must start with G: G_MODE;
Internal tables must have T_: LT_MARA;
Structures must have S_: LS_MARA;
Object references must have R_: R_CUSTOMER;
input parameters must start with I, output with O, changing with C and returning with R.
And the most stupid of all, field-symbols must start with FS_: <FS_MARA>.

In the early XXI century those rules made some sense (except for the field-symbols on, which was, and still is, as stupid as writing ‘pencil’ in all our pencils). Today they don’t make much sense anymore. Let me explain.

Abapinho Dev Tools: Translator

Thu, 22 Oct 2015 14:54:11 +0000

Nuno Morais has developed another very useful tool to help simplify mass translations of most SAP objects. The toold is not for automatic translation between two languages. Instead, it has the following features: Export an Excel file with texts Import an Excel file with texts Copy texts from one language into one or more languages Create a transport order with the changed texts Find object dependencies which lack translations Provides a nicer browsing interface to help on manual translation

Abapinho Dev Tools: Dependencies

Thu, 22 Oct 2015 14:37:19 +0000

Nuno Morais developed a very useful tool which can compare objects between systems and works much better than transaction SREPO. Abapinho will be its official repository. Code in GitHub. Soon, an instruction manual. Until then, go on and try it. If you like it or have any suggestion please leave a comment here. Thank you Nuno for having developed this and for sharing it with the world in Abapinho. Greetings from Abapinho.

Shortcuts for making small and big letters

Mon, 19 Oct 2015 09:00:05 +0000

You may not even know how to program but if you’re able to type fast and know enough keyboard shortcuts everyone will think you’re an expert. In the ABAP editor write the following word: subdermatoglyphic Now try the following shortcuts: CTRL+U: SUBDERMATOGLYPHIC BIG LETTERS! UPPER CASE! CTRL+L: subdermatoglyphic small letters! lower case! CTRL+J: Subdermatoglyphic The First Letter Of Each Word In Upper case! CTRL+K: sUBDERMATOGLYPHIC tHe BiG aRe NoW sMaLl AnD tHe SmAlL ArE nOw BiG!

SE16H - Aggregate data without using Excel

Mon, 12 Oct 2015 09:00:57 +0000

A long time ago transaction SE17 was used to look at database tables content. They quickly felt ashamed and decided to improve it, creating SE16. When ALV was invented, SE16N was released (although until today many people still use SE16, go figure!).

Today I present you SE16H.

CONCATENATE LINES OF itbl

Mon, 05 Oct 2015 09:00:50 +0000

If you want to serialize a set of strings stored in an internal table there are two ways to do it. One is dull, the other one is full of style.

Modify one field in all lines of an internal table

Mon, 31 Aug 2015 09:00:25 +0000

What I’m about to show you is not exactly new. It has even been used in Abapinho before. But since there is still a lot of people out there using LOOP to change a single field of an internal table, I thought it would be worth talking about it.

Bye bye READ TABLE

Mon, 24 Aug 2015 09:00:20 +0000

Pré 7.4: DATA l_idade type i. READ TABLE lt_folk INTO ls_folk WITH KEY name = l_name. l_age = ls_folk-age. Pós 7.4: data(l_age) = lt_folk[ name = l_name ]-age ) Thanks Sérgio Fraga for the tip. Greeetings from Abapinho.

So much new stuff in 7.4, I don't know where to begin

Wed, 19 Aug 2015 09:00:19 +0000

Abapinho will slowly start posting tips specific to AS ABAP 7.4. Slowly because there are still only a few people with access to this version. But there are so many new things to tell that I feel tempted to start posting all of them. ABAP was a flabby middle aged guy with a beer belly. It underwent major plastic surgery and now looks like a lean 20 year old kid who can party until 9am, drink 7 gin tonics and then, before going to bed, do 100 burpees just to sleep better.

Breakpoint in message from inside the debugger

Mon, 10 Aug 2015 09:00:09 +0000

You’re in the middle of a debug and want it to stop at a specific message.

What to do?

Multiple OR selections in SE16N

Mon, 03 Aug 2015 09:00:15 +0000

If you are one of those persons who still uses SE16, this article is not for you. If you keep reading, you might find yet another reason to finally start using SE16N (as if all others were not enough already).

Imagine that you want to select all materials whose name contains “PREGO” and whose type is “FERRAGENS”, and all materials whose name contains “GUARDANAPO” and whose type is “COMIDA”. In other words, “PREGO_NO_PAO” or “GUARDANAPO_PAPEL” won’t be part of the result set. What you want is this:

(MATNR = “PREGO%” AND MTART = “FERR” ) OR (MATNR = “GUARDANAPO%” AND MAKT = “COMI” )

As you know, using SE16N in a regular way (which doesn’t use what I’m about to show you) you would need to execute it twice and manually compare data, because the selection screen does not allow you to make multiple OR selections.

Or does it?

DELETE vs CLEAR vs REFRESH vs FREE

Mon, 27 Jul 2015 09:00:01 +0000

DELETE CLEAR REFRESH FREE

These are different ways of deleting all data from an internal table. They look the same. But they aren’t.

CASE inside a SELECT (available soon)

Mon, 20 Jul 2015 09:00:42 +0000

Get ready because you’ll soon be running into a lot of surprises. ABAP is learning new tricks. Look at this one: CONSTANTS: lc_menina TYPE STRING VALUE ‘GIRL', lc_menino TYPE STRING VALUE ‘BOY’, lc_senhor TYPE STRING VALUE ’GENTLEMAN’, lc_senhora TYPE STRING VALUE ‘LADY’. SELECT nome, CASE WHEN sexo_id = ‘M' AND idade < 18 THEN @lc_menino WHEN sexo_id = ‘F’ AND idade < 18 THEN @lc_menina WHEN sexo_id = ‘M' AND idade >=18 THEN @lc_senhor WHEN sexo_id = ‘F’ AND idade >=18 THEN @lc_senhora END AS titulo FROM zpessoa WHERE pessoa_id = @pessoa_id INTO CORRESPONDING FIELDS OF @lt_pessoas.

Search for notes directly in Google Chrome

Mon, 13 Jul 2015 09:00:20 +0000

Google Chrome has an app for searching SAP notes. It’s called SAP Notes finder. You can install it here. Thank you Fernanda Mirabile and Talita Polanczyk for the tip. Greetings from Abapinho.

Consider converting WRITE reports into ALVs

Mon, 06 Jul 2015 09:00:46 +0000

Reports still writing directly to the screen are very hard to maintain whenever changes to the layout are required. On such occasions, review the code and, if the effort involved is not too big, consider converting it to ALV. Always involve the functional people in this decision.

[:pt]Curso online grátis de depuração[:]

Thu, 25 Jun 2015 09:00:04 +0000

[:pt]O Pedro Lima (responsável pelo OnSAP) fez um curso online grátis a ensinar os rudimentos da depuração em ABAP. Espreitem pois está bem feito e porque estas iniciativas merecem todo o nosso apoio. Tenho a certeza de que o Pedro fará mais cursos se vir que há público interessado. Aqui Nota: o curso é em inglês. O Abapinho saúda-vos [:]

No more english translations

Wed, 24 Jun 2015 18:07:21 +0000

Sadly, Abapinho will not be able to continue posting the English translation of the Portuguese posts. I am sorry to all the readers who don’t speak Portuguese. Abapinho’s main goal has always been to publish ABAP content written in Portuguese. But the possibility of also publishing them in English was a great asset because it allowed us to reach a much wider audience. We were able to do it for several years because the translations were sponsored.

[:pt]CALL FUNCTION com DESTINATION ‘NONE' cria nova LUW[:]

Mon, 22 Jun 2015 09:00:57 +0000

[:pt]Sabias que quando invocas uma função com a opção DESTINATION ‘NONE’ estás a iniciar uma nova LUW? Isto pode parecer apenas uma curiosidade, mas há um caso em que pode fazer toda a diferença: sabes aqueles módulos de função que ao serem chamados uma segunda vez têm um comportamento diferente da primeira vez? Isto acontece porque eles hão-de ter alterado alguma variável global ao grupo de funções. Ora se iniciares uma nova LUW quando chamares a função, o seu grupo de funções é automaticamente inicializado e assim garantes que o comportamento da função é o esperado.

[:pt]Debug de um job[:]

Mon, 15 Jun 2015 09:00:40 +0000

[:pt]Para fazeres debug a um programa que faça parte de um job faz o seguinte:

Converting an exception into an exception

Mon, 01 Jun 2015 09:00:21 +0000

If you’re still not using exception classes, then you’re making a mistake. Cause they are very healthy for your code. They’re not only good nutrients for the system, they also make it lean and less vulnerable to diseases.

There are cases where you still need to deal with the old exceptions. For example, when a function module is invoked.

In this article I am presenting a suggestion that seems a little complex, but it works very well if you need to integrate the old exceptions with exception class in a simple way. And though it is sophisticated, you only need to do it once. Once it’s done, it’s easy to use.

[:pt]Novo livro "UI5 para desenvolvedores SAP/ABAP"[:]

Wed, 27 May 2015 12:00:32 +0000

[:pt]O Flávio Pagoti, do blog ABAP101 publicou um livro em português sobre SAPUI5/OPENUI5. Aqui está o artigo do ABAP101 a anunciar o livro. Lá encontras um link para o comprar. Custa $9,99. A minha principal motivação quando decidi criar o Abapinho foi exactamente combater a gritante falta de conteúdos técnicos de qualidade escritos em português. Hoje as coisas estão um pouco melhores, em particular no mundo do ABAP onde há vários blogs de óptima qualidade.

Teach ABAP to juggle

Mon, 18 May 2015 09:00:13 +0000

What can be done when a night is not enough to complete the daily processes?

Thou shalt modularize, modularize, modularize

Mon, 11 May 2015 11:40:10 +0000

Historically ABAP programs tend to grow very loooong. All programming best practices teach us there is not a single advantage in this approach. If any routine, be it a program, a method, a function or anything else, becomes longer than 200-300 lines, question it and seriously consider refactoring it into several sub-routines. This has the added advantage of potentially increasing code reuse. But the greatest advantage is encapsulation, isolating variables in their local context, instead of having all of them together, resulting in safer and more readable code.

Thou shalt reuse, thou shalt not rewrite

Mon, 04 May 2015 09:00:28 +0000

If the same piece of code is repeated at least once, question yourself why and try to avoid it by creating a reusable routine. If there is more than one SELECT for the same table in a program, make sure you can’t merge them into a single one. Sometimes a smart use of RANGEs to unify parameters can avoid the need for multiple SELECTs. If the same code is used in 2 different programs, don’t repeat the code.

Thou shalt avoid global variables

Mon, 13 Apr 2015 09:00:36 +0000

The more global variables a program has, the most obscure it becomes. Please avoid them. This is a basic rule of good programming and should always be followed. Even if several variables have to be passed by parameter, it takes slightly more effort but yields a much more readable and safer code. Exceptions can be made for simple reports which run around a single internal table, which can be declared globally without compromising clarity.

How to ask if the line exists without seeming fashioned

Mon, 06 Apr 2015 14:08:12 +0000

Long ago, you used the expression “groovy, man”. Later came “great, man”. Then there was “cool”. Today you say “awesome”. It’s important not to get confused and not make a fool of yourself.

And how do you ask an internal table if a line exists exists?

Stop the functions module's error messages

Mon, 30 Mar 2015 09:00:30 +0000

There are standard functions that trigger messages where they shouldn’t. And they shouldn’t because we want to use these functions in non-interactive programs and then, instead of returning the error, an error message is triggered and ruins the whole process.

However, being aware of this problem, SAP has provided a quite elegant (but not well documented) way of solving this problem.

Text search in a WebDynpro

Mon, 23 Mar 2015 09:00:31 +0000

SAP doesn’t know how to do things right the first time. The WebDynpros are a good example of this. It doesn’t even let you do a text search. It’s sad.

Fortunately Sérgio Fraga has found a way, though it’s rather laboured:

It's my birthday!

Thu, 19 Mar 2015 22:24:50 +0000

I’m 6 years old! (Thank you Caleb Prichard for the photo)

Thou shalt always use a predefined structure with ALV

Mon, 16 Mar 2015 09:00:30 +0000

It is common to find an ALV data structure explicitly defined in the code. If this is done, the field catalog has to be manually constructed. If a predefined structure (from DDIC or declared as a TYPE) is used instead, the field catalog can be automatically built. This approach is always better and results in less code, even if the field catalog needs to be adjusted here and there. https://abapinho.com/en/2011/12/automatizar-catalogo-alv/

Thou shalt use TRANSPORTING NO FIELDS

Mon, 09 Mar 2015 09:00:02 +0000

Many times we do READ TABLE itbl or LOOP AT itbl just to do a CHECK SY-SUBRC = 0. In these cases, the actual data read is not needed. For these cases always use TRANSPORTING NO FIELDS. This way is faster and avoids having to declare a target structure.

Debugging an infinite loop already in execution

Mon, 02 Mar 2015 09:00:22 +0000

Imagine you have a program executing an infinite cycle or, at least, a cycle with 70x7 iterations. It is neverending, and you want to know what’s going on there.

In the past you had to go to SM50, select the process and choose from the menu “Administration | Program | Debug”.

But now there is a much easier way.

How many includes is a class made of?

Mon, 23 Feb 2015 09:00:55 +0000

No matter how many times things go around in ABAP, everything ends up in SE38. Even the methods of the ABAP classes are saved in includes.

Sometimes, when there is a dump, it says the problem is, for example, here: CL_MESSAGE_HELPER=============CM001.

Unreleasing a released transport order

Mon, 16 Feb 2015 09:00:51 +0000

You’ve released a transport order because you thought everything was ready. However, one more minor modification was still missing. So now you will have to create a new order and transport both of them. What a drag.

Don’t worry.

Presenting the EGSAP_TECH app

Tue, 10 Feb 2015 10:55:53 +0000

Do you know about the EGSAP_TECH app? It’s a SAP knowledge bank.

Here is a description in the words of its own creators:

SELECT-OPTIONS default behavior

Mon, 09 Feb 2015 09:00:23 +0000

Abapinho received a letter.

Mr. Abapinho,

Everybody knows how to set default values in select options using the DEFAULT keyword. What some people may not know is that one can also set the default option, sign and even if allows for intervals or just fixed values.

Chained exceptions

Mon, 02 Feb 2015 09:00:48 +0000

Today I will teach you how to chain exceptions. It’s a very practical solution to a complicated, not so obvious problem. Let’s start by describing the problem. Imagine you are in the application BANANA. The application is quite complex. It has three modules: BANANA1, BANANA2 and BANANA3. Each one has its exception class ZCX_BANANA1, ZCX_BANANA2 and ZCX_BANANA3. Since the application is in fact well designed, all the exception classes inherit from the same ZCX_BANANA.

Ignore function module exceptions

Mon, 26 Jan 2015 09:00:25 +0000

When calling a function module which returns exceptions you normally give them sequential numbers like this:

CALL FUNCTION 'GO_BUT_PLEASE_COME_BACK'
 EXPORTING
 ali = 'To the moon'
 EXCEPTIONS
 NOT_FOUND = 1
 GOT_LOST = 2
 OTHERS = 3.

But Code Inspector may be configured to report a warning if afterwards you are not careful to add an IF or a CASE to look at SY-SUBRC,

Thou shalt use exception classes

Thu, 22 Jan 2015 09:00:28 +0000

In classes, consider using exceptions classes over the old ones. These have great advantages and, once understood, are simple and allow for simpler code. https://zevolving.com/2011/12/class-based-exception/

Thou shalt use readily translatable explicit literals in programs

Tue, 13 Jan 2015 10:13:48 +0000

In reports, instead of WRITE TEXT-001, use WRITE ‘bla bla bla’(001). This way a default text will always be there and besides the readability of the program is improved. https://abapinho.com/en/2011/11/programas-poliglotas/

Thou shalt use SALV instead of the old ALV functions

Thu, 08 Jan 2015 09:00:37 +0000

SALV classes are more versatile and more recent than the old function modules. So, for new ALVs always use SALV. The only exception is editable ALVs which SALV classes are still very incapable of doing. https://scn.sap.com/docs/DOC-10365 https://scn.sap.com/docs/DOC-10366

Let's concatenate

Mon, 05 Jan 2015 09:00:35 +0000

We start with two variables:

DATA word1 TYPE string.
DATA word2 TYPE string.
DATA: phrase TYPE string.

word1 = ‘this’.
word2 = ‘that’.

And we want to concatenate them adding the word “plus” between them and, of course, separate them by space.

Communication by event between programmes

Mon, 22 Dec 2014 09:00:11 +0000

In Greek mythology, the gods’ most commonly used means of communication with mortals was rape. They would rape for no reason whatsoever.

The closest thing we have to rape in ABAP is the command “SUBMIT”, which is also the most common way of communicating between two programmes.

Write in multiple lines at the same time

Mon, 15 Dec 2014 09:00:42 +0000

The ABAP editor has many curious functionalities. You can even write in multiple lines at the same time.

Where is the boolean?

Wed, 10 Dec 2014 18:12:58 +0000

It’s not.

But they - the people who make and remake the ABAP itself - are trying to mend this unfortunate situation.

Look at this new functionality:

LOOP AT tbl ASSIGNING <line> CASTING

Mon, 01 Dec 2014 09:50:19 +0000

Did you know that you can do a LOOP on an internal table of one type into a structure of a different type?

INNER JOIN vs FOR ALL ENTRIES vs artificial RANGES

Tue, 25 Nov 2014 09:00:13 +0000

Since data operations are much more optimized in the database server than in ABAP, it is always better to use the first as much as possible. FOR ALL ENTRIES should only be used when INNER JOIN doesn’t give us what we need or is not possible (like with BSEG for example). Artificial ranges are also a possible alternative to FOR ALL ENTRIES but be careful not to reach the SQL parser limit.

Thou shalt not use CHECKs directly in user-exits

Mon, 10 Nov 2014 09:00:51 +0000

User-exits (and enhancements) are usually crowded with CHECKs. The tragic consequence is that, if the check fails, nothing else after it will run. Not even the standard code. Always try to correct these. Encapsulating the code inside a routine (ideally a method) is enough to render it harmless.

Block indent

Mon, 03 Nov 2014 09:00:21 +0000

To indent a block of lines do the following:

Thou shalt use LIKE LINE OF itbl

Mon, 20 Oct 2014 10:25:10 +0000

When declaring structures which will receive data from an internal table, instead of declaring its type directly, use LIKE LINE OF. This way not only it becomes clear that they are related but also, if you happen to change the type of the internal table, you won’t have to worry about updating the structure’s type.

Clearing the buffers of an SAP session

Mon, 13 Oct 2014 09:00:25 +0000

I keep learning new transaction commands. Today I learned some which solve a problem which, although rarely, has happened to me in the past.

Did this happen to you? You make a change to a text of a data element you’re using in a table to be edited through SM30. But when you go and edit that table in SM30 the old text is still there. You activate objects, close windows, open windows, no matter what you do, the new text is not shown.

Thou shalt not COMMIT in user-exits

Mon, 29 Sep 2014 09:00:25 +0000

Never do COMMITs inside user-exits. Also, make sure any external routine you call from there doesn’t do any COMMIT either.

Automatic model just using CTRL-SPACE

Mon, 22 Sep 2014 09:00:04 +0000

Of course you already know the “Model” button in the ABAP editor that allows you to automatically add models for function modules, calls for methods and others.

The new editor has now grown a bit (it’s now only 10 years behind Eclipse instead of 20) and it allows you to automatically complete some commands through the CTRL-SPACE shortcut.

Thou shalt consider using SM34 clusters

Thu, 11 Sep 2014 09:00:14 +0000

If a development requires more than one customising table consider grouping their maintenance views under a cluster. This way it will be more intuitive to maintain them. This makes even more sense if one depends on the other since in the cluster definition these relations can be explicitly defined. Example: Como encavalitar tabelas (portuguese)

Thou shalt not SELECT *

Thu, 04 Sep 2014 11:25:03 +0000

Always try to select only the fields you’ll need. Selecting others is a waste of resources. Exception made for the use of FM *_SINGLE_READ because, even though these do select all fields, since they cache the data, they are still faster when used multiple times for the same key. If you just want to check if a record exists, select just one field, if possible the one you’re using as criteria to avoid declaring an extra variable.

Thou shalt use a constants table

Thu, 28 Aug 2014 09:00:45 +0000

Whenever you feel a constant value can change and you can’t add it as a user parameter, store it in ZCONSTS. This table should never be used directly. Instead, a class like ZCL_CONSTS should be created to properly access it, like shown in this article: (portuguese only) Resist the temptation of using T900 or similar tables for this purpose. It’s true that a lot of people do it. But it’s ugly, durty and besides these tables don’t even have an adequate key because they were not designed with this in mind.

Unlocking objects in a transport request

Mon, 25 Aug 2014 09:00:26 +0000

When you touch an object and add it to a transport request, it becomes locked there by default. In a transport request you can also lock objects which are not yet locked in another order. But, once locked, how to unlock them?

Thou shalt build up and adopt toolkits with common tools

Thu, 21 Aug 2014 09:00:04 +0000

Code which is used very often should be made available centrally, if possible under a single package (ex: ZTOOLS) so that it’s easily identified. There is a lot of code already available on the Internet to accomplish several common functions (ex: ABAP2XLSX). Adopt it; For your most common tasks, develop your own tools which you can reuse and add them to the central library; Advertise the existence of that library among your colleagues to avoid that they waste time come up with duplicate code wasting;

Put it between parentheses

Mon, 18 Aug 2014 09:00:09 +0000

Sweet little trick: when in SE38 you need to surround a word or expression with () or [] or ‘’, just select it and press ( or [ or ’ and it immediately becomes (it) or [it] or ‘it’. Thank you Sérgio Fraga for the tip.

Thou shalt not REPLACE ‘.’ with ‘,’ just like that

Fri, 08 Aug 2014 09:00:08 +0000

If you need to adapt the content of a file with amounts, always take into consideration the user settings (USR01-DSCFM). If you need to convert a string to a number use FM MOVE_CHAR_TO_NUM. If you need to convert a number to a string use WRITE curr TO str [CURRENCY waers].

Thou shalt use command TABLES only when unavoidable

Thu, 31 Jul 2014 09:00:20 +0000

Using SELECT-OPTIONS is one of the very few reasons for using TABLES. For all other cases, explicitly declare a local variable for the equivalent structure. TABLES basically creates obscure global variables which increase ambiguity in the code. And global variables should be avoided anyway.

Thou shalt use FIELD-SYMBOLs instead of working areas

Thu, 24 Jul 2014 09:00:50 +0000

READ TABLE itbl ASSIGNING is always faster than READ TABLE itbl INTO wa. Besides, when making changes to internal tables, not only it doesn’t require the explicit MODIFY but it also does away with the auxiliary TABIX variable. The only situation in which a working area is better is when adding new lines to an internal table. Some people contend that working areas should still be used when no changes are to be made to the data.

Packages 2.0

Mon, 21 Jul 2014 09:00:12 +0000

SAP R/3 repository is a wonderful thing. A vast warehouse of data elements, structures, tables and much more, readily available to one and all. As developers, it is extremely convenient to quickly pick these elements and pull them into our programs as necessity conveys, while our string of thought remains virtually uninterrupted. Well, not all is sunshine and roses. If you are not careful with the mushrooms you pick you might get a poisoned one.

Thou shalt group related parts together

Thu, 17 Jul 2014 09:00:16 +0000

Sometimes you find an IMPORT in the code but you have no idea where the corresponding EXPORT is. When communication is needed between programs, it should be done using a pair of methods belonging to the same class. This way, when we run into one, we’ll always know where the other one is. Anyway, try to use EXPORT/IMPORT only when unavoidable. If possible, use static class variables instead.

Contemplating the package

Mon, 14 Jul 2014 08:00:25 +0000

You are looking at a class in SE24, a table in SE11 or a program in SE80. Now you want to see the package of this object and its content. Until recently, I would do this: first I would look in the object’s characteristics to see its package, then open a new session, go to SE80 and write the package there.

Now I’ve learned a much easier way.

Thou shalt avoid dynamic messages

Thu, 10 Jul 2014 08:30:17 +0000

When you need to send a dynamic message by parameter, make sure you still use the MESSAGE command, so that the “where-used” doesn’t loose track of it. When you do MESSAGE E001 INTO V_DUMMY, the message details become available in the system variables: SY-MSGNO, SY-MSGTY, etc. Also, message texts should never be hardcoded, they should always be defined in SE91. https://abapinho.com/en/2009/09/evitar-mensagens-dinamicas/ (portuguese)

Find out who transported a request

Mon, 07 Jul 2014 08:30:15 +0000

The other day, a series of things crashed in our test machine. All of a sudden, no one could work on it. We found a series of transport requests improperly transported to STMS. The user who appears to be associated with each of these requests is its owner. But is it the owner’s fault? Didn’t someone else do the transport?

How can we find out?

SE16N's technical view

Mon, 30 Jun 2014 09:00:43 +0000

Hi. How’ve you been? How’s life? All cool? This tip is so simple that if we don’t talk for a while it will all end too quickly. The sun is shinning. It rained in the morning but now it stopped. Moving on. Every time I see someone still using SE16 I wonder why, since SE16N is so much better and already exists for so long. But this is not the tip.

Thou shalt not use direct code in user-exits

Thu, 26 Jun 2014 09:00:47 +0000

All code to be put in user-exits (BADIs, enhancements, SMOD, etc.) should be encapsulated. It’s common for an user-exit to include multiple independent parts. Each of these parts should be encapsulated in its own method. Even if it is only one line; This should apply to both new implementations and changes to existing code; A change to existing code should always be seen as an opportunity to organize existing code into methods, since it will have to be tested again anyway;

Deleting packages that do not want to be deleted

Mon, 23 Jun 2014 08:30:48 +0000

When you try to delete a package where you have created objects that have meanwhile been deleted, and the package looks empty in SE80, when you try to delete it, it won’t work because it says the package still contains objects.

For some silly reason, SE80 does not show every type of object associated with packages. In addition, when an object is deleted, its entry is often times not deleted correctly. SAP is full of shortcomings. But it’s what we have, and it’s what brings us the bacon, so let’s not say too many bad things about it.

Abapinho has the solution for you.

Thou shalt not implement in classical processing blocks

Thu, 19 Jun 2014 09:00:32 +0000

Official ABAP Programming Guidelines (page 34): [When a classical processing block is required], you should immediately delegate the execution to a suitable method (see Rule 6.37, No Implementations in Function Modules and Subroutines, and Rule 6.44, No Implementations in Dialog Modules and Event Blocks).

0 is Private, 1 is Protected, 2 is Public

Mon, 16 Jun 2014 08:30:50 +0000

Simple tip to speed up entering data in (some) fields.

Thou shalt use ABAP OO whenever possible

Tue, 10 Jun 2014 13:14:29 +0000

All new developments should be implemented using ABAP Objects unless still impossible (RFC, IN UPDATE TASK, screens, etc). Existing developments, when rewritten, should also be converted to OO, if it proves to be realistic. Official ABAP Programming Guidelines (page 32) rule 3.1: Use ABAP Objects whenever possible for new and further developments. Classical processing blocks may be newly created in exceptional cases only. pdf/why-abap-objects.pdf https://scn.sap.com/people/thomas.jung/blog/2007/12/19/update-your-abap-development-skills-to-sap-netweaver-70 https://wiki.sdn.sap.com/wiki/display/ABAP/ABAP+Objects

Read the texts of a program

Mon, 09 Jun 2014 08:30:00 +0000

An easy way of programmatically accessing the texts of any program: DATA: t_textos TYPE TABLE OF textpool. READ TEXTPOOL sy-repid INTO t_textos LANGUAGE sy-langu STATE 'A’. Now, you have all of the texts available in the internal table T_TEXTOS. As if this were not enough, you can also change the texts programmatically with the following commands: INSERT TEXTPOOL sy-repid FROM t_textos LANGUAGE sy-langu. DELETE TEXTPOOL PROGRAM LANGUAGE 'E’. According to SAP, these last two commands are for internal use only.

SELECT within SELECT

Mon, 26 May 2014 09:00:03 +0000

ABAP programmers don’t explore the possibilities of SQL, probably for historical reasons. There are many who instead of using INNER JOINs still think it’s faster to do several SELECTs for internal tables and then process the data in ABAP. But the truth is that even if there are exceptions, the rule is: the lower the number of accesses to the database, the better the performance. And it makes sense because, after all, they were written explicitly for this; relational databases are much more adept at processing relational data than an ABAP program.

There are of course things that, due to their complexity, cannot be done with a simple INNER JOIN. Nevertheless, some of these things can be done in a single SELECT.

Get information on a remote system by RFC

Mon, 19 May 2014 09:00:16 +0000

Here’s a cool mini-function to obtain some details of a remote system accessible by RFC: RFC_SYSTEM_INFO I cannot give any example here because it would reveal very important secret information about my client which would certainly be used by the baddies to perform industrial espionage. But it is easy to test in SE37. Thanks to kingofthebigmacs for the photo. Greetings from Abapinho.

Request Based Debugging

Mon, 12 May 2014 09:00:10 +0000

If you look up the UNAME system variable in debug within a RFC call you may think it kind of odd to find a username that is not your own. What happens is that the system adopts a specific username for remote calls and a new session is started. A new session implies a new execution context and, hence, all our strategically placed breakpoints will no longer be recognised.

This problem can hinder a simple debug forcing us to run through the code looking for THAT remote call to THAT particular system.

SAP has a solution.

Class with loads of methods to deal with dates

Mon, 05 May 2014 09:00:16 +0000

There are countless standard functions to make calculations with dates. There are too many of them, they are redundant and, in many cases, they are obscure or impossible to understand. I’ve been meaning to insert an article here with a list of the most useful ones. But now it’s no longer necessary.

How to debug a job

Mon, 21 Apr 2014 09:00:23 +0000

Here’s a simple way to start debugging a job: Go to transaction SM37; Click on the job you want to debug; type JDBG in the command line (without /) and press ENTER; and… bang! you’re now debugging the job. Thank you Ricardo Monteiro for the tip. And thank you Ingolf for the photo. Greetings from Abapinho

Shortcut for time travelling

Mon, 07 Apr 2014 09:00:35 +0000

Some months ago I showed how to transform the debugger into a time machine. Today’s tip is simple but useful: there is a keyboard shortcut which makes it even simple to travel in time: shift + F12 Just place the cursor in the line you want to travel to and then… shift+F12. Thank you Maxsuel Maia for the tip. Greetings from Abapinho.

Use a password manager in your life

Mon, 24 Mar 2014 09:00:52 +0000

And there you go, if you read the title you know the hint.

Now, here are some hints about the hint:

I'm 5 years old!

Wed, 19 Mar 2014 16:47:07 +0000

Hello, my name is Abapinho and I’m 5 years old. I’m still growing up. Thank you to everyone who visited me during my short life and a special thank you to all those who participated with tips, ideas and posts. Greetings from me, Abapinho.

Abapinho's best practices

Mon, 17 Mar 2014 09:00:54 +0000

Recently, I have compiled a set of personal best practices. I decided to share them here by creating a new category (which will soon appear on the menu to the left) into which they will be grouped. The original idea was to make a PDF file but, since they are constantly being reviewed and expanded, this was largely impractical. As such, they will be published one by one. The goal is for these practices to be visible in their entirety as a user-friendly, accessible reference.

The ABAP detective

Mon, 10 Mar 2014 09:00:42 +0000

When a development is completed in SAP, the time to send it to other systems where it can be duly tested and then executed by users has finally arrived. Before that occurs, however, it has to be checked for lapses, errors and other problems that could lead to our programmes behaving in an unpredictable manner. There is a very useful tool that allows some of these errors and gaps to be filtered out. It is called ABAP Code Inspector.

Close the frozen window

Mon, 03 Mar 2014 17:30:56 +0000

How many times have you been left with a “hanging” window when you end a debug?

Exemplary example of SALV

Mon, 10 Feb 2014 09:00:25 +0000

Unless you want to do data editing, the only dignified way to use ALVs these days is through SALV classes. They are more modern and more elegant, and those who use them can achieve a social status until now only available to owners of a license plate.

Hold on… but not yet

Mon, 03 Feb 2014 09:00:56 +0000

You are doing a LOOP AT in a 1000-line table, and you know that you want line 853. Until recently, you had two options: either hit F8 852 times, running the risk of hitting it 853 times and having to start all over again, or create a watchpoint with the condition SY-TABIX = 852 or something close, and pray that it worked.

Now you have a third option.

APPEND LINES OF class->method() TO itbl

Mon, 27 Jan 2014 22:33:25 +0000

ABAP is getting smarter all the time. Back in my day, no one did anything with it. And now, slowly, more than a fifth of a century late, it’s trying to imitate C and Java, and becoming more flexible.

I was going to do something like this:

Automatic keyboard

Mon, 20 Jan 2014 09:00:00 +0000

Every programmer knows about the intimate relationship between batch-inputs and paperweights, staplers and similar heavy objects. These precious little helpers can keep us from spending up to eight hours hitting the “ENTER” key with one finger.

Although these objects have a certain charm, the law of gravity - the same one that makes them useful - sometimes makes them fall over and stop pushing this key.

Adding values to a standard domain

Mon, 13 Jan 2014 09:00:58 +0000

If you think it’s impossible to add values to a standard SAP domain without requesting an activation key, you’re wrong.

ABAP sucks

Mon, 06 Jan 2014 09:00:46 +0000

Go to the ABAP Editor (SE38) and check out line 323 of standard program RCIFCUST. If you’re lazy, here it is: SAP programmers are wild. Thanks Brian Wolfe for the photo. Greetings from Abapinho

Always use message classes in exception classes.

Mon, 16 Dec 2013 09:00:49 +0000

Exception classes let you state multiple texts describing the different possible errors that they can represent.

However, there exists an option to associate it with a message class (SE91). This allows texts to be defined as classic SE91 messages instead of being defined directly in the exception class. And it has advantages.

Mathematics problem

Mon, 09 Dec 2013 09:00:23 +0000

Do you know the difference between a mystery and an enigma puzzle? An enigma puzzle is known to have a solution, but with a mystery you don’t know if there is solution.

Do you agree with this? 5 * 3 / 10 = ( 5 * 3 ) / 10 = 5 * ( 3 / 10 ) = 1.5

If you don’t, you should agree because it is a mathematical fact.

Now let’s do some experiments.

The ABAP editor has a good memory

Mon, 02 Dec 2013 09:00:55 +0000

Select a word in the ABAP editor and choose CTRL-C. Then select another word and choose CTRL-C again. Then another word and so on. You have copied words several times to the clipboard. Experience and common sense tells us that if you choose CTRL-V you can only paste the last word you copied to the clipboard. But that is not quite right. You may not be aware of it, but the ABAP editor has a good memory.

Compare a table across two systems

Mon, 25 Nov 2013 09:00:45 +0000

The SCMP transaction compares the content of a table across two systems. It is very useful, especially for parameterization tables. It is very easy to use. It allows for the pre-selection of the registers and fields to compare. It also allows you to only display the differences, which is convenient for tables with lots of data. I don’t think any more explaining is required. Ite et videte. This tip recently appeared in the ex SAPtricks blog and I think it is so useful that I have reposted it here, in case you haven’t already seen it.

SELECT... ...ORDER BY PRIMARY KEY

Mon, 18 Nov 2013 09:00:43 +0000

Although I have been using ABAP since 1998, I learn new features or options every week, and sometimes even new commands. It’s hard to believe. Today, I’ll share a little SQL option that I recently discovered. SELECT * FROM T001 INTO TABLE T_T001 ORDER BY PRIMARY KEY. I have known SELECT, FROM, INTO, TABLE and even ORDER BY for a long time. I just didn’t know of PRIMARY KEY. It orders the internal table by its key.

Function to create cartoons

Mon, 11 Nov 2013 09:00:47 +0000

Cartoons always look good in a report. In a SAPGui that is boredom in blue, the more colours and cartoons there are the better it is. Luís Rocha showed me a very convenient function to fill up a report with icons.

SELECT comparing 2 fields of the same table

Mon, 04 Nov 2013 09:00:00 +0000

This tip is simple and quick, but I bet 200.482 Portuguese escudos that few know it.

Syntax error when returning tables of a method

Mon, 21 Oct 2013 09:00:37 +0000

When you create a return parameter in a method of a class that is a TABLE TYPE based on a type declared in the class proper, an error sometimes pops up that says:

“Type of RETURNING parameters must be fully specified.”

Steal data from a SALV

Mon, 14 Oct 2013 10:04:02 +0000

A friend of a friend of a friend said that a friend of his knew a friend who explained to him in a shady club bar in the docks area of Lisbon how to steal data from a SALV.

/HS Command

Mon, 22 Jul 2013 09:00:36 +0000

Most functionals, and even the hardcore functionals, knows that in order to start debugging an ABAP program, we use the /H command. But few programmers, even the hardcode programmers, will know the purpose of the /HS command.

Have you used regular expressions before?

Mon, 15 Jul 2013 09:00:55 +0000

Regularly expressions have been around for ages. But they’re not very well known and even less used. They are a sort of descriptive language that allows for making research and very sophisticated replacements in alpha-numeric chains. A simple example: to validate an email address. If you have to do this through an algorithm you’ll have to work hard. However, with regular expressions, only two or three code lines and the regular expression "\b[A-Z0-9.

Dynamically call classes and methods

Mon, 08 Jul 2013 09:00:12 +0000

Now, learn how to dynamically invoke a method.

Let’s go for it.

Read code from the web and execute it

Mon, 01 Jul 2013 09:00:42 +0000

This is a 2-in-1 article. That is to say, you’ll learn two subjects at once.

But get ready, what you’ll learn is dynamite, and, in the wrong hands, it can implode your universe.

First, you’ll learn how to read content on the web. And right after that, assuming that this content is ABAP code, you’ll learn how to execute it in the blink of an eye.

Don't mix Z functions with maintenance views!

Mon, 24 Jun 2013 09:00:02 +0000

Today’s hint is not a hint - it’s an advice.

After creating a table, you create its maintenance views. The maintenance views dwell within a group of functions. This group of functions is requested from you at the time of their creation. Since, after all, that’s no more than a set of generated code, and most of it is, nonetheless, standard includes. Loads.

I give you the problem: there are those who create their own Z functions and put them in groups of functions with maintenance views. It’s true. Some do this.

I like LIKE

Mon, 17 Jun 2013 09:00:16 +0000

In the ‘bad old days’ when the ABAP was even more old-fashioned than today, variable statements were all made through LIKE and were referenced to table fields:

DATA: V_KUNNR LIKE KNA1-KUNNR.

With many fields avoid INTO CORRESPONDING FIELDS

Mon, 10 Jun 2013 09:00:27 +0000

I have already advised here that, in tables with many fields, it’s always recommended to avoid using SELECT *, you must always select, explicitly, only the necessary fields.

But I didn’t warn you that there’s yet another optimisation worth making: avoid INTO CORRESPONDING FIELDS OF TABLE.

Free SAP course on HANA

Mon, 03 Jun 2013 17:40:13 +0000

SAP started last week a free course on HANA. Run!

QUICKINFO: tip on how to give tips.

Mon, 03 Jun 2013 09:00:46 +0000

In my opinion, this tip has arrived a few years too late, as it is now rare to use the WRITE command to directly write things to the screen. Therefore, we can say it’s a retro tip. A vintage tip. But let’s assume we are still in the twentieth century grappling with ABAP’s most Baroque command, WRITE. Then, imagine yourself sitting in front of SAP, listening to Pearl Jam, wearing black headphones and writing WRITEs of a series of values on the screen, which you would like the user to have more information on.

Is that RFC system alive?

Mon, 27 May 2013 09:00:03 +0000

You want to call an RFC function in another system but, because you’re not a carrion eater, you only want to do it if it’s alive. Hence, you need a way of checking whether that particular destination RFC system is alive. How do you do that? Charles Santana does it like this: DATE: rfcdest TYPE rfcdest, ping_status TYPE /sdf/e2e_traffic_light_numeric. CALL FUNCTION '/SDF/RFC_CHECK' EXPORTING iv_destination = rfcdest iv_ping = 'X' * iv_logon = 'X' * iv_latency = 'X' IMPORTING ev_ping_status = ping_status.

Does the function exist?

Mon, 20 May 2013 09:00:07 +0000

You call a function. Imagine it doesn’t answer. It may be that it’s staying silent. Or it’s shy. Or dumb. Or, of all the misfortunes, it doesn’t exist.

To make sure and put your mind to rest you then do:

Writing money without any decimal worries

Mon, 13 May 2013 09:00:50 +0000

Some people read the TCURX to find out the number of decimal places of a CURRENCY when they need to write a money field to an alphanumeric variable.

Are you one of those people? Don’t be.

R3TR vs LIMU

Mon, 06 May 2013 23:00:21 +0000

You’ve screwed up the productive system. You made a change to a method of a class (or to a function, whatever). Someone else makes another change to another method of the same class (or to another function of the same group of functions, whatever) and saves it to a different transport. When you transport your changes to the productive system, you discover that the class (or function, whatever) now has a syntax error because the changes had interdependencies. You also discover that now, until you get this problem resolved, all your functional co-workers hate you.

Finally, expressions can be concatenated

Mon, 15 Apr 2013 09:00:33 +0000

Finally, the SAP NetWeaver 7.0 Enhancement Package 2 makes ABAP start to seem like a normal programming language.

It even allows expressions to be concatenated, no less!

Decimal to alphanumeric without depending on the user

Mon, 08 Apr 2013 09:00:46 +0000

When reading a file with numeric values to an internal table or vice versa, the success of the conversion depends on whether the user has defined the dot or comma as the decimal separator. It is customary to then go and read the user setting and then adjust the values from the file with a dot or a comma as required.

But this is unfortunate and rather inelegant. There should be a way of not making this depend on the user.

And there is.

SORTED instead of STANDARD in the cache tables

Mon, 01 Apr 2013 16:11:22 +0000

Some time ago I wrote a post here showing the advantages of using internal tables with defined indexes instead of simple STANDARD tables. Confession: that habit is so ingrained that since then, almost all the internal tables I have created have continued to be STANDARD TABLE. It’s very common to create internal tables to cache data that I know I’ll often use inside LOOPS to avoid having to SELECT SINGLES inside them.

Share constants among several classes

Mon, 25 Mar 2013 09:00:35 +0000

Imagine you have a herd of related classes sharing between them a whole bunch of constants. Saying the same thing a different way, would you like all the classes of the herd to have easy access to the bunch of constants?

(If you’re confused, then let me tell you that the “herd” thing was just to baffle you)

Carrying on…..

SAP for rent

Mon, 18 Mar 2013 09:00:21 +0000

If you really need to access an SAP and nobody lets you, and you don’t have a computer where you can install it or you don’t have enough know-how or patience to do it, you can always rent.

Colour hallucination

Mon, 11 Mar 2013 09:00:56 +0000

This is not really an article. It’s hardly a tip. It’s closer to getting something off my chest in all the colours of the rainbow.

Create RANGEs in DDIC without getting all wound up

Mon, 04 Mar 2013 18:26:40 +0000

I am using RANGEs more and more. I use them at breakfast, lunch, and dinner and outside meal times. It’s like soy sauce. A few spoonfuls and everything is instantly tastier.

Lock data in Z-tables without a locking object

Mon, 28 Jan 2013 09:00:54 +0000

If I needed to create locking entries in a ZCOISO table I had created, up to two days ago I would have gone to SE11 to create a locking object for the ZCOISO table so that I could then use the function module generated by the locking object to lock the data.

But not anymore.

SAP system name in the window title

Mon, 21 Jan 2013 09:00:20 +0000

The client where I’m working at the moment owns more SAP systems than the number of volcanoes in Chile. And, of course, it’s inevitable to have multiple sessions open for several of those systems. With the windows minimized it’s impossible to know the matching between systems and sessions. I mean, it was impossible, because today that’s already possible:

Good mouse

Mon, 17 Dec 2012 09:00:45 +0000

Most of my friends, when they buy a new computer, worry a lot about CPU speed, disk speed and memory speed and whatnot speed. And then they go and buy a €6 mouse and a €7 keyboard. Ironic. While the CPU, the disk and the memory and all that other stuff often end up being wasted, the mouse and the keyboard are used to the max the entire time the computer is in use.

Execute commands in the user’s computer

Mon, 10 Dec 2012 09:00:41 +0000

It’s been a while since Abapinho played with fire. Today he will. Because today he’ll show you how to execute DOS commands on the user’s local machine. After you finish reading this article, you’ll be ready to format the hard disks of all your users. Dealing with danger helps make us aware of the power we have and the responsibility that comes with it. Dear reader, listen to your conscience.

SAPlink

Mon, 03 Dec 2012 09:00:00 +0000

SAPlink is a Z program that is installed in the development environment and which enables a wide variety of object types to be imported and exported from the Workbench.

Take a look here at some examples of how SAPlink can be used:

To transfer a table from one SAP system to another
To share a class on the internet
To make a local security backup of a set of programs before making a dangerous change
To keep a development in our personal repository (in Evernote, of course) in case you need it later in another project
Etc.

Benefits of LIKE LINE OF

Mon, 26 Nov 2012 09:00:40 +0000

Let’s start by assuming that you have some dignity and so you don’t use internal tables with HEADER LINE anymore ;)

Given this, let’s suppose you declare an internal table:

Maintaining table maintenance authorisation groups

Mon, 19 Nov 2012 09:00:24 +0000

There are some projects in which the authorisations group associated with table maintenance is always &NC;&, that is, Not Classified. It signals that everything there is friendly and nobody is hurting anyone else. But there are other projects where authorisation groups are taken seriously. But this is not synonymous with saying that they are organised. Serious or not, usually it all ends in a big mess, with nobody knowing who is authorised to do what.

This tip may help.

INSERT and APPEND with ASSIGNING FIELD-SYMBOL

Mon, 05 Nov 2012 09:00:11 +0000

The harsh truth, at all costs, is that structures are out of date. Nowadays FIELD-SYMBOLS are in.

When you make a LOOP to an internal table of course that you also use ASSIGNING FIELD-SYMBOL instead of INTO Structure,correct?

But what was screwing everything over was APPEND and INSERT. I did not know how to use a structure to add records

No one cares for LISTBOX

Mon, 29 Oct 2012 09:00:07 +0000

For some strange reason, LISTBOX is rarely used in report selection screens. Even though it’s widely used throughout the web. Who knows why.

Dear reader, I suggest you pay attention to its advantages:

Entrevista a Mauricio Roberto Cruz do ABAPZombie

Mon, 22 Oct 2012 09:00:51 +0000

Depois de o site irmão ABAPZombie (grande site brasileiro sobre ABAP) me ter entrevistado há uns meses atrás, aqui fica finalmente a minha vingança Zômbica. Entrevistar o Mauricio foi muito simples porque as perguntas que me fizeram são tão boas que resolvi virá-las contra o feiticeiro (Mauricio, espero que não leves a mal ter-tas usurpado!). As suas óptimas respostas ajudarão certamente os leitores portugueses a terem uma ideia de como funciona o mercado ABAP lá no Brasil:

SAParrot

Mon, 15 Oct 2012 09:00:47 +0000

Go to SE38 and create a program with the code below. Then turn the computer sound on and press F8. INCLUDE ole2incl. DATA : ole TYPE ole2_object, voz TYPE ole2_object, texto TYPE string. CREATE OBJECT voz 'SAPI.SpVoice'. texto = 'Olá eu sou o SAP e falo português com sotaque estrangeiro'. CALL METHOD OF voz 'Speak' = ole EXPORTING #1 = texto. Note: the parrot not in the photo, just the macaw with which he was talking :)

Are you serious or just joking?

Mon, 08 Oct 2012 09:00:16 +0000

Some things can only happen in production. While with some others it’s quite the opposite.

If you still don't use ABAP Objects you're chicken

Mon, 01 Oct 2012 09:00:20 +0000

SAP has a book called Official ABAP Programming Guidelines which describes rules and best practices on how to program in ABAP. In there you can read: Page 42: Rule 3.1: Use ABAP Objects whenever possible for new and further developments. Classic processing blocks may be newly created in exceptional cases only. Page 45: Within such a [classic] processing block, however, you should immediately delegate the execution to a suitable method (see Rule 6.

Beautiful table relationships diagrams

Mon, 24 Sep 2012 09:00:39 +0000

Nice relation diagrams for standard tables. Rui Dias revealed me a site where you can check the relation between any standard table with each other. For instance for T012. And if you try KNA1 it gets even better. Do you like it? I do. Thanks Rui Dias. Greetings from Abapinho.

Hey dad, look...no hands

Mon, 17 Sep 2012 09:00:48 +0000

In today’s article I will show you (and explain!) how you can make a selection screen refresh itself on a regular basis without user intervention.

Are you ready?

Keyboard shortcut to transaction field

Mon, 10 Sep 2012 09:00:09 +0000

And there you are madly typing with SAP when suddenly you need to go to the transaction field and write /OS37 or whatever. But you are writing with so much passion that the thought of leaving the keyboard for a moment to use your mouse seems catastrophic. Instead, you just press 3 keyboard keys: CTRL-SHIFT-7. Thank you Renato Sousa for the tip. Greetings from Abapinho.

Create sessions with the keyboard

Mon, 03 Sep 2012 09:00:02 +0000

You need to start a new session but your mouse was stolen. No problem. Press CTRL and then the + key and you will see a new session coming in. Thank you Renato Sousa for the tip. And thank you freeimageslive / gratuit for the photo. Greetings from Abapinho.

Digital narcissism

Mon, 27 Aug 2012 09:00:38 +0000

Reflection is the ability of a program to see itself. ABAP has a series of reflective capabilities, such as RTTS or the ability to dynamically generate code. There are also a few other so-and-so functions that do this and that. Today I present one of them to you:

GET_GLOBAL_SYMBOLS

Good program to find user-exits

Mon, 20 Aug 2012 09:00:00 +0000

Every now and then we’ll be looking for user-exits and BADIs, BTEs and the like. SAP doesn’t help. But programs appear here and there, almost always called Z_USEREXIT, which help with this unappreciated search. Recently I learned of another one. I share it here because it is the best I have ever seen: https://wiki.sdn.sap.com/wiki/display/Snippets/Find+User-exits,+BADIs,+BTEs,+Etc+by+TCode+or+Program Thanks to Bruno Esperança for the tip. And thank you rverscha for the photo. Greetings from Abapinho.

Class for converting STRINGs

Mon, 13 Aug 2012 09:00:56 +0000

You know how you sometimes have a STRING-type variable and you need to send it to a function that needs it in SOLIX-type? It often happens to me. Well, I have found this great class that converts strings into a wide range of formats:

CL_BCS_CONVERT

Jump The Wall

Mon, 06 Aug 2012 09:00:31 +0000

Turn down the music. Close the door. Look around. Is anyone looking at you? Are you being watched? Are there any security cameras? If not, we can go on.

Preventing competition in an ABAP program

Mon, 30 Jul 2012 09:00:27 +0000

They say that competition in trade is good. Good for consumers, that is. It lowers prices and so on. But inside computers it creates problems for those using them.

Usually, competition is contained in ABAP at the data level, blocking ( euqueue ) certain tables based on their key. But sometimes, something more violent may be required to ensure that a program may not run more than once at the same time. The ESINDX lock object can be used to do this.

Diving into Chaos with the CL_ABAP_RANDOM* classes

Mon, 23 Jul 2012 09:00:07 +0000

ABAP programs are all too well behaved, too predictable.

As demiurges, we have a moral obligation to give them a little free will, give them a scent of chaos, show them the trees of life and of knowledge, and in a passage through kenosis , give them free reign to take a bite from the apple. Only in this way will we feel complete and fulfilled, only by this means will we be able to rest on the seventh day.

There is nothing better to achieve this than random numbers.

Complex parameters in remote functions

Mon, 16 Jul 2012 09:00:01 +0000

Remote function calls (by RFC) do not support parameters with complex structures (deep structures). In other words, if any of the parameters has a structure in which one of the fields is another structure or an internal table then, hard luck, it won’t work.

Do you give up? No, you don’t. Abapinho provides the solution: serialization.

F1 in the selection screen fields

Mon, 09 Jul 2012 09:00:07 +0000

You have just produced a wonderful report headed by a selection screen crammed full of very interesting fields. But usually those running the report will not know, if it has some complexity, what each of the fields does. There are, of course, the technical and functional specifications for this. But are there? And even if there are, wouldn’t it be easier if you could press F1 on top of each field and find out there and then what it’s for?

I’ll show you two possible ways to give individualized information about the fields of a selection screen.

Finally ABAP knows Excel

Mon, 02 Jul 2012 09:00:22 +0000

There are various ways of creating an Excel spreadsheet in ABAP. Some are more masochistic than others and some are certainly more lousy than others.

Happily jumping from line to line

Mon, 25 Jun 2012 09:00:09 +0000

At the bottom right corner of ABAP editor, right in the status line, you can check in which line and column the cursor is. By double clicking over that information a dialog box is shown and you will be able to introduce a line number to it skip directly. The short key is CTRL-O. It’s very helpful. Thank you Fábio Branquinho for the tip. And thank you to juandesant for the photo.

Menu search

Mon, 18 Jun 2012 09:00:02 +0000

Did you know that is possible to search in SAP menus? Probably yes. Well, I didn’t. I’ve spent years looking through menu S000 searching for the most random stuff imaginable. I’m sure that if I had done menu search I would have found most of them in seconds. Sometimes you just don´t think of the obvious. Thank you Sérgio Fraga for the tip. Greetings from Abapinho.

Dot and comma or comma and dot?

Mon, 11 Jun 2012 09:00:34 +0000

Some numbers have dots, some numbers have commas and some numbers have dots and commas. The problem is that there are also numbers that have commas and dots. The thing is, there are commas that are dots and dots that are commas, depending on where you are from, in other words, depending on user’s configurations. When importing a file with decimal numbers, these numbers’ alpha-numeric fields must be converted into numeric fields.

More RANGEs, less SELECTs

Mon, 04 Jun 2012 09:00:33 +0000

The dictionary has the following entry for “style”: “set of formal aspects and expressive resources that characterise a text.”

It is preferable to read a text with style than one without. If ABAP were a language, a program in ABAP would be a text. When it comes to style, there are programs that seem to have been written by the feet, while there are others that one would swear the quill that wrote them was guided by the pure hand of an eighteenth century lady plagued by the troubles of love. Fortunately, I think it’s not possible to write programs in ABAP as tacky as the last sentence.

The “style” label is used here in Abapinho to identify articles that talk about just that: style. These articles try to find ways to improve the style of ABAP programs. This is one of Abapinho’s favourite labels, as you can see here. And what you are reading is another of those articles.

Moving on.

Follow your fingers

Mon, 28 May 2012 10:00:44 +0000

I have a number of friends working as managers, lawyers, marketers, programmers, etc., at very dynamic and competitive companies who are allegedly very busy and are always up to their eyeballs in work. They dedicated several years of their lives to their degrees in order to specialise in a particular field and some of them have put in the extra effort to get a postgraduate diploma in order to be better qualified and therefore able to do more both better and faster. However, the vast majority of them use two fingers when typing at a computer. Over a number of years they have acquired many skills that supposedly make them ultra efficient and yet they still type with two fingers.

Curso ABAP em São Paulo - 10% de desconto!

Wed, 23 May 2012 13:47:39 +0000

(actualizado em 16 de Junho) Queres aprender ABAP e moras em São Paulo? Se sim, aqui está a tua oportunidade. ZTREINAMENTO vai realizar um curso de 8 6 semanas que custará R$1.200,00 R$750,00 e é adequado a pessoas sem qualquer conhecimento de ABAP. Serão abordados os seguintes temas: Entendendo alguns conceitos de ABAP Comandos básicos Data Dictionary Trabalhando com funções Trabalhando com module pool Sapscript ABAP Orientado a Objetos (passou de 8 para 6 semanas mas a carga horária aumentou de 32h para 48h)

Slash O

Mon, 21 May 2012 10:00:00 +0000

Throughout all my “SAP life” I’ve used the command /olalala to initiate the lalala transaction in a new GUI window. Until now I had never tried just writing /o. I did today. The result was interesting. Meaning, it’s the same as going to SM04 and then choosing our user. But much easier. Greetings from Abapinho

Gregarious constants

Mon, 14 May 2012 10:00:28 +0000

If you are one of those who insert the values directly in code instead of using constants, then read no more and go and stand over there in the corner on punishment for 1 hour to learn not to be lazy. If you’ve come back from punishment or you usually use constants, then please continue reading.

Your password has expired. Change it 5 times.

Mon, 07 May 2012 10:00:08 +0000

It is not uncommon for us to be emotionally attached to our passwords. Therefore, it is always rather painful to receive those despicable threatening notices that say “your password is going to expire”. Soon followed by the blow we receive to our heart on the appearance of the inevitable vile invective that “your password has expired.” At such times, the hurt is so great that all the muses leave us, we have imagination cramp and remain stuck there, staring and drained, emptied of any idea to help us choose our next password.

Insert variables in standard texts

Mon, 30 Apr 2012 10:00:06 +0000

Everyone uses standard texts. But did you know that standard texts can have dynamic fields in the middle? SAP calls them “text symbols”. The way to do it is identical to that of the old forms of the harmful SE71, in other words wrapping them in the & symbol. Thus: &KNA1-NAME1;&. It’s really handy. I’ll show you how it’s done.

Client or Customer?

Mon, 23 Apr 2012 10:00:05 +0000

Wherever you use the data element KUNNR, its descriptions is “Client”. And what if we wanted to change this field description from “Client” to “Customer”? “Customer" is so much nicer! Or let’s suppose that the company you work for is trafficking in drugs and tells you that they want “Dealer” rather than “Supplier” to appear in the LIFNR field. Obviously we can label it as we wish on screens and Z reports but what about standard transactions?

Adding buttons to the selection screen

Mon, 16 Apr 2012 10:00:45 +0000

Normally, when buttons must be generated for users to click, Screen Painter is used to create a screen which is then invoked by the report using CALL SCREEN. But, unless the screen being designed is already quite complex it is pointless creating a screen which will have no further use. Screens have always annoyed me.

I will demonstrate an example of using buttons on a completely normal selection screen resorting to a button called PUSHBUTTON and a very clever trick called ONLI.

Fill up the selection screen with cartoons

Mon, 09 Apr 2012 10:00:58 +0000

Was SAP born miserable or are SAP-users simply unable to cheer it up?

The truth is that SAP GUI is no rainbow and neither does looking at it bring happiness. Even so, it puts at our disposal a bunch of cartoons that we may use to make it just a little more uplifting.

And take a look at just how easy it is.

Oh time turn back

Mon, 02 Apr 2012 10:00:08 +0000

“Oh time turn back Give me everything I have lost Take pity and give me the life The life I have already lived Oh time turn backward Kill off my futile hopes Look how even the sun itself Returns every morning” – António Mourão

Hey Tony, right away. I will show you how you can turn back time.

Search object attributes in an internal table

Mon, 26 Mar 2012 10:00:17 +0000

There are increasingly more objects in ABAP, gradually less fear of them and, lo and behold, more and more people are writing and using them. It is normal and desirable, if objects begin to appear everywhere, to start to stuff them into internal tables. I also stored a load of objects in tables a while back, unfortunately I did not know at that time what I am going to teach you here. It could have come in handy.

So, what exactly am I going to teach you here?

Implementing private methods in BADIs

Mon, 19 Mar 2012 10:00:09 +0000

A little while ago I had an idea as eccentric as it was amazing that today I have decided to share here, namely, how to create private methods in BADI classes.

Let me explain.

How to sabotage tables

Mon, 12 Mar 2012 13:30:24 +0000

Another article to help those who are into sneaky subversion Spies, take note on how to edit a table that cannot be (and probably shouldn’t be) edited. I’ll show you three techniques. The first stopped being useful a few years ago, the second is about to become obsolete and the third, well, we’ll just have to see for how long it will work. 1. SE16 /H OK_CODE EDIT The first technique dates back to the twentieth century and uses the old transaction SE16.

F1 + F9 = Technical Information

Mon, 05 Mar 2012 16:18:59 +0000

In a functional screen I often feel the need to see technical information about a particular field. I place the cursor on the field I want, then I click on F1 and a dialog screen will appear with help for that field. Then I click on the button that says “technical information”.But there is a quick way to do the same thing using only the keyboard. There are two possible ways for F1 to display the help for one specific field:

When an internal table is not structured

Mon, 27 Feb 2012 10:00:06 +0000

When you want to select some lines in an internal table you normally do something like this: DATA: BEGIN OF itbl, campo1 TYPE c, campo2 TYPE c, END OF itbl. READ TABLE itbl WITH KEY campo1 = 'X' campo2 = 'Y'. LOOP AT itbl WHERE campo1 = 'X' and campo2 = 'Y'. COISO. ENDLOOP. But what if the table is not structured and you want to search on the line as a whole?

Create test variants within functions from the debugger

Mon, 20 Feb 2012 10:00:42 +0000

Imagine that you are debugging a transaction, you enter into a function and find something interesting. So interesting that you have to debug it several times. The conventional way is to start the debug of the transaction again from the beginning. How tedious.

But there is a more direct route. When you are debugging a function you can create test data for this function directly from the debugger, using the values with which the function had been called at that time. For instance:

Sending a report or spool job by email

Mon, 13 Feb 2012 10:00:35 +0000

This post inaugurates a new category in Abapinho: Code. Posts in this category will present useful programs that are ready to execute.

This one is used for sending the result of any report or spool order by e-mail. This program makes use of the new BCS (Business Communication Services) through the CL_BCS class instead of the tired and old SO_DOCUMENT_SEND_API1, may its soul rest in peace.

The content can be sent in the body of the email, as a TXT attachment or as an HTML attachment, with the latter being sent nice and neat with all the colours. Enjoy it. Blindly copy it and use it or dissect it and learn how to use CL_BCS. On the way, you can still learn, if you feel like it, how to use local classes and exception classes.

A local class is simpler to show here in Abapinho but if you want you can transform it into a global class through SE24 as Abapinho already explained some time ago so that you can use it anywhere.

*&---------------------------------------------------------------------*
*& Report ZZZ_NFG_SEND_REPORT_BY_EMAIL
*&
*&---------------------------------------------------------------------*
*& Author: Nuno Godinho
*& Date: 03 January 2012
*& Description: Sends an abap list (generated by a submitted program or
*& read from an existing spool) by email. The list can be
*& sent either in the email body, as a text attachment or
*& as an HTML attachment.
*&---------------------------------------------------------------------*
REPORT zzz_nfg_send_list_by_mail MESSAGE-ID so.

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

* Exception classes
CLASS zcx_zs_no_receivers
 DEFINITION FINAL INHERITING FROM cx_static_check.
ENDCLASS.
CLASS zcx_zs_spool_error
 DEFINITION FINAL INHERITING FROM cx_static_check.
ENDCLASS.
CLASS zcx_zs_invalid_parameters
 DEFINITION FINAL INHERITING FROM cx_static_check.
ENDCLASS.
CLASS zcx_zs_objectlist_error
 DEFINITION FINAL INHERITING FROM cx_static_check.
ENDCLASS.

*----------------------------------------------------------------------*
* CLASS cl_send_list_by_mail DEFINITION
*----------------------------------------------------------------------*
*
*----------------------------------------------------------------------*
CLASS cl_send_list_by_mail DEFINITION.
 PUBLIC SECTION.
 TYPES: ty_send_mode TYPE char4,
 ty_source TYPE char6.

 CONSTANTS:
 k_send_mode_text TYPE ty_send_mode VALUE 'TEXT',
 k_send_mode_text_attach TYPE ty_send_mode VALUE 'TXTA',
 k_send_mode_html_attach TYPE ty_send_mode VALUE 'HTMA',
 k_send_mode_attachment TYPE ty_send_mode VALUE space,

 k_source_submit TYPE ty_source VALUE 'SUBMIT',
 k_source_spool TYPE ty_source VALUE 'SPOOL'.

 METHODS:
 constructor
 RAISING
 cx_send_req_bcs,

 add_recipient
 IMPORTING
 i_smtp_address TYPE ad_smtpadr
 RAISING
 cx_send_req_bcs
 cx_address_bcs,

 submit_and_send_mail
 IMPORTING
 i_report TYPE program
 i_variant TYPE raldb_vari
 i_send_mode TYPE ty_send_mode
 i_subject TYPE so_obj_des
 i_smtp_address TYPE ad_smtpadr OPTIONAL
 RAISING
 zcx_zs_no_receivers
 cx_bcs
 zcx_zs_invalid_parameters
 zcx_zs_objectlist_error
 zcx_zs_spool_error,

 read_spool_and_send_mail
 IMPORTING
 i_spool_number TYPE rspoid
 i_send_mode TYPE ty_send_mode
 i_subject TYPE so_obj_des
 i_smtp_address TYPE ad_smtpadr OPTIONAL
 RAISING
 zcx_zs_no_receivers
 zcx_zs_invalid_parameters
 zcx_zs_objectlist_error
 cx_send_req_bcs
 cx_bcs
 zcx_zs_spool_error.

 PRIVATE SECTION.
 DATA: go_send_request TYPE REF TO cl_bcs.

 METHODS:
 get_objectlist_and_send_mail
 IMPORTING
 i_source TYPE ty_source
 i_report TYPE program OPTIONAL
 i_variant TYPE raldb_vari OPTIONAL
 i_spool_number TYPE rspoid OPTIONAL
 i_send_mode TYPE ty_send_mode
 i_subject TYPE so_obj_des
 i_smtp_address TYPE ad_smtpadr OPTIONAL
 RAISING
 zcx_zs_no_receivers
 zcx_zs_invalid_parameters
 zcx_zs_objectlist_error
 cx_bcs
 zcx_zs_spool_error,

 submit_report_to_memory
 IMPORTING
 value(i_report) TYPE program
 value(i_variant) TYPE raldb_vari
 RETURNING
 value(ot_listobject) TYPE table_abaplist
 RAISING
 zcx_zs_objectlist_error,

 read_spool_to_memory
 IMPORTING
 i_spool_number TYPE rspoid
 RETURNING
 value(ot_listobject) TYPE table_abaplist
 RAISING
 zcx_zs_spool_error,

 get_objectlist
 IMPORTING
 i_source TYPE ty_source
 value(i_report) TYPE program
 value(i_variant) TYPE raldb_vari
 i_spool_number TYPE rspoid
 RETURNING
 value(ot_listobject) TYPE table_abaplist
 RAISING
 zcx_zs_spool_error
 zcx_zs_objectlist_error,

 create_text_document
 IMPORTING
 i_report TYPE program
 i_variant TYPE raldb_vari
 i_spool_number TYPE rspoid
 i_subject TYPE so_obj_des
 it_listobject TYPE table_abaplist OPTIONAL
 RETURNING
 value(o_document) TYPE REF TO cl_document_bcs
 RAISING
 zcx_zs_objectlist_error
 cx_document_bcs,

 add_header_to_body
 IMPORTING
 i_report TYPE program
 i_variant TYPE raldb_vari
 i_spool_number TYPE rspoid
 CHANGING
 xt_soli TYPE soli_tab,

 add_abaplist_text_attach
 IMPORTING
 it_listobject TYPE table_abaplist
 i_name TYPE so_obj_des
 CHANGING
 x_document TYPE REF TO cl_document_bcs
 RAISING
 zcx_zs_objectlist_error
 cx_document_bcs,

 add_abaplist_html_attach
 IMPORTING
 it_listobject TYPE table_abaplist
 i_name TYPE so_obj_des
 CHANGING
 x_document TYPE REF TO cl_document_bcs
 RAISING
 cx_document_bcs,

 send_mail
 IMPORTING
 value(it_listobject) TYPE table_abaplist
 i_report TYPE program OPTIONAL
 i_variant TYPE raldb_vari OPTIONAL
 i_spool_number TYPE rspoid OPTIONAL
 i_send_mode TYPE ty_send_mode
 i_subject TYPE so_obj_des
 RAISING
 zcx_zs_objectlist_error
 zcx_zs_invalid_parameters
 cx_bcs,

 build_attach_name
 IMPORTING
 i_report TYPE program
 i_variant TYPE raldb_vari
 i_spool_number TYPE rspoid
 i_extension TYPE so_obj_des OPTIONAL
 RETURNING value(o_name) TYPE so_obj_des.

ENDCLASS. "cl_send_list_by_mail DEFINITION

*----------------------------------------------------------------------*
* CLASS cl_send_list_by_mail IMPLEMENTATION
*----------------------------------------------------------------------*
*
*----------------------------------------------------------------------*
CLASS cl_send_list_by_mail IMPLEMENTATION.

 METHOD constructor.
* Create the send request
 go_send_request = cl_bcs=>create_persistent( ).
 go_send_request->set_send_immediately( 'X' ).
 ENDMETHOD. "constructor

 METHOD add_recipient.
 DATA: recipient TYPE REF TO if_recipient_bcs.
 recipient = cl_cam_address_bcs=>create_internet_address( i_smtp_address ).
 go_send_request->add_recipient( recipient ).
 ENDMETHOD. "add_receiver

 METHOD submit_and_send_mail.
 get_objectlist_and_send_mail(
 i_source = k_source_submit
 i_send_mode = i_send_mode
 i_report = i_report
 i_variant = i_variant
 i_subject = i_subject ).
 ENDMETHOD. "submit_report_and_sendmail

 METHOD read_spool_and_send_mail.
 get_objectlist_and_send_mail(
 i_source = k_source_spool
 i_send_mode = i_send_mode
 i_spool_number = i_spool_number
 i_subject = i_subject ).
 ENDMETHOD. "read_spool_and_send_mail

 METHOD get_objectlist_and_send_mail.
 DATA: t_recipients TYPE bcsy_re,
 t_listobject TYPE table_abaplist.

* Check parameters
 IF ( i_source = k_source_spool AND i_spool_number IS INITIAL ) OR
 ( i_source = k_source_submit AND i_report IS INITIAL ).
 RAISE EXCEPTION TYPE zcx_zs_invalid_parameters.
 ENDIF.

* Add recipient if supplied
 IF i_smtp_address IS SUPPLIED.
 add_recipient( i_smtp_address ).
 ENDIF.

* It should only run if there is at least one recipient
 t_recipients = go_send_request->recipients( ).
 IF t_recipients[] IS INITIAL.
 RAISE EXCEPTION TYPE zcx_zs_no_receivers.
 ENDIF.

* Get objectlist either from submit or from spool
 t_listobject = get_objectlist(
 i_source = i_source
 i_report = i_report
 i_variant = i_variant
 i_spool_number = i_spool_number ).

* Send email
 CALL METHOD send_mail
 EXPORTING
 it_listobject = t_listobject
 i_report = i_report
 i_variant = i_variant
 i_spool_number = i_spool_number
 i_send_mode = i_send_mode
 i_subject = i_subject.
 ENDMETHOD. "get_objectlist_and_send_mail

 METHOD get_objectlist.
* Get abap list into memory (either from spool or submit)
 IF i_source = k_source_submit.
 submit_report_to_memory( i_report = i_report i_variant = i_variant ).
 ELSE.
 read_spool_to_memory( i_spool_number = i_spool_number ).
 ENDIF.

* Import the list from memory and store it in table listobject
 REFRESH : ot_listobject.
 CALL FUNCTION 'LIST_FROM_MEMORY'
 TABLES
 listobject = ot_listobject
 EXCEPTIONS
 not_found = 1
 OTHERS = 2.
 IF sy-subrc <> 0.
 RAISE EXCEPTION TYPE zcx_zs_objectlist_error.
 ENDIF.

* Free memory
 CALL FUNCTION 'LIST_FREE_MEMORY'
 TABLES
 listobject = ot_listobject
 EXCEPTIONS
 OTHERS = 1.
 IF sy-subrc <> 0.
 RAISE EXCEPTION TYPE zcx_zs_objectlist_error.
 ENDIF.

 ENDMETHOD. "get_objectlist

 METHOD submit_report_to_memory.
 TRANSLATE: i_report TO UPPER CASE,
 i_variant TO UPPER CASE.
* Submit report
 SUBMIT (i_report) USING SELECTION-SET i_variant EXPORTING LIST TO MEMORY AND RETURN.
 ENDMETHOD. "submit_report

 METHOD read_spool_to_memory.
* Adapted from FM RSPO_RETURN_ABAP_SPOOLJOB. This FM converts the list to ASCII
* and I needed it as an ABAPLIST so I just copied the code and adapted it
 DATA: data_is_otf TYPE c.

 CALL FUNCTION 'RSPO_CHECK_JOB_ID_PERMISSION'
 EXPORTING
 rqident = i_spool_number
 access = 'DISP'
 EXCEPTIONS
 no_such_job = 1
 no_permission = 2.
 IF sy-subrc <> 0.
 RAISE EXCEPTION TYPE zcx_zs_spool_error.
 ENDIF.

 CALL FUNCTION 'RSPO_GET_TYPE_SPOOLJOB'
 EXPORTING
 rqident = i_spool_number
 IMPORTING
 is_otf = data_is_otf
 EXCEPTIONS
 can_not_access = 1.
 IF sy-subrc <> 0.
 RAISE EXCEPTION TYPE zcx_zs_spool_error.
 ENDIF.

 IF data_is_otf = 'X'.
 RAISE EXCEPTION TYPE zcx_zs_spool_error.
 ELSE.
 SUBMIT rspolist EXPORTING LIST TO MEMORY AND RETURN
 WITH rqident = i_spool_number
 WITH first = 1
 WITH last = 0
 WITH pages = space.
 ENDIF.
 ENDMETHOD. "read_spool

 METHOD send_mail.

 DATA: document TYPE REF TO cl_document_bcs,
 sent_to_all TYPE os_boolean,
 bcs_exception TYPE REF TO cx_bcs,
 name TYPE so_obj_des.

 IF i_send_mode = k_send_mode_text.
 document = create_text_document(
 i_report = i_report
 i_variant = i_variant
 i_spool_number = i_spool_number
 it_listobject = it_listobject
 i_subject = i_subject ).
 ELSE.
* Create text document without adding listobject to the body (it will be attached)
 document = create_text_document(
 i_report = i_report
 i_variant = i_variant
 i_spool_number = i_spool_number
 i_subject = i_subject ).
* Add attachment to document
 IF i_send_mode = k_send_mode_text_attach.
 name = build_attach_name(
 i_report = i_report
 i_variant = i_variant
 i_spool_number = i_spool_number
 i_extension = 'TXT' ).
 add_abaplist_text_attach(
 EXPORTING
 it_listobject = it_listobject
 i_name = name
 CHANGING
 x_document = document ).
 ELSEIF i_send_mode = k_send_mode_html_attach.
 name = build_attach_name(
 i_report = i_report
 i_variant = i_variant
 i_spool_number = i_spool_number ).
 add_abaplist_html_attach(
 EXPORTING
 it_listobject = it_listobject
 i_name = name
 CHANGING
 x_document = document ).
 ENDIF.
 ENDIF.

* Add document to send request
 go_send_request->set_document( document ).

* Send
 sent_to_all = go_send_request->send( i_with_error_screen = 'X' ).
* IF sent_to_all NE 'X'.
* RAISE EXCEPTION TYPE zcx_zs_mail_not_sent.
* ENDIF.

 ENDMETHOD. "send_mail

 METHOD create_text_document.
 DATA: t_listasci TYPE STANDARD TABLE OF solisti1,
 t_listobject LIKE it_listobject,
 t_soli TYPE soli_tab,
 w_soli LIKE LINE OF t_soli.

* Add header
 add_header_to_body(
 EXPORTING
 i_report = i_report
 i_variant = i_variant
 i_spool_number = i_spool_number
 CHANGING
 xt_soli = t_soli ).

* Add abap list
 IF it_listobject IS SUPPLIED.

 CLEAR w_soli.
 APPEND w_soli TO t_soli.
 w_soli = '------------------------------------------------------'.
 APPEND w_soli TO t_soli.
 CLEAR w_soli.
 APPEND w_soli TO t_soli.

 t_listobject[] = it_listobject[].
 CALL FUNCTION 'LIST_TO_ASCI'
 TABLES
 listasci = t_listasci
 listobject = t_listobject
 EXCEPTIONS
 empty_list = 1
 list_index_invalid = 2
 OTHERS = 3.
 IF sy-subrc <> 0.
 RAISE EXCEPTION TYPE zcx_zs_objectlist_error.
 ENDIF.
 APPEND LINES OF t_listasci TO t_soli.
 ENDIF.

* Create text document
 o_document = cl_document_bcs=>create_document(
 i_type = 'RAW'
 i_text = t_soli
 i_subject = i_subject ).
 ENDMETHOD. "create_text_document

 METHOD add_header_to_body.
 DATA: w_soli LIKE LINE OF xt_soli.

 IF i_report IS NOT INITIAL.
 CONCATENATE 'Report:' i_report INTO w_soli SEPARATED BY space.
 APPEND w_soli TO xt_soli.
 ENDIF.

 IF i_variant IS NOT INITIAL.
 CONCATENATE 'Variant:' i_variant INTO w_soli SEPARATED BY space.
 APPEND w_soli TO xt_soli.
 ENDIF.

 IF i_spool_number IS NOT INITIAL.
 MOVE i_spool_number TO w_soli.
 CONCATENATE 'Spool number:' w_soli INTO w_soli SEPARATED BY space.
 APPEND w_soli TO xt_soli.
 ENDIF.

 CONCATENATE 'Date:' sy-datum sy-uzeit INTO w_soli SEPARATED BY space.
 APPEND w_soli TO xt_soli.

 CONCATENATE 'User:' sy-uname INTO w_soli SEPARATED BY space.
 APPEND w_soli TO xt_soli.

 ENDMETHOD. "build_header

 METHOD add_abaplist_text_attach.
 DATA: t_solix TYPE solix_tab.

* It's always necessary to compress the table. SAPconnect will decompress it
 CALL FUNCTION 'TABLE_COMPRESS' "#EC *
 TABLES
 in = it_listobject
 out = t_solix
 EXCEPTIONS
 compress_error = 1
 OTHERS = 2.
 IF sy-subrc <> 0.
 RAISE EXCEPTION TYPE zcx_zs_objectlist_error.
 ENDIF.

 x_document->add_attachment(
 i_attachment_type = 'ALI'
 i_attachment_subject = i_name
 i_att_content_hex = t_solix ).

 ENDMETHOD. "add_abaplist_text_attach

 METHOD add_abaplist_html_attach.
 DATA: t_soli TYPE soli_tab,
 t_listobject LIKE it_listobject.

 t_listobject[] = it_listobject[].

 CALL FUNCTION 'WWW_HTML_FROM_LISTOBJECT'
 TABLES
 html = t_soli
 listobject = t_listobject.

 x_document->add_attachment(
 i_attachment_type = 'HTM'
 i_attachment_subject = i_name
 i_att_content_text = t_soli ).

 ENDMETHOD. "add_abaplist_html_attach

 METHOD build_attach_name.
 IF i_report IS NOT INITIAL.
 o_name = i_report.
 IF i_variant IS NOT INITIAL.
 CONCATENATE o_name '-' i_variant INTO o_name.
 ENDIF.
 ELSE.
 MOVE i_spool_number TO o_name.
 SHIFT o_name LEFT DELETING LEADING space.
 ENDIF.
 CONCATENATE o_name '-' sy-datum '-' sy-uzeit INTO o_name.
 IF i_extension IS NOT INITIAL.
 CONCATENATE o_name '.' i_extension INTO o_name.
 ENDIF.
 ENDMETHOD. "build_attach_name

ENDCLASS. "cl_send_list_by_mail IMPLEMENTATION

***************************************************************************
TABLES: adr6.

*------------------------------------------------------------------*
SELECTION-SCREEN BEGIN OF BLOCK b1 WITH FRAME TITLE text-001.
PARAMETERS: p_subj TYPE so_obj_des OBLIGATORY.
SELECT-OPTIONS: s_rec FOR adr6-smtp_addr NO INTERVALS LOWER CASE OBLIGATORY.
SELECTION-SCREEN END OF BLOCK b1.

SELECTION-SCREEN BEGIN OF BLOCK b2 WITH FRAME TITLE text-002.
PARAMETERS: p_submit RADIOBUTTON GROUP typ USER-COMMAND typ.
SELECTION-SCREEN BEGIN OF BLOCK b2a WITH FRAME.
PARAMETERS: p_rep TYPE program MODIF ID ty1,
 p_var TYPE raldb_vari MODIF ID ty1.
SELECTION-SCREEN END OF BLOCK b2a.
PARAMETERS: p_spool RADIOBUTTON GROUP typ.
SELECTION-SCREEN BEGIN OF BLOCK b2b WITH FRAME.
PARAMETERS: p_rspoid TYPE rspoid MODIF ID ty2.
SELECTION-SCREEN END OF BLOCK b2b.
SELECTION-SCREEN END OF BLOCK b2.

SELECTION-SCREEN BEGIN OF BLOCK b3 WITH FRAME TITLE text-003.
PARAMETERS: p_text RADIOBUTTON GROUP opt,
 p_texta RADIOBUTTON GROUP opt,
 p_htmla RADIOBUTTON GROUP opt DEFAULT 'X'.
SELECTION-SCREEN END OF BLOCK b3.

AT SELECTION-SCREEN OUTPUT.
 LOOP AT SCREEN.
 IF screen-group1 = 'TY1'.
 IF p_submit IS NOT INITIAL.
 screen-input = 1.
 ELSE.
 screen-input = 0.
 ENDIF.
 MODIFY SCREEN.
 ENDIF.
 IF screen-group1 = 'TY2'.
 IF p_spool IS NOT INITIAL.
 screen-input = 1.
 ELSE.
 screen-input = 0.
 ENDIF.
 MODIFY SCREEN.
 ENDIF.
 ENDLOOP.

START-OF-SELECTION.

 DATA: go_sender TYPE REF TO cl_send_list_by_mail,
 send_mode TYPE cl_send_list_by_mail=>ty_send_mode,
 exc_ref TYPE REF TO cx_root,
 text TYPE string.

 IF ( p_submit IS NOT INITIAL AND p_rep IS INITIAL ) OR
 ( p_spool IS NOT INITIAL AND p_rspoid IS INITIAL ).
 MESSAGE s622 DISPLAY LIKE 'E'.
 EXIT.
 ENDIF.

 CREATE OBJECT go_sender.

* Determine send mode
 CASE 'X'.
 WHEN p_texta.
 send_mode = cl_send_list_by_mail=>k_send_mode_text_attach.
 WHEN p_htmla.
 send_mode = cl_send_list_by_mail=>k_send_mode_html_attach.
 WHEN OTHERS.
 send_mode = cl_send_list_by_mail=>k_send_mode_text.
 ENDCASE.

* Add recipients
 LOOP AT s_rec.
 CALL METHOD go_sender->add_recipient
 EXPORTING
 i_smtp_address = s_rec-low.
 ENDLOOP.

 TRY.
 CASE 'X'.
 WHEN p_submit.
 CALL METHOD go_sender->submit_and_send_mail
 EXPORTING
 i_send_mode = send_mode
 i_report = p_rep
 i_variant = p_var
 i_subject = p_subj.
 WHEN p_spool.
 CALL METHOD go_sender->read_spool_and_send_mail
 EXPORTING
 i_send_mode = send_mode
 i_spool_number = p_rspoid
 i_subject = p_subj.
 ENDCASE.
 WRITE: / 'Mail message sent'.
 CATCH cx_root INTO exc_ref.
 text = exc_ref->get_text( ).
 WRITE: / text.
 ENDTRY.

* It will not work without this commit
 COMMIT WORK.

Texts for selection screen:

P_SUBJ	Subject

S_REC| Recipients

P_SUBMIT| Send report

P_REP| Report

P_VAR| Variant

P_SPOOL| Send spool job

P_RSPOID| Spool job ID

P_TEXT| Email body

P_TEXTA| TXT attachment

P_HTMLA| HTML attachment

Greetings from Abapinho.

The SAPGui history does not work even when active?

Mon, 06 Feb 2012 10:00:01 +0000

Has it ever happened to you that SAPGui does not store a history of values that you input to various fields even though the History option is actived in the settings?

SE80 has favourites

Mon, 30 Jan 2012 10:00:39 +0000

The SE80 transaction contains everything. It seems like those village grocery stores crammed with junk where you can buy toothpaste, bread, shoes, perfume and rice in bulk. I like these grocery stores. But to go there you need to know where you are going, otherwise you’ll walk from pillar to post. But this is what it’s like in these grocery stores but in SE80…. there are favourites. Yes indeed there are.

If a stranger offers you values, this is Input

Mon, 23 Jan 2012 10:00:08 +0000

In a report, the values are normally requested from the user at the first selection screen before the program is run. But what if you want to interactively ask for more values in the middle of running the program?

Selection screen with tabs

Mon, 16 Jan 2012 10:00:23 +0000

The selection screens of ABAP programs have several features that, although complex and easy to use, are generally ignored. Here, I will show you how easy it is to create tabs to better organise the parameters of a program. This time though, and uncommonly, I’ll spare you the verbal onslaught. It’s a practical class.

Debugging while in modal dialogue boxes

Mon, 09 Jan 2012 10:00:29 +0000

There are times when you can’t do /H to launch debugger. The most common one is when a pop-up window is open. However there is a simple, if Heath-Robinson, way to do it:

What does a message say?

Mon, 02 Jan 2012 10:00:15 +0000

Do you want to obtain the text from a message when you only know the ID and the number, but you don’t know how? Find out here: DATA text TYPE string. MESSAGE ID '00' TYPE 'E' NUMBER '163' WITH '123' INTO text. That’s all it is. Now inside the text variable, you find the following text: “Client 123 does not exist in the system” Thanks to Peteris B for the photo.

Be lazy when you write in ABAPese

Mon, 26 Dec 2011 00:11:42 +0000

To find out which professions attract the laziest people, I googled the following:

Profession	Results

“médico preguiçoso (lazy doctor)"| 2,140,000

“advogado preguiçoso (lazy lawyer)"| 1,430,000

“gestor preguiçoso (lazy business administrator)"| 1,020,000

“engenheiro preguiçoso (lazy engineer)”| 647,000

“político preguiçoso (lazy politician)"| 602,000

“economista preguiçoso (lazy economist)"| 284,000

“pedreiro preguiçoso (lazy builder)"| 91,200

As this conclusively proves, engineers are not lazy enough as they are beaten by lawyers and doctors. This must change. And this tip will help. But not without making the following difference clear: lazy is not work-shy. I am talking here about noble laziness, the behaviour of those who like doing things but with the least possible effort. Lazy slobs are not included here.

SAP is something that evolves slowly, and it launched a new editor a few years ago that is full of capabilities many of which, while handy, are barely used. One of them is called ‘Code templates’ which I will now demonstrate:

Multiple choice ALV in a modal dialogue box

Mon, 19 Dec 2011 10:00:31 +0000

Do you know how to present an ALV with a list of records in a dialogue box allowing multiple choice? I didn’t. But I do now. Let me explain how.

Automating the ALV field catalogue

Mon, 12 Dec 2011 10:00:00 +0000

Sometimes I ask myself what percentage of the world’s ABAP code is unnecessary. A paradigmatic example of how time can be wasted writing code which is of no use to anyone and only creates problems is the ALV’s all-too-common field description definition sitting directly in ABAP.

Pasta temporária do SAP Gui

Mon, 05 Dec 2011 10:00:09 +0000

Sometimes a program wants to save a file locally on the user’s computer via the SAP Gui. In these cases it is usual that one of the fields of the selection screen is the location of the folder on the local disk. This is a way of initialising this field with the temporary folder of the SAP Gui: PARAMETERS: p_path TYPE string. AT SELECTION-SCREEN ON VALUE-REQUEST FOR p_path. CALL METHOD cl_gui_frontend_services=>directory_browse EXPORTING initial_folder = p_path CHANGING selected_folder = p_path.

Partial Analyses in SE30

Mon, 28 Nov 2011 11:37:25 +0000

Obviously you already know the SE30 transaction (run time analysis) and obviously you use it often to analyse standard programs and to discover tables, functions, BADIs and similar contained within them. But if you are like me, then you have a love-hate relationship with this transaction – on the one hand you love it because it enables you to see the guts of a program without having to debug it, yet on the other hand you hate it because normally the list of guts tends to have thousands of lines and becomes unmanageable.

Multilingual programs that know what they are talking about

Mon, 21 Nov 2011 10:00:20 +0000

SAP is multilingual. But ABAP not always. ABAP does have some ability to learn and speak a few languages, but sometimes the programmers do not let it. A lot of programmers whack literal texts directly into the program, leaving it forever unable to communicate in multiple languages. I can think of two reasons for shackling a program to just one language: Laziness, the main reason for doing things badly; Legibility. In fact the way to make an ABAP program localizable is to pack it full of text references, like TEXT-001, which can get a bit illegible.

Fair thee well DESCRIBE TABLE. And good riddance.

Mon, 07 Nov 2011 10:20:18 +0000

For twelve long years When I wanted to count The lines of an itab I did what everyone does: DESCRIBE TABLE itab LINES linhas. Until the other day When (my eyes didn’t deceive me) I saw something so new, You wouldn’t believe me: LINES( itab ). It gives the same outcome And does away with declaring The damn variable. So instead of: DATA: linhas TYPE i. DESCRIBE TABLE itabl LINES linhas.

The drag queen message

Mon, 31 Oct 2011 10:00:55 +0000

The AT SELECTION-SCREEN modules of a report can throw error messages and send you back to the selection screen. But once you get past the START-OF-SELECTION, if you get an error message, the program ends. The solution to getting an error and returning to the selection screen, is to disguise the message: START-OF-SELECTION. IF condicao_desejada. MESSAGE S208(00) with 'Erro!' DISPLAY LIKE 'E'. EXIT. ENDIF. WRITE 'Olá, eu sou o resto do programa'.

The round-about routes of VALUE CHECK

Mon, 24 Oct 2011 10:00:24 +0000

Have you ever come up against something in ABAP that seems to be one thing but is in fact another? The documentation says it is this and everything seems to indicate that it is, but after all it isn’t. You’ve probably needed to, when setting a parameter in the report selection screen, check the possibilities of what the user can input to the available values in the data type of that parameter, right?

Automatic variants in reports

Mon, 17 Oct 2011 10:00:57 +0000

When developing a report with a selection screen it is very annoying that every time we test it we have to input the test data to the selection screen. We usually end up creating a variant of the test to save us from this hassle. But, every time we run the report we still have to manually call this variant. Here is a simple way to automatically call a variant. This code can be inserted into the INITIALIZATION event during the development of the program:

Stand up, all victims of oppression

Tue, 11 Oct 2011 10:55:54 +0000

Classes. They have always existed among people. But there are still few who take them into consideration in ABAP. While being a supporter of classes in society can result in pedantry, the only class struggle in ABAP is that some fight for them to be used more. There are two types of classes: global and local. The global ones are created in the SE24 transaction. Local classes, which by the way I find myself using more and more, are done declaratively in SE38.

Forget it!

Fri, 07 Oct 2011 10:00:49 +0000

O SAP GUI tem boa memória. Vai decorando os valores que lhe vamos metendo nos campos e depois sugere-os quando, mais tarde, voltamos a esses campos. Mas às vezes decora coisas que mais valia esquecer. Como por exemplo quando introduzimos um valor errado e a seguir ele insiste em sugerir-nos esse valor errado. Há uns tempos descobri que este pequeno drama tem solução. Quando, no campo, aparece a combo box com as várias hipóteses, usa as setas do teclado para te posicionares no valor que queres esquecer e depois carrega na tecla DELETE.

SPLIT INTO TABLE

Mon, 03 Oct 2011 10:00:13 +0000

I’m going to show you a creative way of filling out an internal table with constants that I learned in a standard program. Imagine you want to create an internal table with the following kinds of financial documents: AB AF CH DG DZ EX F3 F4. The more conventional way would be this: DATA: t_blart TYPE STANDARD TABLE OF blart, wa_blart LIKE LINE OF t_blart. wa_blart = 'AB'. APPEND wa_blart TO t_blart.

Vertical text selection in ABAP editor - really? Really.

Mon, 26 Sep 2011 10:00:06 +0000

As everyone knows, you can select vertical or horizontal blocks of text almost anywhere in SAPGUI, typing CTRL-Y and then dragging the mouse to make the selection. Everyone also knows that this does not work in ABAP editor. But perhaps what some people don’t know is that there is a way of making this kind of selection in ABAP editor: press and hold ALT. Now you can select blocks of text.

Unparameterisable parameters

Mon, 12 Sep 2011 10:00:52 +0000

Every now and then you get a client who asks a programmer to create a write-protected parameter on the program selection screen. It’s a bit dumb given that the whole idea of parameters is that they are parameterisable. But there you go, it takes all sorts. Clients have so much imagination that SAP should create a cinema module, SAP CI, especially so they can screen all the films they carry around in their heads.

Hopping merrily from ELSE to ELSE

Mon, 22 Aug 2011 11:02:30 +0000

You have in front of you one of those giant IF ELSEIF ELSEIF ELSEIF ELSEIF ELSE ENDIF that runs through hundreds of lines of code. If you double click on the IF or any of the ELSEIF you jump to the ENDIF. If you double click on the ENDIF down below you go to the IF up above. Everybody knows this. It is handy with a small IF ENDIF. However, it’s not much use with the large ones.

Jumping within ABAP editor

Mon, 15 Aug 2011 10:06:39 +0000

Have you ever found yourself programming in one of those ABAP programs that’s as long as the Bible with hundreds and hundreds of lines where you always have to jump from one code area to another? Until a few days ago, in my ignorance I was using PageUp and PageDown to jump between the two locations and I wasted loads of time looking for the exact place in the code that I was interested in.

Upside down CASE

Mon, 08 Aug 2011 10:00:47 +0000

What is your favourite colour? SELECTION-SCREEN BEGIN OF BLOCK b1. PARAMETERS: p_azul BUTTONGROUP GROUP COR DEFAULT 'X', p_verde BUTTONGROUP GROUP COR, p_roxo BUTTONGROUP GROUP COR. SELECTION-SCREEN END OF BLOCK b1. If you said ‘blue’ you live and can cross the bridge. In any case, the following normally happens in ABAP to discover the colour the user chose: IF p_azul = 'X'. lv_cor = 'AZUL'. ELSE IF p_verde = 'X'. lv_cor = 'VERDE'.

The *_SINGLE_READ functions

Mon, 01 Aug 2011 10:43:04 +0000

When you need to derive a single record from a database table, you normally use SELECT SINGLE, which is like this in its most basic form, as everyone knows: SELECT SINGLE * FROM KNA1 WHERE KUNNR = '1234567890'. Of course, if you are interested in just a few fields, ideally you select them explicitly to avoid copying unnecessary data from one side to the other: DATA: lv_name1 TYPE name1. SELECT SINGLE name1 INTO lv_name1 FROM KNA1 WHERE KUNNR = '1234567890'.

RICEF is not transgenic rice nor is it part of the UN

Mon, 25 Jul 2011 10:39:04 +0000

RICEF is an acronym in SAP world which apparently was not invented by SAP. And so it is an unofficial acronym. Which does not mean it is an illegal or secret acronym given that it has become a term in proper usage in more and more projects. RICEF means Report , Interface , Conversion , Enhancement , Form and, basically, refers to any kind of development that might be needed in a SAP project.

I CTRL-clicked to select a word

Mon, 18 Jul 2011 11:19:51 +0000

A simple but valuable tip: anywhere in the SAP GUI - including the ABAP Editor - to select a word all you have to do is CTRL-click above it. Cool, no? Unfortunately it doesn’t work on the Mac Java GUI :-( (Thank you Sérgio Fraga for the tip) Greetings from Abapinho.

Instant RANGE - just add water

Mon, 11 Jul 2011 11:07:07 +0000

I’m going to teach you a magic formula for creating a RANGE that is almost as easy as just adding water. Imagine that you want to create a RANGE from a database selection to then use it in another SELECT. Obviously you can do it like this: DATA: lt_kunnr TYPE STANDARD TABLE OF kunnr, lr_kunnr TYPE RANGE OF kunnr, wa_kunnr LIKE LINE OF lr_kunnr. FIELD-SYMBOLS: <kunnr> LIKE LINE OF lt_kunnr. SELECT kunnr INTO TABLE lt_kunnr FROM kna1.

LOOP ASSIGNING instead of LOOP INTO

Sat, 02 Jul 2011 12:25:03 +0000

In the beginning there was INTO. Actually, in the beginning it was not even INTO.

Taking a nap

Fri, 17 Jun 2011 11:43:28 +0000

Whatever the case, it is necessary to put a program to sleep. And, as with almost everything else, there are several ways to do this, some better than others. The most standard way to do this in ABAP is as follows: WAIT UP TO 10 SECONDS. The advantage of WAIT UP TO N SECONDS is that the process is freed up during these 10 seconds, thereby making it available for those who want it.

Different versions of the same story

Thu, 09 Jun 2011 13:41:50 +0000

Everyone knows that the SAP versions are a big mess. The lords of Heidelberg who play around with the names they give their things are either an impulsive bunch, are making fun of us, or they must always be in uproar. Here is a little table to help to unravel them: Ano | UI | Edition | Version | Version | BASIS | WebAS | ECC | NetWeaver —|—|—|—|—|—|—|—|— | Terminal

On your marks, get set, go!

Tue, 24 May 2011 09:00:41 +0000

Ladies and gentlemen, boys and girls, the race is about to begin.

Introduction

The four competitors are as follows. They are 4 internal tables, of different races and creeds, which will fight for the athletics title of speed LOOP. Here they are:

Competitor 1: DATA: LT_ITEM TYPE TABLE Competitor 2: DATA: LT_ITEM_HASHED TYPE HASHED TABLE Competitor 3: DATA: LT_ITEM_SORTED TYPE SORTED TABLE Competitor 4: DATA: LT_ITEM TYPE TABLE + INTO INDEX

Global macros

Thu, 19 May 2011 18:02:41 +0000

In a previous article we talked about macros, a relatively obscure and little used feature that can be both useful as well as create a huge mess. But these aren’t the only ABAP macros. There are others that are even more obscure and with even greater potential to mix up a system: the global macros. I don’t know if I should tell you this, as it’s so strange… But, I don’t think it’s a good idea to hide it… Therefore, I’ll tell all.

Start on the right footing

Sat, 23 Apr 2011 09:27:25 +0000

Normally when you log on to SAP the SAP menu appears. But you can use the function module NAVIGATION_SET_START_TCODE to pre-set an initial transaction. Anyway, it’s better to know it’s there than not to know it’s there, and even better than knowing that it’s not there. Who knows – it could be good for some users. There’s also the function module NAVIGATION_GET_START_TCODE to see what is pre-set. Greetings from Abapinho.

Not even David Copperfield would do better

Thu, 21 Apr 2011 11:26:14 +0000

Sometimes we want to access a transaction and we don’t have permission. That’s annoying. Luckily there’s the function module ALINK_CALL_TRANSACTION which makes things better. But use it with care or someone will get angry. Welcome to the dark side of Abapinho. If they say it was me that said it, I deny everything. Update: this function module will also do the trick: CALL_TRANSACTION_FROM_TABLE. New update: if all the above fail try this other function module: RS_HDSYS_CALL_TC_VARIANT (clearing flag AUTHORITY_CHECK).

ABAP Ninja

Fri, 25 Mar 2011 18:51:10 +0000

One of the major new features in ERP 6.0 is the Enhancement Framework, a kind of “landlord’s friend” that allows you to hammer on all the SAP walls without chipping the paintwork. Unfortunately there’s still very little documentation about this and it’s always difficult to find the right Enhancement Point for the hammering you want. The a ABAP Ninja site tries to help. It’s an Enhancement search engine. They say they have more than 13,000 Enhancement Points waiting to be found.

St. Isidore of Seville

Sun, 20 Mar 2011 17:29:14 +0000

Don’t know who to pray to in moments of desperation? Now you can relax. Programmers have a saint – St. Isidore of Seville. A very learned and intelligent gentleman who lived in Spain in the 6th and 7th centuries and, to quote Wikipedia, “wrote about mathematics, astronomy, medicine, human anatomy, zoology, geography, meteorology, geology, mineralogy, botany and agriculture. He added nothing innovative or original, carried out no experiment, made no new observations or reinterpretations and discovered nothing, but his influence on the Middle Ages and the Renaissance was great”.

LOOP FROM INDEX

Thu, 10 Mar 2011 12:15:12 +0000

It’s very easy to get tied up in knots where performance is concerned when you’re working with internal tables – especially when they’re getting really big. In fact these problems often only arise after a few months, when the tables tend to grow as time goes by. For example, when you’re looping two tables, one of headers and another of entries, do you do this? LOOP AT itab1 ASSIGNING <fs1>. LOOP AT itab2 ASSGNING <fs2> WHERE field1 = <fs1>-field1.

Progress indicator

Mon, 07 Mar 2011 12:04:18 +0000

You know those progress bars that show how long it will take for a process to end? The ones that sometimes go back to the beginning when they reach the end and leave you frustrated and confused and wondering what use they are anyway? Here’s how you can use them in an ABAP program. DATA: lv_texto TYPE char40, lv_valor type i. DO 10 TIMES. WAIT UP TO 1 SECONDS. CLEAR lv_texto.

Executa um comando no teu computador

Wed, 16 Feb 2011 21:33:38 +0000

Imagina que queres executar um programa no teu PC a partir de um programa ABAP. Não sei porque carga de água quererás tu fazer isto mas ok, se queres mesmo fazer, é assim: DATA: i_returncode TYPE i. CALL FUNCTION 'GUI_EXEC' EXPORTING command = 'Notepad.exe' parameter = 'eu_sou_um_texto.txt' IMPORTING returncode = i_returncode. É provável que dê para fazer coisas boas com isto. Mas está à vista a grande javardice que se pode fazer por isso pensa bem antes de começares para aí a escangalhar os computadores dos utilizadores todos.

SAT – The new execution analysis tool

Wed, 16 Feb 2011 14:31:40 +0000

Since I was small I have been using the SE30 transaction for two different things: To analyze a (normally standard) program I don’t know in order to find out what functions it uses, what BADIs it offers, etc; To analyze a program of mine to search for performance problems. The simple truth is that the SE30 transaction is a total mess. It’s extremely limited and inflexible and it’s useless for any more complex analysis.

Como encavalitar tabelas

Sat, 05 Feb 2011 16:38:20 +0000

Às vezes temos de criar uma tabela Z. Às vezes temos até de criar várias tabelas Z. Às vezes estas tabelas estão relacionadas de alguma forma. Como quando uma contém dados de cabeçalho e a outra dados de item, por exemplo. Ora se estão relacionadas pode dar jeito que sejam editadas em conjunto. É para isso que servem os Clusters de Visão (view cluster).

As estruturas PRE-a-porter

Tue, 11 Jan 2011 11:51:37 +0000

Quantas vezes não é necessária uma pequena estrutura para guardar, por exemplo, uma lista que relacione materiais e centros. Mas perder tempo a inventar a roda é sempre de evitar. No reino do MM há uma pequena família de estruturas que uso amiúde: são elas as PRE*, uma série de estruturas que vai desde a PRE01 à PRE50, com uns saltos pelo meio. Embora sejam, na sua maioria, específicas demais para servirem algum propósito, há algumas úteis.

A Ressurreição de um programa

Thu, 16 Dec 2010 13:23:34 +0000

Batendo impetuoso com seus braços no peito, o famoso guerreiro gritava desesperado: “Oh meu Zeus! Apaguei um grande programa , um programa precioso, feito de bronze, forjado por vós deuses no próprio Olimpo. Que será de mim quando isto for descoberto! Oh, ignomínia! Oh, funesto infortúnio! Zeus pai, não te enfureças com tal revés, Se és mesmo meu pai, acode-me ao invés.” Assim falou; e Zeus compadeceu-se dele que chorava, garantindo que seu programa se salvaria e não pereceria.

Imprimir para PDF local

Wed, 01 Dec 2010 04:25:12 +0000

Receita rápida: Manda-se imprimir o que se quer, dizendo ao SAP para guardar a ordem de impressão no spool e não a imprimir imediatamente. Reserva-se o número da ordem de impressão num recipiente à parte. A seguir, corre-se o programa RSTXPDFT4 , junta-se-lhe o número da ordem de impressão, mistura-se bem e executa-se o dito. Por fim escolhe-se onde, no computador local, se quer desenformar o ficheiro PDF com o conteúdo da ordem de impressão.

Depuração telepática

Fri, 26 Nov 2010 10:55:58 +0000

Imagine o seguinte cenário: um utilizador (ou utilizadora) está sentado no escritório dele, a correr uma transacção ou não sei o quê. Tem um problema e chama um programador (ou programadora) para o (ou a) ajudar a entender o que se passa. Normalmente o programador (ou programadora) teria de se deslocar lá, à sala do senhor utilizador (ou senhora utilizadora) e das duas uma: fazer debug no computador dele (ou dela) ou aprender como recriar o problema e depois fazer debug no seu computador.

SELECT com mais olhos que barriga

Sun, 21 Nov 2010 22:56:36 +0000

Embora seja evidente que, ao fazer selecções de dados de uma tabela da base de dados, devemos ter o cuidado de escolher apenas os campos que necessitamos, a verdade é que há muito boa gente que não se dá a esse trabalho e manda vir tudo.

Mediremos aqui a diferença real entre as duas abordagens.

SE37.com

Wed, 10 Nov 2010 12:52:03 +0000

Neste site pode-se consultar documentação de módulos de função ABAP: www.se37.com Basta escolher continue as guest pois a inscrição só é necessária para edição ou adição de conteúdos. E depois é só introduzir um grupo de funções ou um módulo de função para ver a sua documentação. Actualização: já não existe. O Abapinho saúda-vos.

Pede ajuda aos PDFs da SAP

Wed, 10 Nov 2010 12:39:55 +0000

A SAP disponibiliza uma série de documentos PDF que contém ajuda e informação preciosa nas mais variadas áreas. Estes PDFs estão dispersos pelos vários sites da SAP, mas alguém no site Easy Service Marketplace compilou todos numa conveniente lista: www.easymarketplace.de/online-pdfs.php Obriado Sérgio Fraga por este outro link com mais uma série de PDFs: sapignite.com/download-sap-pdf-material-abap/ Espero que vos ajude! Actualização: Isto parece já não existir. O Abapinho saúda-vos.

Um mal que veio por bem

Sun, 07 Nov 2010 03:29:07 +0000

Era uma vez um cliente com um sistema produtivo com 9 servidores mais rápidos que a própria sombra. Esses 9 servidores eram geridos por 4 administradores de sistema muito bons que os mantinham sempre oleados e a fluírem à velocidade máxima. Um dia tive de desenvolver um carregamento muito complexo que criava milhões de classificações. Quando se começou a testar o programa, constatou-se que algo estava muito lento, lento demais. Na maior parte do tempo o programa estava encalhado à espera de SELECTs sequenciais à tabela INOB, que era gigante.

Downloadar e uploadar programas e afins

Tue, 28 Sep 2010 11:16:37 +0000

Há palavras em inglês que o português de Portugal não se dá ao trabalho de traduzir. O verbo inglês download vira downloadar ou fazer download. A seu tempo, há-de seguir o caminho que beef seguiu até conseguir chegar a bife , transformando-se lentamente em algo tipo daunelaudar. Mas até lá… fazem-se downloads. Já que a SAP nunca se preocupou em permitir o download e upload de objectos do DDIC e do ABAP Workbench, foram sempre aparecendo umas almas caridosas com uns programas mais ou menos medíocres que o permitiam.

Dar de beber à dor

Tue, 21 Sep 2010 10:47:05 +0000

No Inverno de 2006 trabalhava no projecto SAP de um enorme retalhista internacional, com centenas de supermercados espalhados por todo um país. Uma bela manhã, pelas 11h45 comecei a ver várias pessoas com ar alarmado a correr de um lado para o outro no escritório. Perguntei o que se passava e se podia ajudar e explicaram-me que não conseguiam fazer a encomenda de leite para o dia seguinte que tinha de ser feita até às 12h15 mas que não tinha nada a ver comigo, que eu não podia ajudar.

Pesquisar em tabelas internas simplórias

Tue, 21 Sep 2010 10:36:51 +0000

Imagina uma tabela interna tão simplória que nem sequer tem uma estrutura de dados com campos: DATA: t_simploria TYPE STANDARD TABLE OF char30. Agora imagina que queres fazer uma pesquisa nessa tabela para saber se contém o valor ‘sumo de melão’. mas como não tem campos, como a fazes? Normalmente usarias algo tipo WITH KEY campo = valor. Mas ela não tem campos. O ABAP disponibiliza uma palavra especial que resolve este problema: TABLE_LINE.

Transacção I18N = Internacionalização

Mon, 06 Sep 2010 13:54:15 +0000

Os americanos são tão bons como os tibetanos a arranjar mnemónicas e abreviaturas para tornar as coisas fáceis de decorar. Internationalization é uma palavra inglesa com 20 letras. Então, a abreviatura adoptada foi I18N, constituida pela primeira e última letras entremeadas por um 18 que representa as 18 letras do meio. Meio maluco mas giro e a verdade é que pegou. Pegou tanto que o SAP tem uma transacção chamada I18N.

É meu, só meu e de mais ninguém

Wed, 01 Sep 2010 14:25:53 +0000

Imagina que estás a trabalhar num sistema partilhado por muitos outros utilizadores que não conheces. Como no IDESACCESS por exemplo. Nada impede que, por distracção ou perfídia, algum desses outros utilizadores altere ou mesmo apague os teus programas. Na SE38, nas características técnicas do programa, existe um pisco chamado “Bloqueio do editor” que, se o activares, só tu próprio passarás a poder modificá-lo. O Abapinho saúda-vos.

Was ist ABAP?

Tue, 17 Aug 2010 17:26:52 +0000

Mas afinal o que é que quer dizer ABAP? Em 1970 chamaram-lhe ABAP que queria dizer “Allgemeiner Berichts-Aufbereitungs-Prozessor”, ou em português “Processador de geração de reports genéricos”. Em 1990 mudaram-lhe o nome para ABAP/4 e disseram que afinal queria dizer “Advanced Business Application Programming”, ou em português “Programação avançada para aplicações de negócio”. Em 2000 largam o /4 e tornaram a chamar-lhe só ABAP e é o que ainda lhe chamam agora.

Import/Export = Contrabando

Sat, 14 Aug 2010 00:37:24 +0000

O Java, uma linguagem de programação bem pensada, ajuda o programador a organizar o seu código obrigando-o a desenvolvê-lo de forma estruturada. A sua própria filosofia potencia o pensamento estruturado e promove coerência e arrumação.

Já o ABAP… promove o caos. Está cheio de caminhos perniciosos que levam direitinho a um inferno confuso e labiríntico. E geralmente são as coisas aparentemente mais convenientes que se revelam as mais perigosas.

Uma das conveniências piores é a parelha IMPORT e EXPORT.

Mensagens entre utilizadores

Fri, 13 Aug 2010 09:35:39 +0000

Muitas vezes precisamos de aceder aos dados de uma tabela através da SM30 ou a um qualquer documento e esbarramos com uma mensagem a dizer que os dados estão bloqueados por outro utilizador. Há várias hipóteses: Ter muita paciência e esperar; Ter bastante paciência, enviar uma mensagem do SAPOffice e esperar que um dia o utilizador a vá ver; Ter alguma paciência, enviar um e-mail e esperar; Ser impaciente, ir ter com o outro e pedir-lhe para por favor sair dali;

Dá e receberás

Mon, 12 Jul 2010 06:28:33 +0000

Vivia-se o ano do Senhor de 1998. No século XX portanto, quando ainda se trabalhava de gravata. Estava eu com 1 mês de experiência em SAP e pela primeira vez sozinho num cliente, de gravata ao pescoço, num armazém gigante, a fazer formulários de WM e coisas do género ao serviço de um funcional de WM. Certo dia fui directamente abordado por um senhor condutor de um empilhador que me disse que o código identificador na etiqueta das paletes tinha letras muito pequeninas e ele tinha muita dificuldade em lê-lo.

Procurar uma BADI no palheiro

Mon, 14 Jun 2010 10:46:04 +0000

O SAP é um enorme palheiro. E os ABAPers são pessoas que trepam por esse palheiro acima e nele vasculham e escarafuncham em busca de agulhas de todo o género. Às vezes, desesperados, deitam-se a descansar e vêm uma quantidade enorme de bicharocos que vivem no palheiro fazer-lhes comichão. Para evitar que isso aconteça, o Artur Moreira propõe-nos uma série de diferentes técnicas para procurar BADIs neste grande palheiro que é o SAP.

Enfiar um browser dentro do SAPGui

Thu, 10 Jun 2010 20:01:45 +0000

Quem não gosta de uma promiscuidadezita de vez em quando? Até o Abapinho. É por isso que hoje vos sugerimos que se deleitem a enfiar um browser dentro do SAPGui. E para conseguir isso basta correr este programa na SE38: SAPHTML_R3HTTP_DEMO. Pronto, ficam a saber. E como há clientes para tudo, quem sabe não se encontre aí pelo mundo algum cliente que invente um problema para esta solução. O Abapinho saúda-vos.

ZTETRIS

Sun, 09 May 2010 15:56:34 +0000

O Abapinho aconselha todos os ABAPers a, pelo sim, pelo não, instalarem o programa ZTETRIS no seu ambiente de desenvolvimento. A versão do Tetris para ABAP é da autoria de Sergey Shumakov. Quando te fartares de jogar podes sempre investigar como é que o programa faz para ir várias vezes ao servidor sem intervenção do utilizador. O Abapinho saúda-vos.

ALV Grid Control - Manuais de referência

Tue, 04 May 2010 06:15:24 +0000

Os ALVs são poderosos. Mas esse poder vem à custa de alguma complexidade. Além disso, como quase tudo em SAP, funcionam de forma obscura. Aqui ficam dois manuais de referência em PDF. São muito parecidos mas suficientemente diferentes para referir os dois. Este chama-se BCSRVALV, é da SAP e data de 2001. No site da SAP encontra-se aqui. E aqui também se aprende sobre isto. Já este chama-se ALV_Grid_Control, é de 2004 e está assinado por um senhor chamado Serdar ŞİMŞEKLER que diz ser turco.

Transportar conteúdo de uma tabela

Thu, 29 Apr 2010 11:26:54 +0000

Fazes assim: Vais à transacção SE01; Crias uma nova ordem de workbench; Editas a lista de objectos; Adicionas-lhe o objecto R3TR-TABU-[nome_tabela]; Clicas na chave que aparece na coluna a seguir; Metes um asterisco * na primeira linha; Gravas a ordem de transporte; Pedes a quem de direito para a passar para onde te aprouver; Vais beber um sumo de melão; Quando voltas, já está. O Abapinho saúda-vos.

Glossário SAP

Tue, 27 Apr 2010 10:09:32 +0000

É frequente em SAP cruzarmo-nos com um conceito desconhecido. Às vezes esqueço-me de que há ferramentas disponíveis muito fáceis de consultar. E o glossário SAP é um exemplo disso. Pode ser acedido de várias formas: No próprio SAP: através da transacção STERM; Online: num site da SAP: https://help.sap.com/saphelp_glossary/en/; No nosso computador: usando o programa ABAP GLOS_DOWNLOAD_HTML para fazer download de todo o seu conteúdo. Tenho a certeza de que, agora que sei onde está, o vou consultar muito mais vezes.

Evernote - No anotar é que está o ganho

Mon, 19 Apr 2010 17:00:15 +0000

Il faut cultiver notre jardin - Voltaire

No SAP fala-se muito de experiência. Fulano tem muita experiência, sicrano tem pouca experiência. Tenta-se com isso medir a capacidade que alguém tem de usar o seu passado para lidar com o seu futuro. Mas nem sempre ter experimentado uma coisa é sinónimo de ganhar experiência com ela. O exemplo paradigmático ao alcance de todos é o amor: quantos desgraçados, por muitas experiências desgraçadas que tenham tido, se continuam a desgraçar-se no amor! O SAP não é o amor. Ainda assim não nos faltarão exemplos de consultores que no CV descrevem muitas experiências e na prática se revelam uns grandes inexperientes.

A Inteligência terá certamente muito peso nessa capacidade de sublimar as experiências, de as conservar, de fazer delas Compota de Experiência. Mas, pelo menos no que toca ao mirabolante mundo do SAP, quem tem também muito a dizer é a senhora Memória. Ou melhor dizendo, a falta dela.

O mundo do SAP é horizontal e vasto. Para onde quer que se olhe é a perder de vista. E embora seja um mundo bastante populado e onde se viaja muito, não houve até hoje, que eu saiba, cartógrafos de jeito. Os mapas que dele se fizeram são parcos, pobres, distorcidos e normalmente ainda o julgam plano quando toda a gente já sabe há muito tempo que ele é curvo.

Há que cartografar o nosso mapa.

Onde é que eu vi aquilo?

Wed, 04 Nov 2009 04:09:36 +0000

A pesquisa de objectos em ABAP e por todo o SAP é normalmente feita de duas formas: listando objectos de um tipo através de search helps ou procurando objectos em que um determinado objecto é usado, através da opção where used. Só que às vezes o que buscamos não se trata de um objecto mas sim de uma frase qualquer ou mesmo um comentário que sabemos existir no código mas não fazemos ideia de onde.

A técnica das Matrioskas

Fri, 09 Oct 2009 13:00:55 +0000

É sabido que quando é necessário fazer uma pequena alteração a uma função standard para a qual não há nenhum tipo de user-exit, o mais normal é fazer uma cópia dela para uma função Z e lá proceder à alteração necessária. No entanto, quando esta alteração pode ser feita no início ou no final do programa, há uma forma mais elegante de conseguir o mesmo resultado: a técnica das Matrioskas. Criar uma função Z com os mesmos parâmetros que lá dentro invoca a função standard e que, além disso, antes ou depois de a invocar, tem o código para implementar a alteração necessária.

O maravilhoso mundo do Application Log

Sat, 19 Sep 2009 09:51:49 +0000

Uma boa parte dos reports, interfaces ou jobs, têm de produzir algum tipo de relatório. É normal ver isso feito recorrendo ao comando WRITE. Ora nos dias que correm, usar o comando WRITE para isto é como recorrer a um par de pedras para acender uma fogueira. Afinal, porque não usar o Application Log que é muito mais simples e prático e standard e é só vantagens?

Macros - Velocidade de ponta

Wed, 16 Sep 2009 02:37:52 +0000

Normalmente quando há um pedaço de código que pretendemos reutilizar várias vezes, transformamo-lo numa sub-rotina que pode depois ser invocada repetidamente. Embora a SAP não saiba estruturar o seu próprio código, ainda assim, o ABAP, coitadinho, permite-o. E até disponibiliza várias alternativas para modularizar o código. Eu conto quatro alternativas que listo aqui, da mais rígida para a mais flácida: METHOD, FUNCTION, FORM, DEFINE. Se os 3 primeiros são já familiar de todos, o último - DEFINE - quase ninguém usa. O DEFINE permite definir macros em ABAP. E o que são macros? São sub-rotinas aparentes.

Aparentes porquê?

Evitar mensagens dinâmicas

Mon, 07 Sep 2009 17:40:15 +0000

Qual é, digam lá, a melhor coisinha que o ABAP tem? É, digo eu, poder fazer where used em cima de tudo o que mexe. E no entanto, esta maravilhosa funcionalidade só funciona maravilhosamente quando as coisas não são invocadas dinamicamente. Eu uso o where used amiúde para descobrir onde uma determinada mensagem está a ser usada. Ora não é nada incomum encontrar chamadas dinâmicas a mensagens, principalmente em casos onde as mensagens não são enviadas directamente para o utilizador mas sim, por exemplo, para o Application Log.

READ TABLE blablabla TRANSPORTING NO FIELDS

Thu, 20 Aug 2009 04:51:19 +0000

Por vezes ao fazer READ TABLE a uma tabela interna queremos apenas verificar se um determinado registo existe, e não nos preocupamos com os dados retornados. Algo tipo: READ TABLE lt_kna1 INTO wa_kna1 WITH KEY kunnr = l_kunnr. CHECK SY-SUBRC = 0. Ora já que a estrutura WA_KNA1 não vai ser necessária de qualquer forma, mais vale não a usar, usando antes a opção TRANSPORTING NO FIELDS: READ TABLE lt_kna1 TRANSPORTING NO FIELDS WITH KEY kunnr = l_kunnr.

Pesquisa SAP no Firefox e no Internet Explorer

Thu, 18 Jun 2009 14:44:23 +0000

Quando se faz desenvolvimentos em ABAP, pesquisar na SAP Community ou nas notas e na documentação da SAP é uma actividade recorrente. Como tal, quanto mais fácil for fazê-lo, melhor. Ideal seria que fazê-lo fosse tão fácil como pesquisar no Google. Ora uns senhores chamados JNYSolutions tornaram isso possível criando plugins de pesquisa para o Firefox e o Internet Explorer que adicionam a SDN, as notas e a documentação da SAP como motores de busca.

Verificar pasta

Sat, 13 Jun 2009 20:40:29 +0000

Eis uma função para verificar se uma pasta existe e se nela temos permissões de escrita. PARAMETERS: p_dir TYPE btctext80 DEFAULT '/usr/sap/trans'. CALL FUNCTION 'PFL_CHECK_DIRECTORY' EXPORTING directory = p_dir write_check = 'X' * FILNAME = ' ' EXCEPTIONS pfl_dir_not_exist = 1 pfl_permission_denied = 2 pfl_cant_build_dataset_name = 3 pfl_file_not_exist = 4 others = 5. CASE sy-subrc. WHEN 0. WRITE /: 'Directory:', p_dir, ' exists'. WHEN 1. WRITE /: 'Directory does not exist:', p_dir.

Constantes inconstantes

Tue, 02 Jun 2009 15:24:07 +0000

As constantes não o são. Toda a gente sabe. Quando se define uma constante, é certo como a morte que mais cedo ou mais tarde alguém vem e muda-a. Quando isto acontece, quem usa os valores directamente no código ABAP está feito ao bife; Quem define constantes no código só tem de alterar o valor num sítio mas vê-se ainda assim obrigado a editar o programa e a transportá-lo, coisa que, dependendo do grau de burocracia do ambiente em que se está, se pode revelar complicada. Este artigo apresenta uma solução simples mas sofisticada para gerir de forma centralizada todas as constantes de um sistema SAP através do uso de uma tabela de utilizador central onde se manterá todos os valores constantes e de uma classe com alguns métodos estáticos que serão usados para os obter.

Testar na SE37 não grava dados? Grava.

Wed, 20 May 2009 10:40:40 +0000

Uma forma prática de aprender a usar um módulo de funções ou verificar se este nos é útil é através da funcionalidade de teste da transacção SE37. Escolhe-se o módulo de função, faz-se F8 (Executar) e tem-se uma forma interactiva de testar uma função. Isto é óbvio. O que não será óbvio para toda a gente é que este teste não faz COMMIT à transacção e, por isso, qualquer alteração que a função possa fazer à base de dados - como gerar um documento por exemplo - não é gravada.

A transacção N

Thu, 14 May 2009 12:44:21 +0000

É intrigante o porquê de, nos dias que correm, a transacção SE16 continuar a ser tão utilizada, quando já existe há tantos anos uma muito melhor, a SE16N. A transacção SE16N tem mais: sainete: tem um interface mais dinâmico e sofisticado; simpatia: mostra em simultâneo a descrição funcional e o nome técnico dos campos; sabedoria: mostra em simultâneo o valor interno e externo dos campos com rotinas de conversão; E pode, vejam só, ser também invocada através da transacção N.

Melhorar os melhoramentos

Fri, 20 Mar 2009 10:17:37 +0000

No princípio era o INCLUDE.

Depois vieram os CMODs,
Seguiram-se logo as BADIs,
Agora são os Enhancements.
E no entanto, o caos continua.

Crítica Na maior parte dos projectos SAP em que já trabalhei, a metodologia de utilização de todas estas modificações é a tudo-ao-molho-e-fé-em-SAP e é normal encontrar num único include - como o MV45AFZZ - extensões de código tão grandes que, se o SAP fosse a princesa Rapunzel, dava para lhe fazer umas tranças até cá abaixo para o príncipe subir à sua torre. Este código normalmente implementa várias funcionalidades diferentes e independentes que, ao longo do tempo, se vão emaranhando quase irreversivelmente umas nas outras (tipo trança mesmo). Como consequência, qualquer alteração ao código existente requer cuidados redobrados e é sempre vista como um risco para o funcionamento de tudo o que lá está.

Venho aqui propor uma solução simples e eficaz para este problema.

Change pointers

Thu, 19 Mar 2009 17:07:02 +0000

Neste artigo tento explicar o que são change pointers e revelar como são úteis e fáceis de usar.

O que é um change pointer Um change pointer é um mecanismo de registo de alteração de dados baseado em change documents desenvolvido pela SAP especialmente para ALE. Permite saber, de forma simples e eficiente, quais os registos alterados em uma ou nas várias tabelas por ele monitorizadas. Os change pointers são utilizados maioritariamente como gatilhos para a criação de IDOCs. Mas não devem ser vistos apenas como tal e espero que este artigo traga alguma luz a este mecanismo tão útil mas tão descurado no SAP.

O Abapinho saúda-vos

Thu, 19 Mar 2009 10:51:11 +0000

Bem-vindo ao Abapinho, um blog sobre ABAP em português.