To be honest, I feel a little bit uncomfortable writing this blog, because I think that all about this subject is said since long. But a recent discussion shows, that even experienced ABAPers can stumble over the handling of trailing blanks in character string processing from time to time. So why not summarize it. You can skip reading, if you know it all ...

For character string processing ABAP provides mainly two built-in types, c and string. Text fields of type c are flat and have a fixed length, text strings of type string are deep and have a dynamic length. Besides that, there is another major difference between text fields of type c and text strings of type string:

While trailing blanks are always relevant in strings, they are ignored in text fields in many operand positions of statements, especially in source fields of assignments. As a rule: When working with text fields of type c you always should look into the ABAP Keyword documentation and check whether trailing blanks are skipped or kept in the respective statement.

Example:

    DATA: text_space   TYPE c LENGTH 1 VALUE ' ',

          string_space TYPE string VALUE ` `,

          result1      TYPE string,

          result2      TYPE string.

    result1 = 'Word' && text_space   && 'Word'.

    result2 = 'Word' && string_space && 'Word'.

The result of the concatenation when using text_space is „WordWord“ and the result when using  string_space is „Word Word“. The trailing blank - which is also the only character of text_space - is ignored in the text field. Be aware that the built-in constant space would have same behavior as text_space here!

And now watch out! The behavior regarding trailing blanks also concerns literals. We have two kinds of character literals in ABAP,

• text field literals '...' of type c
• text string literals `...` of type string

It seems to be trivial, but one might tend to forget: What is said above about trailing blanks in c and string fields holds for the respective literals too. Especially text field literals '...' can be rather nasty. Trailing blanks are not kept in many positions and that means that a text field literal containing one blank ' ' is often treated like an empty string. The problem is, it's not WYSIWIG. You see a blank in the code but you don't get it.

Examples:

DATA text TYPE string.

text = ' '.

text is an empty string of length 0.

DATA text TYPE string VALUE `blah_blah_blah`.

REPLACE ALL OCCURRENCES OF '_' IN text  WITH ' '.

text contains "blahblahblah".

IF ` ` =  ' '.

  BREAK-POINT.

ENDIF.

A running gag!

By the way, the concatenation operator && skips trailing blanks while the literal operator & keeps them:

DATA text TYPE string.

text = 'Word ' && 'Word'.

text = 'Word ' &  'Word'.

The results are "WordWord" and "Word Word" respectively, oh my.

But that's still not enough, there's also another way around!

DATA text TYPE string.

CONCATENATE 'Word' 'Word' INTO text SEPARATED BY ''.

The result is "Word Word" with a blank! There is no empty text field literal '' in ABAP. It is always replaced by ' '. You don't realize that in statements where trailing blanks are skipped. But behind SEPARATED BY they are kept!

Confused?

Rules of thumb:

• Don't use trailing blanks in text field literals '...' of type c in operand positions where they are skipped
• Always use text string literals `...` of type string, if you want to preserve trailing blanks in literals

B.t.w., string templates |...| have type string and trailing blanks are preserved, of course. The logical expression ` ` = | | is true.

With ABAP 740, a new feature was introduced called "Constructor expressions". First I was sceptical about their usefulness, and it seemed to me that they make the coding more complicated and more difficult to read. But since I am always very curious about new possibilities in programming, I decided to try them out, and I must admit that meanwhile I am a fan of them. In this post, I'd like to focus on VALUE, which I use frequently.

Coding examples

Look at these two examples from a mapping routine, taken out of a productive program of mine:

1. Without using VALUE:
   
   
   
   
2. Using VALUE:
   
   

Where's the difference?

One could say "where's the difference? No fewer coding lines, no saving of variable declaration!", which is all true. But there are two functional differences and one aesthetical.

The first functional difference is, that the target structure is initialized before assigning the values to it. If you ever forgot a "clear" statement before filling data structures, you will appreciate this effect.

The second comes out in debugging. The whole mapping of this structure will be done in the debugger with one single step. Of course, pressing F5 will bring you into the method determine_req_date, which is called by the expression, but the rest is done with one step. Do you remember, how often you were hammering F5 to step over a large mapping section, having to stop on every single assignment?

The second difference is about beauty and readability of the code. Using the constructor expression, you get one block for each structured element you populate, which leads to good readable coding even if the single module is quite long. Look at this example:

Do you get the Idea?

Conclusion

I'd appreciate to know your thoughts!

All the best

Jörg

Reports with class

In MVC (model view controller) framework for ABAP part 1 you can find the "starter kit" for a framework you can use to create applications that are using dynpros and CFW controls that the framework is able to control. In this second part I will introduce only one further class that can be used for report programming. In my daily work, I am using this report very frequently as a template for new ones.

The demo application

Just like the demo application in the first part, the application contains the framework class that you can extract to a public class for reusing the code.

Application screen You can upload the screen 0001 from the file attached. Other than in the first part, we do not need a subscreen here. All we need is an empty screen that is able to carry the docking container in which we will place an ALV with the result list.

Selection screen controller The selection screen is controlled by the new class ZCL_MVCFW_CON_SELSCR. The controller derives from the class ZCL_MVCFW_CON_DYNPRO and extends it only with two methods

How it works

In order to get everything to work, a few steps are necessary. Let's go through it step by step.

Selection screen interface To simplify the passing of selection screen parameters between the classes, I use always a local interface that contains a structured type with all input elements from the selection screen

You can see that I use the same names for the components as for the selection screen elements:

Global data Some global variables are indispensible:

INITIALIZATION Here the main controller is instantiated. After that, the get_con_dynpro method is called to create a controller for the actual dynpro, which is the selection screen.

PAI The PAI event of a selection screen is at selection-screen, so we call the PAI of the screen controller, which is a framework method that does the following:

• Ask the main controller to fetch the screen data.
  • Therefore, the method get_screen_data of the main controller must be redefined:
    
    As you see, the data is stored in an attribute of the main controller. This can be useful, if you want to react to user inputs during PBO, i.e. switching on/of field attributes and so on.
• Invoke the PAI of the super class, which will compare all component values from the screen with the stored ones in the memory of the framework class ZCL_MVCFW_DYNPRO and call PAI_FIELD_CHANGE on change of values.

START-OF-SELECTION The method run of the selection-screen controller is called.

RUN The control is passed to the main controller (run_program), where the main logic of the report begins to work.

