artigos on Abapinho

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.

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.

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.

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.

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.

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.

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.

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.

Can your users hack your SQL?

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

Are you sure your SQL is bulletproof?

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.

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.

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.

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.

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.

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

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.

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?

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.

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.

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.

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.

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

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.

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.

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.

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:

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.

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.

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.

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?

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:

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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?

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.

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.

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.

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.

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.

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

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.

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

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

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.

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.

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.

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.

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

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.

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.