MDX - ABAP program variable to select the required month

Dear all,
Please I would like to ask you about the following MDX issue.
We have run the following MDX in SAP R/3 using the OLAP BAPI with successful results:
SELECT
[Measures].MEMBERS ON AXIS(0) ,
NON EMPTY [0SALESORG].[LEVEL01].MEMBERS
[0DISTR_CHAN].[LEVEL01].MEMBERS
[0MATERIAL].[LEVEL01].MEMBERS
properties member_name
ON AXIS(1)
FROM [EPSDC108/ZTD_EPSDC108_Q002]
We now want to select a specific calendar month for the data and generated the following MDX:
SELECT
[Measures].MEMBERS ON AXIS(0) ,
NON EMPTY [0SALESORG].[LEVEL01].MEMBERS
[0DISTR_CHAN].[LEVEL01].MEMBERS
[0MATERIAL].[LEVEL01].MEMBERS
properties member_name
ON AXIS(1)
FROM [EPSDC108/ZTD_EPSDC108_Q002]
SAP VARIABLES [CALMONTH] INCLUDING <member>
We would like to know how we use an ABAP program variable to select the required month.
Thank you in advance for you reply
Regards
Ales

hello,
the syntax of the MDX should be:
SELECT
[Measures].MEMBERS ON AXIS(0) ,
NON EMPTY [0SALESORG].[LEVEL01].MEMBERS
[0DISTR_CHAN].[LEVEL01].MEMBERS
[0MATERIAL].[LEVEL01].MEMBERS
properties member_name
ON AXIS(1)
FROM [EPSDC108/ZTD_EPSDC108_Q002]
SAP VARIABLES [CALMONTH] INCLUDING [0CALMONTH].[200412]
CALMONTH is the Queryvariable!!
If you wanna use a ABAP veriable you have to concatenate the MDX statement in your ABAP.
Kind reg.
Michael

Similar Messages

ABAP programming standards for SELECT...ORDER BY....

I recently saw a set of programming standards that stated it was better not to use an ORDER BY clause on a SELECT statement. Instead SELECT into an internal table and use SORT. The actual statement was....."In most cases it is preferable to do the sorting within the ABAP program instead of on the database server. That means: fill the internal table via a SELECT statement and then sort via the SORT statement instead of coding a SELECT u2026 ORDER BY. The sorting of large amounts of data on the database server affects the performance of all users on the system, whereas the sorting within the ABAP program u2018onlyu2019 affects the application server. However, if an index exists on the table that can be used for the sorting then the SELECT u2026 ORDER BY doesnu2019t cause any undue strains on the system."
I think this is no longer correct particularily with regards to Systemi/iSeries which we normally run in 2 tier mode.
What are people opinion on this?

Peter,
the correct answer for DB2 on IBM i is "it depends". To implement "ORDER BY", the optimizer has basically these choices:
- If an index with the columns of the "ORDER BY" clause exists, the database can access the data through this index, which returns them in the desired order. However, the data needs to be fetched row by row, so for each returned row you need one I/O request.
- If such an index does not exist, the database can choose to perform a sequential read into a temporary storage and sort the temporary result set before returning the data to the caller. This is basically the same as reading the data into an internal table and let ABAP do the sort. Even if an index exist, reading the whole table into memory and sorting it there may be faster, because on a sequential read, the database can execute a "blocked" fetch rather than many individual I/O operations. You may see this if the table is relatively small.
- If such an index does not exist, the database could also choose to create a temporary index and access the data through the temporary index. For the first execution, you don't gain much, but subsequent executions may perform much better. However, after an IPL you loose all temporary indexes, so the index needs to be built again on the first execution after the IPL.
If you code your ABAP to read the table sequentially and sort it in memory, you are forcing the second implementation. If you code ABAP with the ORDER BY in the SELECT statement, you allow the database optimizer to choose the best possible implementation depending on the size of the table, the size of the result set, and the available indexes.
If your table is relatively large but the result set (based on the WHERE clause) is relatively small, make sure to have an index that combines the WHERE clause elements returning only one value with the ORDER BY clause elements.
For example, if you have a query like:
SELECT * FROM T
WHERE A = ? AND B = ? AND C IN (?, ?, ?)
ORDER BY D, E
you should have an index over columns A, B, D, and E for the best possible performance. A and B in the index can be used to limit the result set without any influence on the sort order D, E, but C cannot.
Kind regards,
Christian Bartels.

ABAP program to add in the process chain before the attribute change run

Hi
I need a ABAP program to add in the process chain before the attribute change run(process) to avoid the locks, can any one send me the program
Regards,
Satish

I am not sure of any standard program .... but you can write your own... should be a small one..
you can check if the table RSDMDENQ has entry for your InfoObject... if yes, then its locked.. if not.. its not locked

Execute webdynpro from abap program and return to the caller program

Guys,
I have a question here.
I know there is a way to call an abap webdynpro application from normal abap program by either using a class method, or use a function module WDY_EXECUTE_IN_PLACE by providing
the webdynpro application or using CALL TRANSACTION statement.
But, is there anyways that we can call the webdynpro application from abap program by supplying data to the webdynpro and display to the user from the portal, and then
once the user do some manipulation on the data, can we transfer back the data to the caller abap program?

hey ,
you can pack any web-dynpro program in tranasaction code and run it from R/3 and not via portal :
search in " SAPTECHNICAL" how to do so - for some reason i cant post a link here
than you can use call transaction .
regards
ASA

ABAP Programming Error when saving the Process Order confirmation in COR6N

Hello,
We have an issue related to Process Order confirmation using Tcode COR6N. When we enter all the inputs to confirm( Activity, yield and phase) and click on save it gives ABAP Programming Error (Exception condition "SEQ_NOT_FOUND" raised).
Any inputs in this regard, would be appreciated.