Batch/Online processing As you can see in run_program, there are two branches, one for background processing and one for online. The online branch is similar to the demo in part 1. For the batch processing, a list has to be created instead of calling a screen. Therefore, a list controller has been added to the program, which we derive from the generic CFW controller.

Of course we do not have any CFW control here. But the framework class can be used even without container. In method refresh the output is coded. In this case, I use CL_SALV_TABLE to produce an output list.

Some notes

I some of my use cases, I use more than one model class because of complexity of the application. In this case, it comes handy to declare common used data types in the interface lif_report.

All the best

Jörg

In this short blog I will use the most primitive example to show you the way from joins in ABAP Open SQL to associations in ABAP CDS.

The aim of the blog is not to show you something you should do but to gain a basic understanding of associations in CDS views.

Step 1, Join in Open SQL

I will start with the following very simple INNER JOIN between database tables SPFLI and SCARR from the good ol' flight model in Open SQL in the ABAP Editor (either WB or ADT in Eclipse):

SELECT FROM spfli

               INNER JOIN scarr ON

                  spfli~carrid = scarr~carrid

       FIELDS scarr~carrname  AS carrier,

              spfli~connid    AS flight,

              spfli~cityfrom  AS departure,

              spfli~cityto    AS arrival

       ORDER BY carrier, flight

       INTO TABLE @DATA(result_open_sql_join).

Nothing special about that and the result shown with CL_DEMO_OUTPUT looks as follows:

Step 2, Join in ABAP CDS

Now let's transform the above ABAP code into the DDL of an ABAP CDS view in the DDL source code editor of ADT in Eclipse:

@AbapCatalog.sqlViewName: 'DEMO_CDS_JN1'

@AccessControl.authorizationCheck: #NOT_REQUIRED

define view demo_cds_join1

  as select from spfli

    inner join   scarr on

      spfli.carrid = scarr.carrid

  {

    scarr.carrname  as carrier,

    spfli.connid    as flight,

    spfli.cityfrom  as departure,

    spfli.cityto    as arrival

  }

This can almost be done by copy and paste. Hey, it's (almost standard) SQL for both.

After activating this view you can use the data preview of ADT (F8) or acces it with Open SQL:

SELECT FROM demo_cds_join1

       FIELDS *

       ORDER BY carrier, flight

       INTO TABLE @DATA(result_cds_join).

It is not too surprising that result_cds_join and result_open_sql_join contain exactly the same data.

Step 3, Association in ABAP CDS

Finally, I will use the advanced modelling capabilty of ABAP CDS and transform the explicit join into an association of another view:

@AbapCatalog.sqlViewName: 'DEMO_CDS_JN2'

@AccessControl.authorizationCheck: #NOT_REQUIRED

define view demo_cds_join2

  as select from spfli

  association to scarr as _scarr on

    spfli.carrid = _scarr.carrid

  {

    _scarr[inner].carrname as carrier,

    spfli.connid           as flight,

    spfli.cityfrom         as departure,

    spfli.cityto           as arrival

  }

The association _scarr is declared once behind the keyword association and can be used at several places inside the view in path expressions. You can also publish it for usage in other views or in Open SQL, but I have not done that here.

For our simple example, I use the path expression _scarr[inner].carrname as the first element of the select list. When using a path expression, the associations listed there are internally transformed to joins. In the select list those joins are left outer joins by default. Therefore, I override the default with [inner] in order to enforce an inner join. You can check the result by displaying the SQL DDL (shown for HANA here) that is generated from the ABAP CDS DDL in ADT (Context menu Show SQL CREATE statement):

CREATE VIEW "DEMO_CDS_JN2" AS SELECT

  "SPFLI"."MANDT" AS "MANDT",

  "=A0"."CARRNAME" AS "CARRIER",

  "SPFLI"."CONNID" AS "FLIGHT",

  "SPFLI"."CITYFROM" AS "DEPARTURE",

  "SPFLI"."CITYTO" AS "ARRIVAL"

FROM "SPFLI" "SPFLI" INNER JOIN "SCARR" "=A0" ON (

  "SPFLI"."MANDT" = "=A0"."MANDT" AND

  "SPFLI"."CARRID" = "=A0"."CARRID"

)

You see, we end up with something well known.

And of course, the data preview of ADT (F8) or the following Open SQL retrieve again the same data as before:

SELECT FROM demo_cds_join2

       FIELDS *

       ORDER BY carrier, flight

       INTO TABLE @DATA(result_cds_assoc).

With other words, no exceptions from

ASSERT result_cds_join  = result_open_sql_join.

ASSERT result_cds_assoc = result_cds_join.

Conclusion

The aim of this simple example is to show you that CDS associations are nothing but specifications of joins in a central position. These joins are instantiated in native SQL when using associations in path expressions.

The benefits of using associations are not shown in the simple example here. The advanced modelling capabilities stem from the reuse of the associations (meaning their joins) in different positions. Of course,  path expressions can contain more than one association, relieving you from the task of coding complex join expressions.  Such path expressions can be used in the same or other CDS views and even in Open SQL (if published by the defining view).

I would like to share my approach of using exception classes and transport t100 messages inside of them. For one single message, there is nothing to talk about, you simply include the t100 interface and pass the message to the exception class. But what if you would like to pass a list of messages to the caller?

Using an application log (BAL)

In the past, I often proceeded like this: I created an object that manages the message list (the BAL_ functions). The SAP class CL_RECA_MESSAGE_LIST is great in doing this job. Then, I passed this object to the classes I invoke so these classes can collect messages there. In case of an error, I just had to use the message list to show a popup with all the messages.

The problem here is, that each caller of the class must provide a log object and all classes involved must have this global object for logging. That's not a really big thing, but I wasn't satisfied with the solution. So I came to a new approach, which is including the log in the exception class and passing it in this way.

The logged exception class

To try it yourself, you first need an exception class that contains a log object (based on CL_RECA_MESSAGE_LIST). Let's go:

Add the attribute for the log. The referenced type is IF_RECA_MESSAGE_LIST

And create a getter method for the log:

Activate the class.

Demo Application

The demo application has a controller and a model class. On running, the controller instantiates the model and calls the read method. Here an error is provocated and the message is being captured in the log. Then the log is passed to the exception object.

The main controller catches the exception and uses the log object to display the error in a popup.

Here is the code:

