estilo on Abapinho

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.

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”?

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.

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.

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.

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.

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.

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.

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.

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 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.

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.

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.

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.

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.

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.

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.

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.”

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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?

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.

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,

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.

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?

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.

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.

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.

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;

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.

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)

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;

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).

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.

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.

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:

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.

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.

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.

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.

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…..

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.

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:

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

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.

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.

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.

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?

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.

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.

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?

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.

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.

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.

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'.

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.

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.

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.

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.