Hello
I can observe that you have implemented the report ZOPSECRE and that an inconsistency was found.
This repor corrects inconsistent orders which do not have an operation or a sequence, or the two of them.
The report checks whether there is at least one operation or one sequence and creates both including status objects.
Therefore, you need to have the default valus for the operation generation defined on OPJG for this order type/plant.
BR
Caetano

Why customer exit variable to grab the current month value doesn't work?

In CMOD, input the following code to grab the current month value from the system date:
Grab the month value with System Date
WHEN 'CURMONTH'.
    CLEAR l_s_range.
    l_s_range-low = SY-DATUM+4(2).
    l_s_range-sign = 'I'.
    l_s_range-opt = 'EQ'.
    APPEND l_s_range TO e_t_range.
In Query Designer, create a formula variable CURMONTH processed by customer exit and the dimension under the Currency/Unit tab is "Number". Put the formular variable in the column as a KF. When running the query, the column with the formular variable shows values of "2,0000000" other than just "2" I want for the current month. If the dimension under the Currency/Unit tab is "date", the column with the formular variable shows values of "00/00/0000". Any idea? How to grab the correct current month value which is 2 from the system date.
Thanks!

Oh ok , try the below options, As such I dont see any errors in our code .
Not sure if you have ABAPER's in your team, just check with them once on the FM we are trying to see .
Next , do you hvae 0CALDAY available in your report ? If so try to restrict that field with variable "0DAT" and write the same code you have written for your formula variable , but instead change the variable name to "0DAT" and try if this gets the month . let me know if I'm not clear .

Read the names of the files in ABAP program that runs in the background

Hello,
I have a program that uploads information from file on application server.
What I can't figure still is how to get the <b>names </b>of the files that are in <b>specific directory</b>.
There is an other application that will post those files into this directory. I wont to get file names and file types from this directory and put it into an internal table.
File names are changing based on date and version.
Please keep in mind that the program runs in the background, (presentation server is not included in the process)
Thanks in advance,
Milan

Hi,
one epossible solution that i have used is:
1. Create an operating system comand with transaction SM69
command OS                              OS-command Parameter
ZDIR         Windows NT Customer cmd.exe          /C dir &
2. Call Functionmodul
CALL FUNCTION 'SXPG_COMMAND_EXECUTE'
    EXPORTING
      COMMANDNAME                         = 'ZDIR'
      ADDITIONAL_PARAMETERS               = P_PARA1
OPERATINGSYSTEM                     = SY-OPSYS
TARGETSYSTEM                        = SY-HOST
DESTINATION                         =
STDOUT                              = 'X'
STDERR                              = 'X'
TERMINATIONWAIT                     = 'X'
TRACE                               =
   IMPORTING
      STATUS                              = G_OK
EXITCODE                            =
    TABLES
      EXEC_PROTOCOL                       = GTBL_PROTO
   EXCEPTIONS
     NO_PERMISSION                       = 1
     COMMAND_NOT_FOUND                   = 2
     PARAMETERS_TOO_LONG                 = 3
     SECURITY_RISK                       = 4
     WRONG_CHECK_CALL_INTERFACE          = 5
     PROGRAM_START_ERROR                 = 6
     PROGRAM_TERMINATION_ERROR           = 7
     X_ERROR                             = 8
     PARAMETER_EXPECTED                  = 9
     TOO_MANY_PARAMETERS                 = 10
     ILLEGAL_COMMAND                     = 11
     WRONG_ASYNCHRONOUS_PARAMETERS       = 12
     CANT_ENQ_TBTCO_ENTRY                = 13
     JOBCOUNT_GENERATION_ERROR           = 14
     OTHERS                              = 15
3. Loop at GTBL_PROTO and make your coding with the filenames
Hope this helps
Regards
Bernd

How to Transport a ABAP Program and Variants on the program

Hi,
I created a Executable Program in SE38 and collected in a Transport Request.
For that program i created VARIANTS ...but how can i collect the created variants in a Transport request
When creating a variant system didn't prompted Transport request
Thanks

Hi,
U can go to the program, then in menu u will get vairants, guess its extras, not sure now...but once u find variants there u have an option to put it in a transport request. It is possible. Just try it out
Regards,
Rathy

ABAP Program using Selection Screen in Process Chain

Hi,
I have included an ABAP Program in the Process Chain.
The ABAP Program takes a selection screen value from user before execution.
I have created a variant for both the ABAP Process (YPV_ABC) and a variant for the Selection Screen (YPV_XYZ).
The ABAP Program executes perfectly well in SE 38.
I get the following message when I execute the Process Chain.
"Status Change of Process ABAP YPV_ABC.
Save Status and Trigger Events if Appropriate "
When I click Yes, the ABAP Process becomes red.
These are error messages in the log
516 - Job started
550 - Step 001 started (program RSPROCESS, variant &0000000012961, user ID ALEREMOTE)
25 -    Could not ascertain code page
546 - Job cancelled after system exception ERROR_MESSAGE
My questions are:
1) Is it possible to use an ABAP Program which has a user input screen in Process Chain?
2) Could you please help with the above error?

1) Is it possible to use an ABAP Program which has a user input screen in Process Chain?
ABAP programs, with variants established for selection screens, are possible. We use them quite extensively for setting triggers to allow Process Chain to continue after an Interrupt Process has been hit.
2) Could you please help with the above error?
I'm not quite sure what could be causing this. When you tested this program in SE38, did you test it with the same variant for the selection screen and did you execute it in background?

Unable to resolve the exception READ_REPORT_LINE_TOO_LONG in Abap program.