*&---------------------------------------------------------------------*
*& Report  ZP_TOOL_TEST_LOGGED_EXC
*&
*&---------------------------------------------------------------------*
*&
*&
*&---------------------------------------------------------------------*
report zp_tool_test_logged_exc.

class lcl_controller definition.

   public section.
     methods run.

   private section.
     methods error
       importing io_log type ref to if_reca_message_list.

endclass.

class lcl_model definition.

   public section.
     methods read raising zcx_tool_logged.

endclass.

start-of-selection.

   new lcl_controller( )->run( ).

class lcl_controller implementation.

   method run.
     " create model.
     data(lo_model) = new lcl_model( ).

     try.
         lo_model->read( ).
       catch zcx_tool_logged into data(lo_err).
         " call error handling (which shows the log)
         error( lo_err->get_log( ) ).
         " show the log
     endtry.
   endmethod.

   method error.

     call function 'RECA_GUI_MSGLIST_POPUP'
       exporting
         io_msglist                   = io_log
       .

     io_log->clear( ).
   endmethod.
endclass.

class lcl_model implementation.

   method read.
     data lo_messages type ref to if_reca_message_list.

     lo_messages = cf_reca_message_list=>create( ).

     " provocate an error

     message e000(0k) with 'Some application error' into sy-msgli.
     lo_messages->add_symsg( ).
     raise exception type zcx_tool_logged exporting mo_log = lo_messages.

   endmethod.

endclass.

Some notes

The log is kept local in the model here. If your model is more complex. it might be that you collect messages in various methods. In this case, it could make sense to create a class-global log. Make sure to clear the log after having displayed the message, so no previous messages will show up (see io_log->clear( )  in method error).

As you see in read the message is created with a standard MESSAGE statement, which captures the text in a dummy variable. This makes it simple to code the message and it will also update the where-used list of the message id in your system. I find this very useful. After the MESSAGE statement, a simple call of lo_messages->add_symsg( ) puts the values of SY-MSGNO, SY-MSGID and so on into the log. Afterwards the exception is raised passing the log into the exeption object.

If you do not know yet CL_RECA_MESSAGE_LIST, it's worth a look. It's full of useful methods!

Not every day.... but from time to time there is a question about synchronize scrolling in ALV .

This article will demonstrate my attempt for horizontal scrolling .

Program Y_R_EITAN_TEST_08_02 use cl_gui_alv_grid.

CL_GUI_ALV_GRID have a method (SET_SCROLL_INFO_VIA_ID) that allows us to scroll to a given column name .

The same method also allow us to scroll to a given line number (this is not covered in this program)

For demonstration purpose the program create an empty internal table of type MARA .

The scrolling is done in  METHOD user_command_scroll ( I put some comments there....).

Output:

Happy scrolling....

It is a common programming pattern to fill a character string in iterative steps, either using the concatenation operator && or character string templates |...|:

DO|WHILE|LOOP|SELECT ...

  str = str && ...

  str = |{ str }...|.

ENDDO|END|ENDWHILE|ENDSELECT ...

Bad News

Both assignments have a string expression as an RHS (right hand side) . What does that mean? As a rule, when assigning an expression, a temporary or intermediate result is created that must be copied to the LHS (left hand side). Since the length of the intermediate result increases with each loop pass and there is a copy operation for each loop pass, the runtime dependency from the number of loop passes is quadratic. Not good.

Good News

Since this is a well known fact, there is an internal optimization for all concatenations that look as follows:

str = str && dobj1 && dobj2 && ... .

str = |{ str }...{ dobj1 [format_options] }...{ dobj2 [format_options] }...|.

As long

• as the target string str occurs at the RHS only once and as the leftmost operator,
• and as long as there are no formatting options for str ,
• and as long as there are no other expressions or function calls involved in the RHS

no intermediate result is created but the characters are concatenated directly to the target stringstr. This prevents the quadratic dependency of the runtime from the number of iterations. The same is true for the CONCATENATE statement.

With other words, no problems in writing something like this:

DATA(html) = `<html><body><table border=1>`.

DO ... TIMES.

  html = |{ html }<tr><td>{ sy-index }</td></tr>|.

ENDDO.

html = html && `</table></body></html>`.

There is a simple data object sy-index concatenated to a target string html and the optimization takes place.

Bad News

The optimization only takes place for the simple cases above!

And this is the trap.

You loose the optimization, if you loop over concatenations that look as follows:

str = str && ... && meth( ... ) && ... .

str = str && ... && str && ... .

str = |{ str }...{ expr( ... ) }...|.

str = |{ str format_options }...|.

str = |{ str }...{ str }...|.

As long as you do such a concatenation outside of loops, no problem. But inside of loops and for a large number of iterations you can quickly experience really large runtimes.

There is in fact a problem, writing something looking as harmless like this:

DATA(html) = `<html><body><table border=1>`.

DO ... TIMES.

  html = |{ html }<tr><td>{

            CONV string( ipow( base = sy-index exp = 2 ) )

            }</td></tr>|.

ENDDO.

html = html && `</table></body></html>`.

Concatenating the ipow expression to str breaks the optimization.

Good News

Now that you know the problem, you can easily circumvent it. Normally we use expressions to get rid of helper variables. But in connection with loops helper variables can be a good thing. You already know that you use  them for calculating results that are constant within a loop. Now you learn, that you should also use them for concatenating expressions or functions to strings:

DATA(html) = `<html><body><table border=1>`.

DATA square type string.

DO ... TIMES.

   square = ipow( base = sy-index exp = 2 ).

   html = |{ html }<tr><td>{ square }</td></tr>|.

ENDDO.

html = html && `</table></body></html>`.

By assigning the ipow expression to helper variable square and concatenating that to str,  the optimization takes place again. Try it yourself and see what happens for large numbers of iterations with and without optimization!

Last but not least, what is said above for loops realized by control statements is also true for FOR loops in expressions:

DATA(result) =

  REDUCE string( INIT s = ``

                 FOR i = 1 UNTIL i > ...

                 NEXT s = s && CONV string( i ) ).

vs.

DATA(result) =

  REDUCE string( INIT s = ``

                 FOR i = 1 UNTIL i > ...

                 LET num = CONV string( i ) IN

                 NEXT s = s && num ).

Only by using the helper variable num declared in a LET expression the optimization is enabled. The example without helper variable shows a quadratic increase of runtime with the number of iterations.

