Skip to Content
avatar image
Former Member

please explain classical, ALV,interactive and Drill down reports briefly

please explain classical, ALV,interactive and Drill down reports briefly

Add comment
10|10000 characters needed characters exceeded

  • Get RSS Feed

4 Answers

  • avatar image
    Former Member
    Mar 19, 2008 at 01:07 PM

    Hi,

    1)Classical - Developing report using Write statements

    2)ALV - Using ALV Function modules ( REUSE_ALV*) or ALV Class

    3)Drill Down - (Interactive report). User can drill down by clicking a specific field / row.

    I think you are in the begining stage. There are lot of documents available for SAP ABAP. You can easily download from net.

    Best of luck.

    Reward if it gives an idea.

    Add comment
    10|10000 characters needed characters exceeded

  • avatar image
    Former Member
    Mar 20, 2008 at 04:52 AM

    Hai.

    check this.

    A classic report is a program that generates a single list, which must contain all of the required detail information.

    1) This procedure may result in extensive lists from which the user has to pick the relevant data.

    2) For background processing, this is the only possible method. After starting a background job, there is no way of influencing the program.

    3) The desired selections must be made beforehand and the list must provide detailed information.

    4) For dialog sessions, there are no such restrictions.

    5) The user is present during the execution of the program and can control and manipulate the program flow directly.

    6) To be able to use all advantages of the online environment, classical reporting was developed into interactive reporting.

    interactive:

    WHAT IS INTERACTIVE REPORTS?

    Interactive Reports

    As the name suggests, the user can Interact with the report. We can have a drill down into the report data. For example, Column one of the report displays the material numbers, and the user feels that he needs some more specific data about the vendor for that material, he can HIDE that data under those material numbers. And when the user clicks the material number, another report (actually sub report/secondary list) which displays the vendor details will be displayed.

    We can have a basic list (number starts from 0) and 20 secondary lists (1 to 21). Events associated with Interactive Reports are: 1. AT LINE-SELECTION 2. AT USER-COMMAND 3. AT PF<key> 4. TOP-OF-PAGE DURING LINE-SELECTION. HIDE statement holds the data to be displayed in the secondary list. sy-lisel : contains data of the selected line. sy-lsind : contains the level of report (from 0 to 21)

    Interactive Report Events:

    AT LINE-SELECTION : This Event triggers when we double click a line on the list, when the event is triggered a new sublist is going to be generated. Under this event what ever the statements that are been return will be displayed on newly generated sublist.

    AT PFn: For predefined function keys...

    AT USER-COMMAND : It provides user functions keys.

    pls find the docu for interactive reporting..

    ________________________________________________________________

    When the system processes event blocks that are not assigned to interactive list events, and when processing dialog modules, the ABAP program writes its list output to the basic list.

    The ABAP system field SY-LSIND contains the index of the list currently being created. While the basic list is being created, SY-LSIND is zero.

    By default, the basic list has a standard list status and a standard page header. The TOP-OF-PAGE and END-OF-PAGE events can occur while the basic list is being created. All output in these events is placed in the page header or footer of the basic list. In executable programs, the basic list is automatically sent to the list processor and displayed at the end of the END-OF-SELECTION event. Otherwise, it is displayed after the PAI processing block on the screen from which the LEAVE TO LIST-PROCESSING statement occurred.

    Creating Detail Lists

    Each time the user executes an action on a list, the runtime environment checks whether there is an event block defined that corresponds to the function code. If there is, SY-LSIND is automatically increased by one, and the relevant event block is executed. Any list output arising during this event block places its data into a new list (list level) with the index SY-LSIND. In order to create a new list level, the GUI status of the basic list must allow user actions, and the relevant event blocks must be defined in the program.

    All lists created during an interactive list event are detail lists. Each interactive list event creates a new detail list. With one ABAP program, you can maintain one basic list and up to 20 detail lists. If the user creates a list on the next level (that is, SY-LSIND increases), the system stores the previous list and displays the new one. The user can interact with whichever list is currently displayed.

    The system displays this list after processing the entire processing block of the event keyword or after leaving the processing block due to EXIT or CHECK. By default, the new list overlays the previous list completely. However, you can display a list in a dialog box. If no other dialog status is set in the event block for the detail list, the system uses the status from the previous list level. However, there is no standard page header for detail lists (see below).

    Consequences of Event Control

    The fact that you program detail lists in event blocks has important consequences. You cannot nest processing blocks (see Structure of an ABAP Program). Therefore, you cannot process other events within the processing blocks of interactive lists.

    Especially, you cannot

    &#149; use separate processing blocks to process further interactive events. A certain user action always triggers the same processing block in your program. You must use control statements (IF, CASE) within the processing block to make sure that the system processes the desired statements. There is a range of system field that you can use for this.

    &#149; use the event TOP-OF-PAGE to influence the list structure of secondary lists. To layout the page headers of the secondary lists, you must use the event TOP-OF-PAGE DURING LINE-SELECTION (see below). However, the system does process the event END-OF-PAGE in secondary lists.

    &#149; use events such as GET and GET LATE to retrieve data for secondary lists, but must use SELECT statements. You can use the logical database assigned to the executable program (report) only for the basic list. If you want to use a logical database during interactive events, you must either call another executable program using SUMIT, or (better) call the logical database using a function module.

    Navigating in Lists:

    To return from a high list level to the next-lower level (SY-LSIND), the user can choose back from a detail list. The system releases the last list to have been displayed, and returns to the previous list level. The system deletes the contents of the released list.

    To determine the list level in which the output from an event block will be displayed, you can change the value of the system fields SY-LSIND. This is one of the few exceptions to the rule that states that you must never overwrite ABAP system fields. The system accepts only index values which correspond to existing list levels. It then deletes all existing list levels whose index is greater or equal to the index you specify. For example, if you set SY-LSIND to 0, the system deletes all secondary lists and overwrites the basic list with the current secondary list.

    When you change SY-LSIND, the change only takes effect at the end of the corresponding event. If you work with statements that access the list with index SY-LSIND (using the INDEX addition - for example, SCROLL), you should set the new value of SY-LISND after these statements. The best place to set it is in the last statement of the event block.

    System Fields for Details Lists

    After each user action on a list, the following ABAP system fields will be set in the corresponding event block:

    System field

    SY-LSIND Index of the list created during the current event (basic list = 0)SY-LISTI Index of the list level from which the event was triggered

    SY-LILLI Absolute number of the line from which the event was triggered

    SY-LISEL Contents of the line from which the event was triggered

    SY-CUROW Position of the line in the window from which the event was triggered (counting starts with 1)

    SY-CUCOL Position of the column in the window from which the event was triggered (counting starts with 2)

    SY-CPAGE Page number of the first displayed page of the list from which the event was triggered

    SY-STARO Number of the first line of the first page displayed of the list from which the event was triggered (counting starts with 1). This line may contain the page header.

    SY-STACO Number of the first column displayed in the list from which the event was triggered (counting starts with 1)

    SY-UCOMM Function code that triggered the event

    SY-PFKEY Status of the list currently being displayed.

    Page Headers for Detail Lists

    On detail lists, the system does not display a standard page header and it does not trigger the event TOP-OF-PAGE. To create page headers for detail list, you must use a different TOP-OF-PAGE event:

    TOP-OF-PAGE DURING LINE-SELECTION.

    The system triggers this event for each detail list. If you want to create different page headers for different list levels, you must program the processing block of this event accordingly, for example by using system fields such as SY-LSIND or SY-PFKEY in control statements (IF, CASE).

    As on the basic list, the page header of a detail list remains displayed even when you scroll vertically.

    Messages on Detail Lists

    ABAP allows you to react to incorrect or possibly-incorrect user input by displaying messages. The seriousness of the error determines how program processing continues.

    In list processing, the message processing for the individual message types is as follows:

    A (=Abend): Termination

    The system displays the message in a dialog box. After the user confirms the message using ENTER , the system terminates the entire transaction (for example SE38).

    E (=Error) or W (=Warning):

    The system displays the message in the status bar. Once the user has confirmed the error by pressing ENTER, the current event block is terminated and the previous list level remains displayed. If you use an error or warning message while creating the basic list, the entire program is terminated.

    I (=Information):

    The system displays the message in a dialog box. Once the user has confirmed the message (ENTER), the program continues processing after the MESSAGE statement.

    S (= status)

    The system displays the message in the status bar of the current list.

    X (= Exit) Runtime error:

    This message type triggers a runtime error and generates a short dump.

    Using Detail Lists

    A classic report is a program that generates a single list, which must contain all of the required detail information. This procedure may result in extensive lists from which the user has to pick the relevant data. For background processing, this is the only possible method. After starting a background job, there is no way of influencing the program. The desired selections must be made beforehand and the list must provide detailed information.

    For dialog sessions, there are no such restrictions. The user is present during the execution of the program and can control and manipulate the program flow directly. To be able to use all advantages of the online environment, classical reporting was developed into interactive reporting.

    Interactive reporting allows the user to participate actively in retrieving and presenting data during the session. Instead of one extensive and detailed list, with interactive reporting you create a condensed basic list from which the user can call detailed information by positioning the cursor and entering commands. Interactive reporting thus reduces information retrieval to the data actually required. Detailed information is presented in detail lists.

    Apart from creating detail lists, interactive reporting also allows you to call transactions or other executable programs (reports) from lists. These programs then use values displayed in the list as input values. The user can, for example, call a transaction from within a list to change the database table whose data is displayed in the list.

    EXAMPLES

    Creating Detail Lists

    REPORT demo_list_interactive_1.

    START-OF-SELECTION.

    WRITE: 'Basic List, SY-LSIND =', sy-lsind.

    AT LINE-SELECTION.

    WRITE: 'Secondary List, SY-LSIND =', sy-lsind.

    When you run the program, the basic list appears. The GUI status automatically permits the function Choose (F2). When you choose a list line, the system triggers the AT LINE-SELECTION event, and the first detail list overlays the basic list. This list has no standard page header. It also inherits the GUI status of the basic list. By choosing Choose, the user can now create up to 19 of these lists. Trying to produce more than 19 lists results in a runtime error. Using Back , the user can return to previous lists.

    Navigation in detail lists.

    REPORT demo_list_interactive_2.

    START-OF-SELECTION.

    WRITE: 'Basic List, SY-LSIND =', sy-lsind.

    AT LINE-SELECTION.

    IF sy-lsind = 3.

    sy-lsind = 0.

    ENDIF.

    WRITE: 'Secondary List, SY-LSIND =', sy-lsind.

    When you run the program, the basic list appears:

    Basic List, SY-LSIND = 0

    The GUI status automatically permits the function Choose (F2). If the user positions the cursor on the list line and chooses Choose to trigger the AT LINE-SELECTION event, the system displays a detail list that contains the following line:

    Secondary List, SY-LSIND = 1

    Choosing Choose again produces:

    Secondary List, SY-LSIND = 2

    Back leads to the previous list level. Choosing Choose for the third time produces a detail list that contains the following line (because of the IF condition):

    Secondary List, SY-LSIND = 0

    The system deletes list levels 1 and 2. Choosing Back returns to the point at which the list processing started. If you choose Choose, the system creates a detail list with index 1. However, the list on level 0 is no longer a basic list (no page header), but is itself a detail list.

    Page Headers for Detail Lists

    REPORT demo_list_interactive_3.

    START-OF-SELECTION.

    WRITE 'Basic List'.

    AT LINE-SELECTION.

    WRITE 'Secondary List'.

    TOP-OF-PAGE DURING LINE-SELECTION.

    CASE sy-lsind.

    WHEN 1.

    WRITE 'First Secondary List'.

    WHEN 2.

    WRITE 'Second Secondary List'.

    WHEN OTHERS.

    WRITE: 'Secondary List, Level:', sy-lsind.

    ENDCASE.

    ULINE.

    When you run the program, the basic list appears. The user can choose Choose to create detail lists. The detail lists have page headers that are set according to the value of SY-LSIND.

    Messages on Detail Lists

    REPORT demo_list_interactive_4 NO STANDARD PAGE HEADING.

    AT LINE-SELECTION.

    WRITE 'Basic List'.

    MESSAGE s888(sabapdocu) WITH text-001.

    AT LINE-SELECTION.

    IF sy-lsind = 1.

    MESSAGE i888(sabapdocu) WITH text-002.

    ENDIF.

    IF sy-lsind = 2.

    MESSAGE e888(sabapdocu) WITH text-003 sy-lsind text-004.

    ENDIF.

    WRITE: 'Secondary List, SY-LSIND:', sy-lsind.

    When the program runs, the system displays the basic list and the success message 100 in the status line. A single click triggers the AT-LINE-SELECTION event. When the system creates the first detail list, it displays a dialog box with the information message 100. You cannot create the second detail list, because the message 200 has message type E:

    Add comment
    10|10000 characters needed characters exceeded

  • avatar image
    Former Member
    Mar 20, 2008 at 04:53 AM

    Hai.

    check this.

    ABAP List Viewer

    The common features of report are column alignment, sorting, filtering, subtotals, totals etc. To implement these, a lot of coding and logic is to be put. To avoid that we can use a concept called ABAP List Viewer (ALV).

    This helps us to implement all the features mentioned very effectively.

    Using ALV, We can have three types of reports:

    1. Simple Report

    2. Block Report

    3. Hierarchical Sequential Report

    There are some function modules which will enable to produce the above reports without much effort.

    All the definitions of internal tables, structures and constants are declared in a type-pool called SLIS.

    1. SIMPLE REPORT.

    The important function modules are

    a. Reuse_alv_list_display

    b. Reuse_alv_fieldcatalog_merge

    c. Reuse_alv_events_get

    d. Reuse_alv_commentary_write

    e. Reuse_alv_grid_display

    A. REUSE_ALV_LIST_DISPLAY : This is the function module which prints the data.

    The important parameters are :

    I. Export :

    i. I_callback_program : report id

    ii. I_callback_pf_status_set : routine where a user can set his own pf status or change the functionality of the existing pf status

    iii. I_callback_user_command : routine where the function codes are handled

    iv. I_structure name : name of the dictionary table

    v. Is_layout : structure to set the layout of the report

    vi. It_fieldcat : internal table with the list of all fields and their attributes which are to be printed (this table can be populated automatically by the function module REUSE_ALV_FIELDCATALOG_MERGE

    vii. It_events : internal table with a list of all possible events of ALV and their corresponding form names.

    II. Tables :

    i. t_outtab : internal table with the data to be output

    B. REUSE_ALV_FIELDCATALOG_MERGE : This function module is used to populate a fieldcatalog which is essential to display the data in ALV. If the output data is from a single dictionary table and all the columns are selected, then we need not exclusively create the field catalog. Its enough to mention the table name as a parameter(I_structure name) in the REUSE_ALV_LIST_DISPLAY. But in other cases we need to create it.

    The Important Parameters are :

    I. Export :

    i. I_program_name : report id

    ii. I_internal_tabname : the internal output table

    iii. I_inclname : include or the report name where all the dynamic forms are handled.

    II Changing

    ct_fieldcat : an internal table with the type SLIS_T_FIELDCAT_ALV which is

    declared in the type pool SLIS.

    C. REUSE_ALV_EVENTS_GET : Returns table of possible events for a list type

    Parameters :

    I. Import :

    Et_Events : The event table is returned with all possible CALLBACK events

    for the specified list type (column 'NAME'). For events to be processed by Callback, their 'FORM' field must be filled. If the field is initialized, the event is ignored. The entry can be read from the event table, the field 'FORM' filled and the entry modified using constants from the type pool SALV.

    II. Export :

    I_List_type :

    0 = simple list REUSE_ALV_LIST_DISPLAY

    1 = hierarchcal-sequential list REUSE_ALV_HIERSEQ_LIST_DISPLAY

    2 = simple block list REUSE_ALV_BLOCK_LIST_APPEND

    3 = hierarchical-sequential block list

    REUSE_ALV_BLOCK_LIST_HS_APPEND

    D. REUSE_ALV_COMMENTARY_WRITE : This is used in the Top-of-page event to print the headings and other comments for the list.

    Parameters :

    I. it_list_commentary : internal table with the headings of the type slis_t_listheader.

    This internal table has three fields :

    Typ : ‘H’ – header, ‘S’ – selection , ‘A’ - action

    Key : only when typ is ‘S’.

    Info : the text to be printed

    E. REUSE_ALV_GRID_DISPLAY : A new function in 4.6 version, to display the results in grid rather than as a preview.

    Parameters : same as reuse_alv_list_display

    This is an example for simple list.

    2. BLOCK REPORT

    This is used to have multiple lists continuously.

    The important functions used in this report are:

    A. REUSE_ALV_BLOCK_LIST_INIT

    B. REUSE_ALV_BLOCK_LIST_APPEND

    C. REUSE_ALV_BLOCK_LIST_HS_APPEND

    D. REUSE_ALV_BLOCK_LIST_DISPLAY

    A. REUSE_ALV_BLOCK_LIST_INIT

    Parameters:

    I. I_CALLBACK_PROGRAM

    II. I_CALLBACK_PF_STATUS_SET

    III. I_CALLBACK_USER_COMMAND

    This function module is used to set the default gui status etc.

    B. REUSE_ALV_BLOCK_LIST_APPEND

    Parameters :

    Export :

    I. is_layout : layout settings for block

    II. it_fieldcat : field catalog

    III. i_tabname : internal table name with output data

    IV. it_events : internal table with all possible events

    Tables :

    i. t_outtab : internal table with output data.

    This function module adds the data to the block.

    Repeat this function for all the different blocks to be displayed one after the other.

    C. REUSE_ALV_BLOCK_LIST_HS_APPEND

    This function module is used for hierarchical sequential blocks.

    D. REUSE_ALV_BLOCK_LIST_DISPLAY

    Parameters : All the parameters are optional.

    This function module display the list with data appended by the above function.

    Here the functions REUSE_ALV_FIELDCATALOG_MERGE, REUSE_ALV_EVENTS_GET, REUSE_ALV_COMMENTARY_WRITE can be used.

    3. Hierarchical reports :

    Hierarchical sequential list output.

    The function module is

    A. REUSE_ALV_HIERSEQ_LIST_DISPLAY

    Parameters:

    I. Export:

    i. I_CALLBACK_PROGRAM

    ii. I_CALLBACK_PF_STATUS_SET

    iii. I_CALLBACK_USER_COMMAND

    iv. IS_LAYOUT

    v. IT_FIELDCAT

    vi. IT_EVENTS

    vii. i_tabname_header : Name of the internal table in the program containing the

    output data of the highest hierarchy level.

    viii. i_tabname_item : Name of the internal table in the program containing the

    output data of the lowest hierarchy level.

    ix. is_keyinfo : This structure contains the header and item table field

    names which link the two tables (shared key).

    II. Tables

    i. t_outtab_header : Header table with data to be output

    ii. t_outtab_item : Name of the internal table in the program containing the

    output data of the lowest hierarchy level.

    slis_t_fieldcat_alv : This internal table contains the field attributes. This internal table can be populated automatically by using ‘REUSE_ALV_FIELDCATALOG_MERGE’.

    Important Attributes :

    A. col_pos : position of the column

    B. fieldname : internal fieldname

    C. tabname : internal table name

    D. ref_fieldname : fieldname (dictionary)

    E. ref_tabname : table (dictionary)

    F. key(1) : column with key-color

    G. icon(1) : icon

    H. symbol(1) : symbol

    I. checkbox(1) : checkbox

    J. just(1) : (R)ight (L)eft (C)ent.

    K. do_sum(1) : sum up

    L. no_out(1) : (O)blig.(X)no out

    M. outputlen : output length

    N. seltext_l : long key word

    O. seltext_m : middle key word

    P. seltext_s : short key word

    Q. reptext_ddic : heading (ddic)

    R. ddictxt(1) : (S)hort (M)iddle (L)ong

    S. datatype : datatype

    T. hotspot(1) : hotspot

    regards.

    sowjanya.b

    Add comment
    10|10000 characters needed characters exceeded

  • avatar image
    Former Member
    Mar 20, 2008 at 05:02 AM
    Add comment
    10|10000 characters needed characters exceeded