Hi,
I am getting the exception READ_REPORT_LINE_TOO_LONG in my abap program.Given below is the full analysis of the exception and then the program code :-
Error Analysis :-
An exception occurred that is explained in detail below.
The exception, which is assigned to class 'CX_SY_READ_SRC_LINE_TOO_LONG', was
not caught in
procedure "K_KKB_FIELDCAT_MERGE" "(FUNCTION)", nor was it propagated by a
RAISING clause.
Since the caller of the procedure could not have anticipated that the
exception would occur, the current program is terminated.
The reason for the exception is:
There was an attempt to read program "ZANI_TEST_INTERACTIVE_ALV" from the
database.
The READ REPORT statement allows you to copy a program text into an
internal table. The occupied line length in the program text must not
exceed the width of the internal table.
The internal table "\FUNCTION=K_KKB_FIELDCAT_MERGE\DATA=L_ABAP_SOURCE[]" is 72
characters wide. The program line is
91 characters wide.
Program Code :-
*& Report ZANI_TEST_INTERACTIVE_ALV
REPORT ZANI_TEST_INTERACTIVE_ALV.
TABLES: LFA1.
TYPE-POOLS: slis.
DATA: it_lfa1 TYPE TABLE OF lfa1,
      wa_lfa1 TYPE lfa1,
      it_fieldcat TYPE slis_t_fieldcat_alv.
SELECTION-SCREEN BEGIN OF BLOCK input WITH FRAME TITLE input.
SELECT-OPTIONS: acc_no FOR LFA1-LIFNR.
SELECTION-SCREEN END OF BLOCK input.
START-OF-SELECTION.
IF NOT acc_no IS INITIAL.
    SELECT * FROM LFA1
      INTO CORRESPONDING FIELDS OF TABLE it_lfa1
      WHERE LIFNR IN acc_no.
ELSE.
    SELECT * FROM LFA1
      INTO CORRESPONDING FIELDS OF TABLE it_lfa1.
ENDIF.
PERFORM form_build_fieldcatalog USING 'IT_LFA1' CHANGING it_fieldcat.
PERFORM form_display_alv USING it_lfa1 it_fieldcat.
*&      Form form_build_fieldcatalog
      text
     -->P_0058   text
     <--P_IT_FIELDCAT text
form form_build_fieldcatalog using    p_it_tabname TYPE slis_tabname
                              changing p_it_fieldcat TYPE slis_t_fieldcat_alv.
CALL FUNCTION 'REUSE_ALV_FIELDCATALOG_MERGE'
    EXPORTING
      I_PROGRAM_NAME               = sy-repid
      I_INTERNAL_TABNAME           = p_it_tabname
    I_STRUCTURE_NAME             =
    I_CLIENT_NEVER_DISPLAY       = 'X'
      I_INCLNAME                   = sy-repid
    I_BYPASSING_BUFFER           =
    I_BUFFER_ACTIVE              =
    CHANGING
      ct_fieldcat                  = p_it_fieldcat
    EXCEPTIONS
      INCONSISTENT_INTERFACE       = 1
      PROGRAM_ERROR                = 2
      OTHERS                       = 3
IF sy-subrc <> 0.
     MESSAGE ID SY-MSGID TYPE SY-MSGTY NUMBER SY-MSGNO
          WITH SY-MSGV1 SY-MSGV2 SY-MSGV3 SY-MSGV4.
ENDIF.
endform.                    " form_build_fieldcatalog
*&      Form form_display_alv
      text
     -->P_IT_LFA1 text
form form_display_alv using p_it_lfa1 LIKE it_lfa1 p_it_fieldcat TYPE slis_t_fieldcat_alv.
CALL FUNCTION 'REUSE_ALV_GRID_DISPLAY'
    EXPORTING
    I_INTERFACE_CHECK                 = ' '
    I_BYPASSING_BUFFER                = ' '
    I_BUFFER_ACTIVE                   = ' '
      I_CALLBACK_PROGRAM                = sy-repid
    I_CALLBACK_PF_STATUS_SET          = ' '
    I_CALLBACK_USER_COMMAND           = 'USER_COMMAND'
    I_CALLBACK_TOP_OF_PAGE            = ' '
    I_CALLBACK_HTML_TOP_OF_PAGE       = ' '
    I_CALLBACK_HTML_END_OF_LIST       = ' '
    I_STRUCTURE_NAME                  =
    I_BACKGROUND_ID                   = ' '
    I_GRID_TITLE                      =
    I_GRID_SETTINGS                   =
    IS_LAYOUT                         =
      IT_FIELDCAT                       = P_it_fieldcat
    IT_EXCLUDING                      =
    IT_SPECIAL_GROUPS                 =
    IT_SORT                           =
    IT_FILTER                         =
    IS_SEL_HIDE                       =
    I_DEFAULT                         = 'X'
    I_SAVE                            = ' '
    IS_VARIANT                        =
    IT_EVENTS                         =
    IT_EVENT_EXIT                     =
    IS_PRINT                          =
    IS_REPREP_ID                      =
    I_SCREEN_START_COLUMN             = 0
    I_SCREEN_START_LINE               = 0
    I_SCREEN_END_COLUMN               = 0
    I_SCREEN_END_LINE                 = 0
    I_HTML_HEIGHT_TOP                 = 0
    I_HTML_HEIGHT_END                 = 0
    IT_ALV_GRAPHICS                   =
    IT_HYPERLINK                      =
    IT_ADD_FIELDCAT                   =
    IT_EXCEPT_QINFO                   =
    IR_SALV_FULLSCREEN_ADAPTER        =
IMPORTING
    E_EXIT_CAUSED_BY_CALLER           =
    ES_EXIT_CAUSED_BY_USER            =
    TABLES
      t_outtab                          = p_it_lfa1
    EXCEPTIONS
      PROGRAM_ERROR                     = 1
      OTHERS                            = 2
IF sy-subrc <> 0.
     MESSAGE ID SY-MSGID TYPE SY-MSGTY NUMBER SY-MSGNO
         WITH SY-MSGV1 SY-MSGV2 SY-MSGV3 SY-MSGV4.
ENDIF.
endform.                    " form_display_alv
Please suggest a solution for this problem.. Thanks in advance.