The last example is directly taken from the recent documentation. But have you been aware of that?

Hello community,

with a tiny trick is it easy possible to use recoreded Microsoft Office VBA (Visual Basic for Applications) code in ABAP.

To do that I use only the Microsoft Script Control, with a little preparation for Excel. Then I read the content from an include, which contains the recorded VBA code. I concatenate the VBScript and VBA code and then I execute it - that's all.

The only thing which is in addition to doing, is to set a point in front of each line of the VBA code. This is necessary because I use oExcel object in VBScript code.

Here an example report:

"-Begin-----------------------------------------------------------------

Report zExcelViaVBScript.

  "-Type pools----------------------------------------------------------

    Type-Pools:

      OLE2.

  "-Constants-----------------------------------------------------------

    Constants:

      CrLf(2) Type c Value cl_abap_char_utilities=>cr_lf.

  "-Variables-----------------------------------------------------------

    Data:

      oScript Type OLE2_OBJECT,

      VBCode Type String,

      VBACode Type String.

  "-Main----------------------------------------------------------------

    Create Object oScript 'MSScriptControl.ScriptControl'.

    Check sy-subrc = 0 And oScript-Handle > 0 And oScript-Type = 'OLE2'.

    "-Allow to display UI elements--------------------------------------

      Set Property Of oScript 'AllowUI' = 1.

    "-Intialize the VBScript language-----------------------------------

      Set Property Of oScript 'Language' = 'VBScript'.

    "-Code preparation for Excel VBA------------------------------------

      VBCode = 'Set oExcel = CreateObject("Excel.Application")'.

      VBCode = VBCode && CrLf.

      VBCode = VBCode && 'oExcel.Visible = True'.

      VBCode = VBCode && CrLf.

      VBCode = VBCode && 'Set oWorkbook = oExcel.Workbooks.Add()'.

      VBCode = VBCode && CrLf.

      VBCode = VBCode && 'Set oSheet = oWorkbook.ActiveSheet'.

      VBCode = VBCode && CrLf.

      VBCode = VBCode && 'With oExcel'.

      VBCode = VBCode && CrLf.

      "-Add VBA code----------------------------------------------------

        Call Function 'ZREADINCLASSTRING'

          Exporting I_INCLNAME = 'ZEXCELTEST'

          Importing E_STRINCL = VBACode.

        VBCode = VBCode && VBACode.

      VBCode = VBCode && 'End With'.

      VBCode = VBCode && CrLf.

    "-Execute VBScript code---------------------------------------------

      Call Method Of oScript 'ExecuteStatement' Exporting #1 = VBCode.

    "-Free the object---------------------------------------------------

      Free Object oScript.

"-End-------------------------------------------------------------------

Here the function module to read an include as string:

"-Begin-----------------------------------------------------------------

  Function ZREADINCLASSTRING.

*"----------------------------------------------------------------------

*"*"Local Interface:

*"  IMPORTING

*"     VALUE(I_INCLNAME) TYPE  SOBJ_NAME

*"  EXPORTING

*"     VALUE(E_STRINCL) TYPE  STRING

*"----------------------------------------------------------------------

    "-Variables---------------------------------------------------------

      Data resTADIR Type TADIR.

      Data tabIncl Type Table Of String.

      Data lineIncl Type String Value ''.

      Data strIncl Type String Value ''.

    "-Main--------------------------------------------------------------

      Select Single * From TADIR Into resTADIR

        Where OBJ_NAME = I_InclName.

      If sy-subrc = 0.

        Read Report I_InclName Into tabIncl.

        If sy-subrc = 0.

          Loop At tabIncl Into lineIncl.

            Concatenate strIncl lineIncl cl_abap_char_utilities=>cr_lf

              Into strIncl.

            lineIncl = ''.

          EndLoop.

        EndIf.

      EndIf.

      E_strIncl = strIncl.

  EndFunction.

"-End-------------------------------------------------------------------

Here my VBA example code, which is stored in the include ZEXCELTEST:

.Range("A1").Select

.ActiveCell.FormulaR1C1 = "1"

.Range("A3").Select

.ActiveCell.FormulaR1C1 = "2"

.Range("A5").Select

.ActiveCell.FormulaR1C1 = "3"

.Range("B2").Select

.ActiveCell.FormulaR1C1 = "4"

.Range("B4").Select

.ActiveCell.FormulaR1C1 = "5"

.Range("C3").Select

.ActiveCell.FormulaR1C1 = "6"

.Range("C4").Select

This code is a directly copied and pasted from the VBA IDE (only with a point in front of each line):

Here the result in Excel:

Enjoy it.

Cheers

Stefan

See also:  MVC (model view controller) framework for ABAP part 1

MVC (model view controller) framework for ABAP part 2

Controlling multiple screens

Welcome back to my MVC series. To follow this blog, it is necessary that you install the classes provided in the first two parts (see links above). In part 1 you see a demo application that controls a dynpro and an ALV control. In the second part, I wrote about a report-type program that controlled a selection screen and an ALV control, but no standard dynpro fields. This time I would like to focus on standard dynpros, especially the case, when you have more than one of them.

Installing the demo application

Download the attached file and paste the content into a new report type program. Then create the main screen, which contains only one big subdynpro area (see part 1 for further explanations about the dynpro concept of the framework). After that, create the two sub dynpros 0100 and 0200 as described below. Last, I also included a popup screen 0300 which is controlled by the same framework controller type that contols also the sub dynpros.

Main screen 0001

Attributes:

Screen elements:

(create the subscreen area using the screen painter and make it as big as the whole screen)

Flow logic:

process before output.

   module pbo_0001.

   call subscreen subscreen including sy-repid gv_subdyn.

*
process after input.
   module pai_0001 at exit-command.
   call subscreen subscreen.
   module pai_0001.

Sub dynpro 0100

Attributes:

Elements:

Flow logic:

PROCESS BEFORE OUTPUT.
   MODULE pbo_0100.
*
PROCESS AFTER INPUT.
   module pai_0100.

Appearance:

Sub dynpro 0200

Copy dynpro 0100 to 0200. Then set the two input fields to "no input". Create a frame to for the data fields of the table spfli and put input fields into it. In the end, it should look like this:

Adjust the flow logic:

PROCESS BEFORE OUTPUT.
   MODULE pbo_0200.
*
PROCESS AFTER INPUT.
   module pai_0200.

Popup screen 0300

Create a modal dialog box containing the data fields of table SCARR. It should look like this:

All fields are display only. Important: use GV_OKCODE_0300 instead of GV_OKCODE:

Adjust the flow logic:

PROCESS BEFORE OUTPUT.
   MODULE pbo_0300.
*
PROCESS AFTER INPUT.
   module pai_0300.

GUI status and title

Create status 0100 with function key assignments:

Enter - ENTER

F3 - BACK

Shift+F3: EXIT (exit command)

ESC: CANC (exit command)

Copy the status to 0200 and add the following functions to the toolbar:

POPUP - Text "Carrier"

DELE - Text "Delete"

Create the status 0300 as a dialogbox status and add the function CANC to key ESC.

Last, create a titlebar MAIN with title "Sample for several dynpros"

How it works

As already discussed in part 1, there is only one main screen 0001. To switch between sub screens on the main carrier screen, the method SET_SUBDYNPRO of the framework class for the main controller is used. In the constructor of the main controller, it is set to 0100:

As you see, the method sets also the used GUI STATUS and the titlebar. All parameters are obtional, so you can use this also for setting only some of them. For example, you could call it to change the GUI STATUS only.

Managing sub dynpro flow

Each sub dynpro has its own controller (LCL_CON_DYNPRO_0100, LCL_CON_DYNPRO_0200). In the PBO and PAI modules, the controller is being fetched from the main controller and the control is being passed to the respective methods of the own dynpro controller.

Therefore, you have to redefine method CREATE_CON_DYNPRO:

On ENTER on the first screen 0100, the second screen is being called:

Note that before the new screen is called, the model is used to read the database. The values of the input fields have been passed already to the model in method PAI_FIELD_CHANGE:

Remember that PAI_FIELD_CHANGE will be called automatically from the framework as soon as the user types in something. It will be called for each field separately giving fieldname (IV_FIELDNAME) and value (IV_SOURCE) as a parameter. This method is intended also for input checks on field level.

During PBO of the main screen, then newly set MV_SUBDYNPRO will be passed to the flow logic and the new sub dynpro is being displayed in the SUBSCREEN area.

In PAI for 0200, we jump back to the last screen on user command BACK:

Exit commands must be treated by the main dynpro, so CANC, which also jumps back to sub screen 0100, but without considering inputs made. So the coding is located in the main PAI method:

Managing popups

The popup screen is managed in a similar way. But instead of setting the variable MV_SUBSCREEN, we have to use CALL SCREEN. In the 0200 user command method, the main controller is being called in order to do this:

You can place the call screen statement directly in the PAI_USER_COMMAND, if you want. But I prefer coding everything regarding the user interface flow in the main controller.

One important thing: use a different OKCODE for each popup screen you create. If you don't the OKCODE set during PAI of the popup will be processed once more in the main screen controller.

As single reaction to the user interface, we leave sthe screen on pressing the cancel button:

Conclusion

In the productive version of the framework in my company's system, there are some more controllers like one for dynamic documents (CL_DD_DOCUMENT) and one for the class I described in Using ALV to display/edit fields of a structure. Both of them are sub classes of the CFW controller class, just like the ALV controller described in part 1. I shared this basic version to inspire the reader to use it as a starting point for own developments.

All the best!

Jörg

Dear All,

There might be a requirement where you need to call standard IDoc's via custom program .

This can be achieved by MASTER_IDOC_DISTRIBUTE function module but this function module has some limitations and it creates both Inbound as well as Outbound Idoc.

Here i am not using above FM,and create a program with following FM's in the same sequence -

1. IDOC_CREATE_ON_DATABASE

2. BAPI_IDOC_INPUT1 (Depends upon the message type and function module configuration in WE57)

3. EDI_DOCUMENT_OPEN_FOR_PROCESS

4. EDI_DOCUMENT_STATUS_SET

5. EDI_DOCUMENT_CLOSE_PROCESS

Let us now understand how to use these function modules -

First you need to fill IDOC_DATA table of type- EDIDD .

1.IDOC_CREATE_ON_DATABASE

In this function module you have to pass IDOC_DATA and IDOC_CONTROL

2.BAPI_IDOC_INPUT1

Before using this function module , you have to ensure whether this function module is assigned with the required message type in WE57,If yes then go ahead and if no - You have to call the FM that is assigned in WE57 against your message type .

Here you have to pass -

idoc_contrl        fill the structure with all control parameters

idoc_data          pass as it is fetched from step-1

idoc_status        as blank

return_variables  as blank

serialization_info as blank

3. EDI_DOCUMENT_OPEN_FOR_PROCESS

Here you have to pass -

Document no i.e. IDOC no that is generated from step-2 in IDOC_DATA

En-queue Option as S

DB_Read Option as N

4. EDI_DOCUMENT_STATUS_SET

This Fm sets the status of your IDOC in standard.

Here you have to pass -

Document no i.e. IDOC no that is generated from step-2 in IDOC_DATA

IDOC_STATUS that is fetched from step-2 in IDOC_STATUS

5. EDI_DOCUMENT_CLOSE_PROCESS

here you have to pass document no and background as N.

Thanks and please let me know if there is any query.

Recently I stumbled over the examples in the documentation of built-in functions ROUND and RESCALE.

There are tables with results of these functions for different values of the arguments, but there was no coding example how to achieve these results. I guess,  the functions were called  with different arguments one by one and the results were copied into the documentation one by one.

But, hey, we have other possibilities in ABAP now and I've tried to recreate the results with CL_DEMO_OUTPUT and REDUCE (as a recreational measure so to say).

I cannot refrain from showing you that (a bit of showing off):

TYPES:
   BEGIN OF line,
     arg       TYPE i,
     result    TYPE decfloat34,
     scale     TYPE i,
     precision TYPE i,
   END OF line,
   result TYPE STANDARD TABLE OF line WITH EMPTY KEY.