hi,
it is getting because of fieldcat hear ur internal table is having all fields in lfa1, lfa1 is having more fileds alv cont display that much fields at a time . for that u are getting that messgae . u can solve this problem by filling fieldcat table manuvally insted of by FM 'fieldcat_merge'. fill filedcat table some fields which are need to display by manuvally.
thanq,
rajesh.k

The performance of ABAP programs

Hey Experts , how can one analyze the performance of ABAP programs apart from using the generic tools such as Trace etc.

Hi Chakradhar,
Overview & Introduction
The runtime analysis tool allows you to examine the performance of any ABAP programs, such as reports, subroutines, function modules or classes, that you create in the ABAP workbench. It saves its results in performance data files, which you can display as lists. You can use these results to identify runtime-intensive statements, to combine table accesses, and show the hierarchy of program calls.
Normally you use the runtime analysis tool to measure the runtime of complex program segments or complete transactions (if you want to measure the runtime of smaller program segments or individual ABAP statements you can use the ABAP statement GET RUN TIME FIELD ).
However, we use only simple
The Programs to be Analyzed
Let's assume I am a very newbie in ABAP and I have written a tiny little program which is doing the following:
reading data from a database table
storing that data in an internal table
display that data on a list (at the start of the program you have to specify certain key values; only matching data should be displayed later on).
So here it comes (and it seems to work as designed ...)
REPORT y_wlog_atra_1.
PARAMETERS: p_carrid TYPE sbook-carrid DEFAULT 'LH',
            p_connid TYPE sbook-connid DEFAULT '0400'.
DATA: wa_sbook TYPE sbook,
      itab_sbook TYPE STANDARD TABLE OF sbook.
*SELECT * FROM sbook INTO wa_sbook.*
CHECK: wa_sbook-carrid = 'LH' AND
         wa_sbook-connid = '0400'.
APPEND wa_sbook TO itab_sbook.
ENDSELECT.
LOOP AT itab_sbook INTO wa_sbook.
WRITE: /,
         wa_sbook-carrid,
         wa_sbook-connid,
         wa_sbook-fldate,
         wa_sbook-bookid,
         wa_sbook-customid,
         wa_sbook-custtype.
ENDLOOP.
A nice colleague has thrown a glance at my source code. He has given the hint to use a WHERE clause with the SELECT statement instead of the CHECK statement for reasons of better performance.
So I have written another program:
REPORT y_wlog_atra_2.
*SELECT * FROM sbook INTO wa_sbook*
WHERE carrid = 'LH' AND
        connid = '0400'.