DATA(val) = CONV decfloat34( '1234.56789 ' ).
DATA(out) = cl_demo_output=>new(
   )->begin_section( 'Value'
   )->write(
     |{ val
      }, scale = { cl_abap_math=>get_scale( val )
      }, precision = { cl_abap_math=>get_number_of_digits( val ) }|
   )->begin_section( 'Round with dec'
   )->write(
    REDUCE result(
      INIT tab TYPE result
      FOR i = -5 UNTIL i > 6
      LET rddec = round( val = val dec = i
          mode  = cl_abap_math=>round_half_up ) IN
      NEXT tab = VALUE #( BASE tab
       ( arg = i
         result = rddec
         scale = cl_abap_math=>get_scale( rddec )
         precision = cl_abap_math=>get_number_of_digits( rddec )
       ) ) )
   )->next_section( 'Round with prec'
   )->write(
    REDUCE result(
      INIT tab TYPE result
      FOR i = 1  UNTIL i > 10
      LET rdprec = round( val = val prec = i
          mode   = cl_abap_math=>round_half_up ) IN
      NEXT tab = VALUE #( BASE tab
       ( arg = i
         result = rdprec
         scale = cl_abap_math=>get_scale( rdprec )
         precision = cl_abap_math=>get_number_of_digits( rdprec )
       ) ) )
   )->next_section( 'Rescale with dec'
   )->write(
    REDUCE result(
      INIT tab TYPE result
      FOR i = -5 UNTIL i > 8
      LET rsdec = rescale( val = val dec = i
          mode  = cl_abap_math=>round_half_up ) IN
      NEXT tab  = VALUE #( BASE tab
       ( arg = i
         result = rsdec
         scale = cl_abap_math=>get_scale( rsdec )
         precision = cl_abap_math=>get_number_of_digits( rsdec )
       ) ) )
   )->next_section( 'Rescale with prec'
   )->write(
    REDUCE result(
      INIT tab TYPE result
      FOR i = 1  UNTIL i > 12
      LET rsprec = rescale( val = val prec = i
          mode   = cl_abap_math=>round_half_up ) IN
      NEXT tab = VALUE #( BASE tab
       ( arg = i
         result = rsprec
         scale = cl_abap_math=>get_scale( rsprec )
         precision = cl_abap_math=>get_number_of_digits( rsprec )
       ) ) )
   )->display( ).

Giving

...

Isn't REDUCE just awesome? For me, one of the most powerful of all the constructor operators. Use it to get used to it. Believe me, after some training, you even don't have to look up its documentation any more.

Dear All,

There might be a requirement where you need to call standard IDoc's via custom program .

This can be achieved by MASTER_IDOC_DISTRIBUTE function module but this function module has some limitations and it creates both Inbound as well as Outbound Idoc.

Here i am not using above FM,and create a program with following FM's in the same sequence -

1. IDOC_CREATE_ON_DATABASE

2. BAPI_IDOC_INPUT1 (Depends upon the message type and function module configuration in WE57)

3. EDI_DOCUMENT_OPEN_FOR_PROCESS

4. EDI_DOCUMENT_STATUS_SET

5. EDI_DOCUMENT_CLOSE_PROCESS

Let us now understand how to use these function modules -

First you need to fill IDOC_DATA table of type- EDIDD .

1.IDOC_CREATE_ON_DATABASE

In this function module you have to pass IDOC_DATA and IDOC_CONTROL

2.BAPI_IDOC_INPUT1

Before using this function module , you have to ensure whether this function module is assigned with the required message type in WE57,If yes then go ahead and if no - You have to call the FM that is assigned in WE57 against your message type .

Here you have to pass -

idoc_contrl        fill the structure with all control parameters

idoc_data          pass as it is fetched from step-1

idoc_status        as blank

return_variables  as blank

serialization_info as blank

3. EDI_DOCUMENT_OPEN_FOR_PROCESS

Here you have to pass -

Document no i.e. IDOC no that is generated from step-2 in IDOC_DATA

En-queue Option as S

DB_Read Option as N

4. EDI_DOCUMENT_STATUS_SET

This Fm sets the status of your IDOC in standard.

Here you have to pass -

Document no i.e. IDOC no that is generated from step-2 in IDOC_DATA

IDOC_STATUS that is fetched from step-2 in IDOC_STATUS

5. EDI_DOCUMENT_CLOSE_PROCESS

here you have to pass document no and background as N.

Thanks and please let me know if there is any query.

Hi Community !

I'd like to share a piece of code which might be useful for someone. It is called abap data parser. Its purpose is parsing of TAB-delimited text into an arbitrary flat structure or internal table. Why TAB-delimited? This is the format which is used automatically if you copy (clipboard) something from Excel - this creates some opportunities for good program usability.

So what does it do. Let's say we have this data in a form of string (CRLF as a line delimiter, TAB as a field delimiter):

NAME     BIRTHDATE

ALEX     01.01.1990

JOHN     02.02.1995

LARA     03.03.2000

... and a corresponding data type and internal table.

types: begin of my_table_type,

         name      type char10,

         birthdate type datum,

       end of my_table_type.

 

data lt_container type my_table_type.

To parse the string into the container table just add the following code:

lcl_data_parser=>create( lt_container )->parse(

  exporting i_data      = lv_some_string_with_data

  importing e_container = lt_container ).

The class supports some additional features, in particular, "unstrict mode" which allow to skip field of the target structure in text - useful when you need to load just several certain fields of a huge data structure (like standard tables in SAP). Let's consider our data type has additional field, unnecessary in the current context:

types: begin of my_table_type,

         name      type char10,

         city      type char40,   " << New field, but still just 2 in the text

         birthdate type datum,

       end of my_table_type.

...

 

lcl_data_parser=>create(

    i_pattern       = lt_container       

    i_amount_format = ' .'         " specify thousand and decimal delimiters

  )->parse(

    exporting

      i_data      = lv_some_string_with_data

      i_strict    = abap_false     " missing city field will not throw an error

      i_has_head  = abap_true      " headers in the first line of the text

    importing

      e_container = lt_container ).

Another feature: i_has_head parameter above means that the first line contains tech names of the fields - then the parser uses it to identify existing fields and their order (which may be flexible then).

Cases of usage

- we (our company) use the code for some of our company's products - like this one

- we use it in the mockup loader - another our openly published tool for unit testing (actually the data parser was a part of mockup loader initially)

- as a tool for mass uploads for some z-tables of some other our products

The code is free to use under MIT licence. Project home page is https://github.com/sbcgua/abap_data_parser

Installation can be done manually - just 1 include to to install - or with abapGit tool (the most convenient way).

I hope you find this useful ! =)

A timestamp is a sequence of characters or encoded information identifying when a certain event occurred, usually giving date and time of day, sometimes accurate to a small fraction of a second.

(Wikipedia, August 29, 2016).

In ABAP you get a time stamp accurate to second with the statement

GET TIME STAMP FIELD DATA(ts).

cl_demo_output=>display( ts ).

Here ts has the dictionary type TIMESTAMP and the result might look like 20160829131515.

And a time stamp accurate to a small fraction of a second with:

DATA ts TYPE timestampl.

GET TIME STAMP FIELD ts.

cl_demo_output=>display( ts ).

The result might look like 20160829131612.294638.

Those are are POSIX time stamps that are independent of a time zone.

The format of such  ABAP timestamps is YYYYMMDDHHMMSS.fffffff with 7 fractions of a second.

As a rule, you use such time stamps to mark data with - well - time stamps (time of creation, time of update, ...).

In order to handle timestamps, you can do the following:

• You can directly compare different timestamps of the same type:
  
  GET TIME STAMP FIELD DATA(ts2).
  WAIT UP TO 1 SECONDS.
  GET TIME STAMP FIELD DATA(ts1).
  ASSERT ts2 < ts1.

• You can convert timestamps into date and time fields of a time zone:
  
  

    GET TIME STAMP FIELD DATA(ts).

    CONVERT TIME STAMP ts TIME ZONE sy-zonlo

            INTO DATE DATA(date) TIME DATA(time)

            DAYLIGHT SAVING TIME DATA(dst).

     cl_demo_output=>display( |{ date }\n{

                                 time }\n{

                                 dst } | ).

         Giving something like 20160829, 172223, X

• You can format timestamps in string processing:
  
  GET TIME STAMP FIELD DATA(ts).
  
  cl_demo_output=>display( |{ ts TIMESTAMP = ISO } | ).
  
  Giving something like 2016‑08‑29T15:27:29
  
  
• You can serialize/deserialize timestamps, if their datatype refers to a special domain:
  
  DATA ts TYPE xsddatetime_z.
  GET TIME STAMP FIELD ts.
  
  CALL TRANSFORMATION id SOURCE ts = ts
                 RESULT XML DATA(xml).
  cl_demo_output=>display_xml( xml ).
  
  Giving something like: <TS>2016‑08‑29T15:33:50Z</TS>
  
  
• You can do some simple calculations with the methods of class CL_ABAP_TSTMP:
  
  DATA: ts1 TYPE timestampl,

          ts2 TYPE timestampl.

    GET TIME STAMP FIELD ts2.

    WAIT UP TO 1 SECONDS.

    GET TIME STAMP FIELD ts1.

    DATA(seconds) = cl_abap_tstmp=>subtract(

        EXPORTING

          tstmp1 = ts1

          tstmp2 = ts2 ).

    cl_demo_output=>display( seconds ).

     Giving something like 1.001369.

And that is it. Timestamps are not foreseen for more and you cannot do more! Especially, you should never do direct calculations with timestamps itself:

GET TIME STAMP FIELD DATA(ts1).

DATA(ts2) = cl_abap_tstmp=>add(

                tstmp = ts1

                secs  = 3600 ).

cl_demo_output=>display( ts2 - ts1 ).

The result is 10000. How that?

Well, you know it. Timestamps don't have an own built-in ABAP type (in another ABAP world, in NGAP, that is Release 8.x in fact they have and we wouldn't have to bother). But in the 7.x-7.40-7.50 Release line, timestamps are stored in type p numbers. p length 8 without decimal places for dictionary type TIMESTAMP and p length 11 with seven decimal places for dictionary type TIMESTAMPL.

Besides the above mentioned points, ABAP does not recognize the semantical meaning of a timestamp. It simply treats it as a packed number of the given value. With other words, if ts1 above is 20160829160257, adding 3600 seconds using the method ADD gives 20160829170257. You see the difference? One hour later (17 compared to 16) in the timestamp format, but a difference of 100000 in normal value format for type p. Using type p for timestamps is simply an efficient way of storing timestamps allowing decimal places.But never, never, never tend to believe that you can do something meaningful with the type p number directly!

Normally if we see a message in SAPGUI and we can just double click the message icon to get its technical detail like message id and number displayed.

However in some case the icon is not available for click, for example below, there is a popup window displayed and you could not double click the icon. If you close the popup, the message disappears as well.

In this case, use tcode SE84 to launch repository information system, specify Short Description with value: *cannot be used as proxy object

Then you get answer: message id DDLS, value 444.

Or if you already know that the table T100 stores message text, you can directly query on table T100 to get the same result.

In a recent discussion I've seen someone was testing whether a loop was executed by placing a WRITE statement inside. Maybe it was a beginner's error but maybe others tend to do that too. Since the discussion is locked, I say it here:

WRITE is not appropriate for error analysis.

WRITE writes to he list buffer. A display of the list buffer in form of a classic list only takes place after calling the list. An automatic call of a classic list happens only in the program flow of a submitted executable program. As a rule, in any other framework there is no automatic list display. Therefore, the fact that you don't see any list output normally does not allow you to conclude that the WRITE statement was not executed.

• For finding bugs during development, you use checkpoints (breakpoints, assertions, logpoints).

• For testing during and after development you use module tests of ABAP Unit.

For the most of you this is crystal clear, but sometimes I get the impression that the knowledge about the fundamentals of classic ABAP programming - that unfortunately can freely be mixed into all the modern stuff - is taking a backseat more and more. Reminds me of the old days when I started with ABAP and also believed that WRITE is simply a kind of printf for creating a console output.

I started this already via Twitterhow to fetch or map two values from an internal table if you are not interested in the whole line

Input:     lt_vbpa   (just an internal table with some more columns )