APPEND wa_sbook TO itab_sbook.
ENDSELECT.
I am curious about the performance now. Let's compare the 2 variants with the ABAP Runtime Analysis tool.
ABAP Runtime Analysis: Tool & Procedure
To start it, choose Test --> Runtime Analysis in the SAP Menu, or use transaction SE30 .
The runtime analysis procedure consists of two parts:
Recording performance data (upper part of the screen)
Analyzing the performance data (lower part of the screen; this part only appears if there are performance data files in place)
The procedure for the first part (Recording performance data):
We go to the initial screen of the runtime analysis (transaction code SE30 ) and specify the name of the first program (Y_WLOG_ATRA_1) in the relevant input field. After that we press the button Execute .
The selection screen of the program Y_WLOG_ATRA_1 (including the 2 input fields) is displayed. At the bottom of the screen we are informed that the measurement has been started. We continue by clicking the Execute button.
Later on we will see that a file (containing performance data) has been created in parallel.
Now we repeat that procedure for our second program (Y_WLOG_ATRA_2).
The second step is the analysis of the generated performance data.
To do that we have to go to the initial screen of the Runtime Analysis tool again. On the bottom part of the screen you can specify those performance data files you want to analyze.
You can see some information related to the last measurement run (in our case that was program (Y_WLOG_ATRA_2). By pressing the button Other File we are able to select those performance data files we like to analyze.
I want to see all the files I have created (user BCUSER).
I get the relevant list with 2 lines (related to the performance data files of the programs Y_WLOG_ATRA_1 and Y_WLOG_ATRA_2).
Based on that list you can display the distinct performance data per line. You have to click in the column Object Type of the relevant line.
As a start the tool displays the evaluation overview (showing the cumulated execution times for the ABAP, database and system-level).
Here comes the evaluation overview for program Y_WLOG_ATRA_1
We can do the same for the other program Y_WLOG_ATRA_2
By comparing the perfomance data of the 2 programs we clearly see that I have done well with listening to the advice of my colleague. The performance of the second program is dramatically better.
In the next step you can forward to a more detailed display of the performance data (Hitlists). That listing shows the different granular execution steps ( according to your filter adjustments ). Here you can easily identify the most time-consuming progam units.
And it will also be a good idea to glance at the Tips & Tricks corner. You will find many valuable suggestions about good performance definitely.
Please use the below link to see the Screen shots of the screens
[http://searchsap.techtarget.com/tip/0,289483,sid21_gci1265920,00.html|Performance Analysing]

How to debug the abap program ?

how to debug the abap program ?Can anybody explain me in details.

Hi
Debugger
This section of the ABAP Workbench documentation provides information on how to use the Debugger as a test tool for finding errors in the source code of an ABAP program.
Functional Overview
Use
The ABAP Debugger is an integrated test tool within the ABAP Workbench. You use it to check the program logic and to find errors in the source code of an ABAP program. In the Debugger, you can step through the source code of a program. The running program is interrupted after each step, allowing you to check its processing logic and the results of individual statements.
As of Release 6.10, you can also run Business Server Pages (BSP) in the debugging mode. You can also display and set breakpoints here. Business Server Pages can be displayed in the Object Navigator when you select an appropriate application under BSP Application.
Features
The Debugger provides an efficient means of identifying errors in ABAP programs. It contains the following functions:
Ways of starting the Debugger
Choosing different views
Choosing different execution options in the Debugger
Displaying source code in the Debugger
Setting and deleting breakpoints
Setting and deleting watchpoints
Stopping a program at a particular statement or event
Displaying and changing field contents at runtime
Displaying ABAP Objects and references
Displaying and positioning strings
Setting and deleting database locks
Opening the ABAP Editor, or Object Navigator
System settings and runtime warnings
Starting the Debugger
There are two possible strategies for starting the Debugger in the ABAP Workbench:
By setting breakpoints then running the program
By running the program in debugging mode.
Setting Breakpoints
A breakpoint is a signal in a specific line of the program source code. This signal indicates to the ABAP runtime processor to stop the program at the relevant line and start the ABAP Debugger. A distinction is made between static and dynamic breakpoints. For further information about the different types of breakpoints and how to use them, refer to Breakpoints.
Direct Processing
You can start the Debugger without previously having set breakpoints. This is the best procedure to use when you want to test a program right from the beginning. It is also a useful procedure if you are not overly familiar with the program and therefore are not sure where best to set breakpoints. You can start the Debugger as follows:
From the Object Navigator
Select a report or transaction and choose Program ® Test ® Debugging.
From the ABAP Editor
Choose Program ® Execute ® Debugging (or the Debugging pushbutton).
From any screen
Choose System ® Utilities ® Debug ABAP.
From any screen
Enter /h in the command field.
Display Modes in the Debugger
When you are debugging a program, there are various display modes that you can use. All of the display modes have the same structure. The top part of the screen displays an extract of the program source code. The bottom part displays the information specifically available in that display mode. There are also pushbuttons on the screen allowing you to switch to the most frequently-used display modes.
Display Modes Available Using Pushbuttons
Fields
The scrollable field display contains the contents of up to eight fields. The contents of the three most important system fields are always displayed. This is the default display mode in the Debugger. See also Processing Fields
Table
Displays the contents of an internal table. This mode allows you to display and edit the entries in an internal table. See also Processing Internal Tables
Breakpoints
A scrollable display containing up to 30 breakpoints. Next to each breakpoint is a counter. You can also delete breakpoints in this display. See also Managing Dynamic Breakpoints
Watchpoints
You can set a watchpoint for a field so that the program is interrupted whenever the value of that field changes. This display mode contains a list of watchpoints, the fields and programs to which they are assigned, the current values of the fields, and the conditions upon which the watchpoint is activated. See also Setting Watchpoints
Calls
This mode displays the current sequence of events, and the sequence of calls up to the current breakpoint. The last active call is displayed at the top of the list; previous calls are listed in reverse chronological order. When an event (for example, START-OF-SELECTION) concludes, it is deleted from the display.
Overview
This mode displays the structure of the program. It lists its events, subroutines, and modules, and shows which sections belong to which events. It also displays the section currently being processed.
Settings
This mode displays the current Debugger settings. You can change the settings by selecting or deselecting various options. For further information, refer to Settings and Warnings
Other Display Modes
You can access other display modes by choosing Goto ® Display data object.
Single field
Displays the contents and technical attributes of a field.
Structured
field
Displays the components of a structure, along with their contents and attributes. If you double-click a component, the system displays detailed information for it.
Strings
Display the content and current length of the string. You can also display part of the content by means of offset and length.
Internal table
Displays the type, line numbers and contents of an internal table.
Object
Displays the structure of an ABAP Object.
For further information on these displays, refer to Displaying Attributes and Displaying ABAP Objects
Checking System Programs for Errors
To check a program or program component that is part of the ABAP Workbench (for example, the Screen Painter), you must use the system Debugger. To start the system Debugger, choose System ® Utilities ® Debug System from any screen. To stop the system Debugger, choose Debugger ® Debugging off.
Displaying Program Attributes
You can display the attributes Fixed Point Arithmetic, System Program, and Unicode Checks of the program that has just been executed by choosing Goto ® Further Information ® Program Attributes.
Restarting the Debugger
If you choose Debugging ® Restart, debugging mode is stopped and the system takes you to the initial screen of the last transaction you called. If, for example, you started an ABAP program in debugging mode from transaction SE38 (ABAP Editor), choosing Debugging ® Restart will take you back to the screen titled ABAP Editor: Initial Screen. If you want to restart the program in debugging mode, choose Debugging.
Breakpoints
Apart from direct execution of an ABAP program in the Debugger, it is also possible to start the Debugger call by the exact setting of a breakpoint. This is achieved by setting one or more of these breakpoints in the program. A breakpoint is a signal at a particular point in the program that tells the ABAP runtime processor to interrupt processing and start the Debugger. The program runs normally until the breakpoint is reached.
There is also a special kind of breakpoint called a watchpoint. When you use watchpoints, the Debugger is not activated until the contents of a particular field change. For further information, refer to Watchpoints.
Breakpoint Variants
The Debugger contains different breakpoint variants:
Static
The BREAK-POINT statement in an ABAP program. Static breakpoints are not normally user-specific. However, you can make them user-specific.
Directly-set
dynamic breakpoints
Can be set in the ABAP Editor or the Debugger. Dynamic breakpoints are always user-specific, and are deleted when you log off from the R/3 System.
Breakpoints
at statement
The Debugger stops the program directly before the specified statement is executed.
Breakpoints
at subroutine
The Debugger stops the program directly before the specified subroutine is called.
Breakpoint at function module
The Debugger stops the program directly before the specified function module is called.
Breakpoint at method
The Debugger stops the program directly before the specified method is called.
Breakpoints at system exceptions
The Debugger stops the program directly after a system exception, that is, after a runtime error has been intercepted.
Static Breakpoints
Static breakpoints are not normally user-specific. Once a user has inserted the statement BREAK-POINT or BREAK name in an ABAP program, the system always interrupts the program at that point for that user or only for the user name. This procedure is only useful in the development phase of an application, when the program execution is always to be interrupted at the same place. For further information, refer to Static Breakpoints.
In HTTP sessions, a static breakpoint is skipped if you did not set additional dynamic HTTP breakpoints in the editor of a BSP page. Instead, a corresponding system log entry is written, which can be checked using transaction SM21.
Dynamic Breakpoints
Dynamic breakpoints are user-specific. Therefore, you should use them if you only want the program to be interrupted when you run it yourself, not when it is being executed by other users. All dynamic breakpoints are deleted when you log off from the R/3 System.
Dynamic breakpoints are more flexible than static breakpoints, because you can deactivate or delete them at runtime. They have the following advantages:
You do not have to change the program code
You can set them even when the program is locked by another programmer
You can define a counter that only activates the breakpoint after it has been reached
Special dynamic breakpoints are useful when you want to interrupt a program directly before a particular ABAP statement, a subroutine, or an event, but do not know exactly where to find it in the source code. Event here is used to refer to the occurrence of a particular statement, for example, or calling up a method. Special dynamic breakpoints are user-specific. You can only set them in the Debugger. For further information, refer to Dynamic Breakpoints.
In HTTP sessions, the system stops both at static and dynamic breakpoints if a dynamic breakpoint was set in the editor of a BSP page before program execution.
Lifetime and Transfer of Breakpoints
A static breakpoint remains intact as long as the BREAK-POINT or BREAK-POINT name statement is not removed from the source code. Without saving, dynamic breakpoints only remain intact in the relevant internal session. However, they are effective during the entire user session, if they are saved by choosing Breakpoints ® Save in the ABAP Debugger. For more details on the subject of sessions and user sessions, refer to Modularization Techniques in the ABAP keyword documentation.
If you call an HTTP session during a user session, only the HTTP breakpoints are loaded when the HTTP session is started. You activate HTTP debugging in the ABAP Editor by choosing Utilities ® Settings ® HTTP Debugging. Depending on the setting, the system then displays either the HTTP or standard breakpoints in the Editor.
If you call an update session during a user session, breakpoints that were defined beforehand in the calling processing unit are copied to the new update session, where they can be displayed under Breakpoints. If, in the ABAP Debugger, you check Update Debugging under Settings and then, for example, call the update module func using CALL FUNCTION func IN UPDATE TASK, a new window is opened in which you can debug this function module in the update session. All the breakpoints that were set in the calling processing unit can also be processed here.
Breakpoints at Statements
You can use this special kind of dynamic breakpoint to interrupt a program directly before an ABAP statement is processed.
Prerequisites
You must already be running the program in the Debugger.
Procedure
To set a breakpoint at an ABAP statement:
1.Choose Breakpoint ® Breakpoint at ® Statement...
The following dialog box appears:
2.Enter the ABAP statement.
The system sets a breakpoint at all points in the program at which the ABAP statement occurs.
3.Choose ENTER.
The breakpoint applies to all lines containing the specified statement.
Result
The system confirms the breakpoint and adds it to the list in the display. When you finish your debugging session, the breakpoint is automatically deleted unless you have explicitly saved it.
Breakpoints at Subroutines
You can use this special kind of dynamic breakpoint to interrupt a program directly before a subroutine is called.
Prerequisites
You must already be running the program in the Debugger.
Procedure
To set a breakpoint for a subroutine:
Choose Breakpoint ® Breakpoint at ® Event/Subroutine.
The following dialog box then appears:
Enter the name of the subroutine before which you want to interrupt the program. By default, the Program field contains the name of the program that is currently active. The system sets a breakpoint wherever the specified subroutine occurs in the program code.
Choose ENTER.
Result
The system confirms the breakpoint. The breakpoint is added to the breakpoints displayed.
Breakpoints at Function Module
You can use this kind of dynamic breakpoint to interrupt a program directly before a function module is called.
Prerequisites
You must already be running the program in the Debugger.
Procedure
To set a breakpoint for a function module:
Choose Breakpoint ® Breakpoint at ® Function module...
The following dialog box appears:
Enter the name of the function module before which you want to interrupt the program. The system sets a breakpoint wherever the specified event, module pool, or subroutine occurs in the program code.
Choose ENTER.
Result
If you entered a valid function module name, the system confirms that the breakpoint has been set. If the function module exists in the system, the new breakpoint is added to the display list.
Breakpoints at Methods
You can use this special kind of dynamic breakpoint to interrupt a program directly before a method is called.
Prerequisites
You must be already running the program in the debugger.
Procedure
To set a breakpoint for methods:
1. Choose Breakpoint ® Breakpoint at ® Method...
The following dialog box then appears:
2. Enter the name of the method and class before which you want to interrupt the program. A breakpoint is then set each time the specified processing block appears in the source code.
3. Choose ENTER.
Result
The system confirms the breakpoint. The breakpoint is added to the list in the display.
Breakpoints at System Exceptions
You can use this special form of dynamic breakpoint to interrupt a program immediately after a runtime error has occurred.
Prerequisites
You must already be running the program in the Debugger.
Procedure
To set a breakpoint at a system exception:
Choose Breakpoint ® Breakpoint at ® System exception.
Result
The system confirms the breakpoint. The breakpoint is added to the breakpoints displayed.
When a system exception is triggered, a warning triangle appears in the line containing the statement that caused it. If you double-click the warning triangle, the internal name of the runtime error appears.
Static Breakpoints
You should only use static breakpoints during the development phase of an application. You must remove them from your program before you transport it.
Setting Breakpoints
To set a static breakpoint, use the ABAP statement BREAK-POINT . Place the breakpoint in the line at which you want to interrupt the program.
program RSDEBUG_01.
if SY-SUBRC 0.
break-point.
endif.
When you run the program, the runtime processor interrupts it when the breakpoints occur. You can number your breakpoints to make them easier to identify ( BREAK-POINT 1, BREAK-POINT 2 ).
Static breakpoints are not normally user-specific. The program is, therefore, always interrupted as soon as the runtime processor reaches the line containing the breakpoint. The program is interrupted regardless of the user who executes it.
However, you can set user-specific static breakpoints using the BREAK statement followed by your user name. For example, if you use the statement BREAK SMITH , the program is only interrupted when user Smith runs it. Although user-specific breakpoints appear in the program code, they are not active when other users run the program. You should, however, be careful if an application is being used by several users with the same name.
Deleting Breakpoints
Since static breakpoints apply to all users, you must remove them from the program once you have finished testing it. In the ABAP Editor, you can find breakpoints quickly by choosing Utilities ® Global search. You can also use the Extended Program Check to find them.
If you do not remove static breakpoints from your program, they will be transported to your production system. This could cause serious problems in the production system.
Dynamic Breakpoints
You can set up to 30 dynamic breakpoints without changing the program code. Dynamic breakpoints can be set either in the ABAP Editor or directly in the Debugger.
Setting Dynamic Breakpoints in the ABAP Editor
You can set dynamic breakpoints in the ABAP Editor regardless of whether you are in display or change mode. You can also set breakpoints directly from within the Debugger at runtime. To set a dynamic breakpoint in the ABAP Editor:
Position the cursor on the line of the source code at which you want to set the breakpoint.
Choose Utilities ® Breakpoints ® Set or the Stop icon. The system confirms that the breakpoint has been set.
To display a list of all dynamic breakpoints in a program, choose Utilities ® Breakpoints ® Display. You can use this list to navigate to a particular breakpoint or to delete one or more breakpoints from the program.
Setting Dynamic Breakpoints in Debugging Mode
To set a dynamic breakpoint in the Debugger:
Position the cursor on the line in which you want to set the breakpoint.
Select the line by double-clicking it or choosing Breakpoint ® Set/delete.
The system sets the breakpoint, and displays a small stop sign to the left of the relevant line. If the line already contained a breakpoint, it is deleted.
When you finish your debugging session, the breakpoint is automatically deleted unless you have explicitly saved it.
Saving Breakpoints
If you want to leave the Debugger temporarily, you can save your dynamic breakpoints so that they are still active when you return to the Debugger within the same terminal session.
To save the breakpoints that you have set in the Debugger:
Choose Breakpoint ® Save.
The system saves all of the breakpoints that you have set in the current program. These breakpoints will remain active until you either explicitly delete them or log off from the system.
You can also delete breakpoints that you have saved:
By deleting individual breakpoints from the display and then saving again. In this case, only your selected breakpoints will be deleted.
By choosing Breakpoint ® Delete all. In this case, the system deletes all dynamic breakpoints.
Managing Dynamic Breakpoints
The ABAP Debugger provides a convenient user interface for managing breakpoints. To open the breakpoint display, choose Breakpoints, or, from the menu, Goto ® Control debugging ® Breakpoints.
Example
Functions
This display mode contains the following functions for breakpoints:
Breakpoint Display
The scrollable breakpoint display contains up to 30 dynamic breakpoints. For breakpoints that you set directly, the program name and line number at which the breakpoint occurs are displayed. For special breakpoint forms, the list displays the statements, events, subroutines, and module calls at which the relevant breakpoints are set.
Counter
In the breakpoint display, you can specify a counter. When you use a counter, the breakpoint is not activated until it has been reached a specified number of times. For example, if you enter 5 for the counter, the breakpoint is not activated until it is reached for the fifth time. After the breakpoint has been activated, it remains so, and the counter no longer appears in the breakpoint display.
Deleting Breakpoints
Position the cursor on the breakpoint that you want to delete, and either double-click the line or choose Breakpoint ® Set/delete. To delete all breakpoints, choose Breakpoint ® Delete all.
Activating and Deactivating Breakpoints
Position the cursor on the breakpoint that you want to activate or deactivate and choose Breakpoint ® Activate/deactivate.
Watchpoints
Like a breakpoint, a watchpoint is an indicator in a program that tells the ABAP runtime processor to interrupt the program at a particular point. Unlike breakpoints, however, watchpoints are not activated until the contents of a specified field change. Watchpoints, like dynamic breakpoints, are user-specific, and so do not affect other users running the same program. You can only define watchpoints in the Debugger.
Use
You set watchpoints in the Debugger to monitor the contents of specific fields. They inform you when the value of a field changes. When the value changes, the Debugger interrupts the program.
Features
You can set up to five watchpoints in a program.
See also Setting Watchpoints.
You can also specify the conditions on which a watchpoint is to become active.
You can specify logical conditions between up to five conditional watchpoints.
See Specifying a Logical Expression.
You can define watchpoints as either local or global. If you define a global watchpoint, it is active in all called programs. Local watchpoints are only active in the specified program.
You can change and delete watchpoints.
See Changing Watchpoints.
You can use watchpoints to display changes to the references of strings, data and object references, and internal tables.
See Memory Monitoring with Watchpoints
Setting Watchpoints
If you want to interrupt a program when the contents of a field or structure change, use a watchpoint. You can set up to five watchpoints, including watchpoints for strings.
A watchpoint can be either local or global. Local watchpoints are only valid in the specified program. Global watchpoints are valid in the specified program, and also in all the other programs it calls.
Procedure
To set a watchpoint, start the Debugger and proceed as follows:
Choose Breakpoint ® Create watchpoint or the corresponding pushbutton. The Create Watchpoint dialog box appears:
Decide whether you want to set a local or global watchpoint.
Enter the program and the name of the field for which you want to set the watchpoint. In the Program field, the name of the program currently running is always defaulted.
If you want your watchpoint to be activated each time the contents of the field change, the definition is now complete, and you can return to the Debugger by pressing ENTER .
To create a conditional watchpoint, that is only activated when a particular situation arises, choose one of the following relational operators.
Operator
Meaning
<
Less than
<=
Less than or equal
=
Equal
<>
Not equal
=
Greater than or equal
Greater than
You can use the Comparison field option to specify whether the comparison is to be carried out with a value that you specify or with the contents of another field. Depending on your choice from step 6, enter a value or a field for the comparison.
Result
The system confirms the watchpoint and adds it to the list in the display. When you finish your debugging session, the watchpoint is automatically deleted unless you have explicitly saved it.
Specifying Logical Links
If you have more than one conditional watchpoint, you can specify a logical link between them:
OR
Only one of the specified conditions must be met
AND
All of the conditions must be met.
Changing Watchpoints
Choose Goto ® Control debugging ® Watchpoints or the Watchpoints pushbutton to display the watchpoint list. The following dialog box appears:
Choose the pencil icon in the line containing the watchpoint you want to change.
Change the watchpoint attributes in the Create/Change Watchpoint.
Choose ENTER .
Deleting Watchpoints
You cannot delete watchpoints by choosing Breakpoint ® Delete or Breakpoint ® Deactivate/activate. Instead, proceed as follows:
Choose Goto ® Control debugging ® Watchpoints or the Watchpoints pushbutton to display the watchpoint list.
Choose the trashcan icon in the line containing the watchpoint you want to delete.
Memory Monitoring with Watchpoints
You can use watchpoints to display changes to the references of strings, data and object references, and internal tables. By placing an ampersand (&) in front of the object name, you can display the reference in question in hexadecimal format. With internal tables, you can also display the table header by placing an asterisk (*) at the beginning of the name.
&objectname
Displays the references of strings, internal tables as well as data and object references
*itab
Displays the table header of the internal table itab
Example
If a watchpoint is set for the object in question at runtime, the program is stopped as soon as the reference is changed. A short dump can be intercepted in this way to stop the program being terminated when the memory is overwritten.
Analyzing Source Code
The Debugger contains an extensive range of functions that help you to analyze the source code of a program. You can step through the source code of a program in four different ways. For further information, refer to Stepping Through the Source Code
For information about functions within the source code display, see Displaying the Source Code
There are also different display modes that provide various information and display the contents of individual fields, tables, and so on:
Reward if usefull

ABAP Program to split the records

Hi Experts,
As i am new to ABAP please update me with the required ABAP Code or atlease with the skeleton Code
Source & target fields
Emp_ID ZEMP_ID (CHAR)
Start Date: ZESTA_DT (DATS)
End Date : ZEEND_DT (DATS)
My requirment is to write a start routine that split the record in to 2
Emp_ID-Start_Date-Termination Date
0001----01/01/2005---01/01/2008
0002----01/01/2007---
(Termination date will be blank if emp is still working)
As per my requirment i would like to see data in DSO as
Emp_ID-Start_Date-Termination Date
0001----01/01/2005---
0001----01/01/2005---01/01/2008
0002----01/01/2007---
I want to split the records of an employee
Please let me know if u need any information
Thanks

Hi Srinivas,
Thanks for the update....
Please correct me my if i was wrong
Data:
Emp_ID-Start date------Termination Date
0001----01/01/2005---01/01/2008
0002------01/01/2005
Loop at itab.
if itab-ZEEND_DT is initial.
itab1 = itab.
append itab1.
else. " split the records ... based on termination ..
itab1 = itab.
clear itab1-ZEEND_DT
append itab1.
itab1 = itab.
append itab1.
endif.
endloop.
My requirment is for the above example data
For the employee 0001 as Termination date is not initial i need that record to be split in to 2
Emp_ID-Start date------Termination Date
0001------01/01/2005
0001----01/01/2005---01/01/2008
Please update

Abap program to find the list of SAP STANDARD reports in complete

Please send me if you have any program since when i run TRDIRT Table in se16 it gives all the program now how to distinguish by business area like sd mm fi its tedious to open every program and check what it is . is there any ABap program that put together the list of all the reports for FI, AP, AR and MM
Soniya Kapoor

Hi,
IN the table TRDIR give the application (TRDIR-APPL) and check the results..
Cross-Application
A Asset Accounting
B Business Information Warehouse
C PPC
D DASS (control station)
E RIVA
F Financial accounting
G General ledger
H Personnel Planning
I Plant maintenance
J Publishing
K Cost accounting
L Inventory management
M Materials management
N Hospital
P Human Resources
Q QSS (Quality assurance)
R Unknown application
S Basis
U Enterprise Data Model
V Sales
W MMS (Merchandise mgt. system)
Y Customer head office
Z Customer branch
Thanks,
Naren

How to see all the columns in the spool output of an ABAP program

I have an ABAP program which displays all the columns when I run it manually. (by scrolling to the right using right arrows). When I run that report in the scheduler and when I see the output in the spool in transaction SP01, it does allow me to go to the right to see all columns.
thanks
Ram

Check OSS Note 409339 - Spool requests with ABAP lists with more than 255 columns.
Summary
Symptom
As of Release 4.6x, the ABAP list processor can create spool requests for ABAP lists with a width of more
than 255 columns. However, when you print using the SAP spool, only the start of the list lines is printed,
the rest of the line is truncated at the end of the page.
Other terms
ABAP, lists, print parameter, LINE-SIZE
Reason and Prerequisites
Creating "wide" lists on the screen (in other words, lists in the SAPGUI with more than 255 columns) was
already introduced by the ABAP list processor for Release 4.0B. However, before Release 4.6 these lists
cannot be printed out in the width used on screen.
In older releases (for example, 4.0B, 4.5B), you were not able to generate spool requests for lists with a
width of more than 255 columns:
The system issues error message PT 026: "No. of columns > 255, no standard print-out possible".
Therefore, we did not have the problem described here of non-existing device-type support in 4.0/4.5 for
printing out "wide" lists.
Up to and including 4.6C there are no SAP device types that support print formats for lists with a width of
more than 255 characters). Since Release 3.0A, all SAP device types support a maximum list width of 255
characters with device format X_65_255.
Solution
When you create the spool request and a print dialog box appears, enter a column width of maximum 255
in the "Number of columns" field.
As of Release 4.6D, you have the option of using device type SWIN with the new format X_65_1024/4 when
printing with Windows (see Note 213382).

MDX - ABAP program variable to select the required month

Similar Messages

Maybe you are looking for