target:     lv_kunn  (two fields to be filled ... needed for next method or something.

               lv_land1

Of cause there are lots of solutions, we could make a list out of it, but key is to have FAST, short an understandable code

80s style:

Read Table lt_vbpa assigning <fs>  Key ...

lv_kunnr = <fs>-kunnr.

lv_land1  = <fs>-land1.

New >7.40

lv_kunnr = lt_vbpa[ parvw = "WE" ]-kunnr

lv_land1  = lt_vbpa[ parvw = "WE" ]-land1

* but worse 2 read operations in ITAB performance issue in mass processing.

Via Twitter I did receive some Ideas:

New >7.40feat. Uwe Fetzer

Read Table ltvbpa assigning <fs>  Key ...

assign lt_vbpa[ parvw = "WE" ] to <fs>.

lv_kunnr = <fs>-kunnr.

lv_land1  = <fs>-land1.

* Nicer, one read on the itab only, but still tree lines of code

Solution by Enno Wulff

* Also nicer but quite some coding overhead... and again with the performance issue of two reads.

I still do not see a great Idea to do this in a nice way in two lines of code (pls. no #Macros, or two statemts in one line ideas ...)

Thanks for the two of you for your Ideas!

Hello Folks,

Usually we encounter a scenario where a program goes for a dump due to conversion errors while using Open/Read Dataset to read .txt files lying on the Application server.For ex below is the screenshot of such a dump.If the text file is very large then it will be tough to identify the rows or columns having non Unicode characters or identifying if at all there are any non-unicode characters in the file.

Below are the steps to identify non-unicode Characters in a .txt file :-

• Open a blank notepad.
• Type the below given text in the notepad.

<?xml version="1.0"?><test></test>

• Copy the content of the .txt file on the Application Server in between the <test> and </test> in the notepad file that we had created and save it with .xml extension.
• To identify the Non Unicode characters we can use either Google Chrome or Mozilla firefox browser by just dragging and dropping the file to the browser.
• Chrome will show us only the row and column number of the .txt file where the non-unicode character is lying but it will not show the content of that particular row or column.

• Mozilla Firefox will show us the row and column number along with the content of that row and column.An underscore will be till the column where the non-unicode character is lying.If there are multiple non Unicode characters in the .txt file then we should remove the first non-unicode character that was identified and then repeat all the steps as explained here to identify the next non-unicode character.Tedious,but this way atleast we can identify the presence of non-unicode characters in the text file.

• Notepad screenshot going by the row and column number that we got using Mozilla Firefox.Status Bar option in the notepad will help us seeing the row and column number in the notepad file.

• Using Internet Explorer when we try to open the .txt file with non-unicode characters it will just show a blank page.So,we need either Chrome or Mozilla Firefox browser to identify the row and column with non-unicode characters.
• Attached are the text file and xml file which can be used to test by dragging and dropping in Chrome or Mozilla.
  

Summer is a strange time for SAP teams: lots of people go on holiday, projects are left to tick over, burning issues are put on hold. A time for those who remain to take it easy a while, take a look at those really intractable problems or catch up on technical innovations and pet projects with no-one to bother you. This is all fine in theory except that the business doesn't rest and production incidents still occur. This is the story of two such incidents and how SAP support helped us.

The first occurred right at the start of August, when nearly all my development team had already left: the SWN_SELSEN production job had started to abend. I groaned inwardly when I heard the news. Nothing could be more simple on the face of it than SWN_SELSEN: it simply selects workflow notifications and sends them out. There is no variant but the customising is fearsomely complicated and you needed to be a deeply experienced workflow guru (something I am not) to understand the code and the exits. This was a high-profile problem too - though the business impact was small, the program was sending PO approval notifications to all the top guys in the company, so when these stopped, important people noticed.

I had a look at the dump. The problem occurred about 20 levels deep with a TSV_TNEW_PAGE_ALLOC_FAILED. An internal table space error. The source throwing the error was SAP for sure, but there was a little cluster of badi code around 15 deep in the stack, before the code returned to standard SAP. The badi changes were imported the previous week - I had found the smoking gun. Unfortunately, dear reader, as you may be aware, developers lack a certain credibility and though I strongly suspected the custom code was causing the issue, I couldn't be 100% sure. My lack of certainty combined with my colleagues 100% certainty that the changes had been thoroughly tested with no problem in our quality system turned the spotlight back onto standard SAP code. We looked at the customising and tried to understand it. In the meantime, as Max Attention customers we felt emboldened enough to turn to SAP and opened an incident.

We changed the custo and imported it on production - no effect. Then we received an almost cheerful answer from SAP support that our Badi code WAS causing the problem and to check out some code which called a certain SAP module. Damn - this was embarrassing! I should have checked out this code more but it was complex and just looking at it made me want to get a coffee and mindlessly browse facebook.

Somehow I figured out the the SAP module (in case you're interested it is function 'SAP_WAPI_WORKITEMS_TO_OBJECT') was doing lots of processing that we didn't need, and we could replace it by a join on tables swwwihead and sww_wi2obj. It did the trick, the dumps stopped and the top guys started getting their PO approvals again.

The second problem was more of a long-running issue concerning invoice pricing. This was an "intractable" problem for which we already had an open OSS incident. Now was the time, with everyone away, to have a very detailed look at the problem. Each time I debugged, the problem seemed to arise in an SAP standard formula. No custom code was implicated. For sure, we did have a strange situation where we were taking the sales order in the sales unit, doing the picking in the base unit, and then converting back to the sales unit for billing, but that couldn't be causing the problem, could it? Again, dear reader, I took the easy route and informed SAP their pricing algorithm was wrong.

After spending sometimes entire days debugging, I was finally convinced: the problem is in the SAP code, I told the business analyst; it doesn't go near any user-exit code. So the OSS incident was updated and next day the reply came back: Dear customer, please check these OSS notes and tell us why you have modified standard modules. It advising us that we would have problems if we tried to apply notes to these modules, and providing the notes we should apply. The reply finished with a rather pointed comment, asking us to kindly answer if there was some Z code at pricing. Well, this was really laying down the gauntlet, and my professional pride was piqued.

I was surprised at the modification in the standard include and had no idea why it was there. We set up an IDES system at (nearly) the same EhP level, and compared the code. It turned out that we'd been careless at the last upgrade during the SPAU phase, and simply accepted the modifications for an old note instead of going back to the standard. I backed out the mods. We applied the 2 notes (and 96 pre-requisites) and retested - no joy.

Much highly concentrated debugging followed during which I had to anatomise function RV_INVOICE_CREATE and all its main forms and exits (maybe I'll share this on a future blog if there is sufficient demand ;-D). What I found was simple: it was the base to sale units conversion, but this was being done at the wrong time and totally screwing up (to use the technical term) pricing.

There are a few simple lessons to draw from these incidents:

1. If you have a problem and have modified standard code or have user-exits in the problem area, it's highly probable that your changes are causing the problem

2. OSS works very well, and particularly for Max Attention customers, as an 'expert of last resort' that can really help catalyse problems with your SAP system.

3. Mistakes during SPAU can have long-lasting impacts

4. IDES systems are very useful

5. Best to go on holiday when everyone else does.