Abap hr standard screen question

Hi,
I want to learn if it is possible to create a screen at which we can get datas as we get from standard screens at hr.
I mean can we get data directly as we get by using 'get pernr' without using where condition at a infotype which we created.
Edited by: Begum Al on Aug 11, 2008 3:50 PM

Yes, you just need to link your program to the logical database PNP. Look at [Reporting in Human Resource Management|http://help.sap.com/printdocu/core/Print46c/en/data/pdf/HRREPORTING/HRREPORTING.pdf] and [Report Programming in HR|http://help.sap.com/printdocu/core/Print46c/en/data/pdf/PAXX/PYINT_PROGRAMM.pdf] and [Programming Utilities for the Logical Databases PNP and PAP|http://help.sap.com/printdocu/core/Print46c/en/data/pdf/PAXX/PYINT_RMAC.pdf], also do some [search at sdn.sap.com|https://www.sdn.sap.com/irj/sdn/advancedsearch?query=hr+report&cat=sdn_all]
Regards

Similar Messages

  • Abap-hr real time questions

    hi friends
    kindly send me ABAP-HR REAL TIME QUESTION to my mail [email protected]
    Thanks&Regards
    babasish

    Hi
    Logical database
    A logical database is a special ABAP/4 program which combines the contents of certain database tables. Using logical databases facilitates the process of reading database tables.
    HR Logical Database is PNP
    Main Functions of the logical database PNP:
    Standard Selection screen
    Data Retrieval
    Authorization check 
    To use logical database PNP in your program, specify in your program attributes.
    Standard Selection Screen
    Date selection
    Date selection delimits the time period for which data is evaluated. GET PERNR retrieves all records of the relevant infotypes from the database.  When you enter a date selection period, the PROVIDE loop retrieves the infotype records whose validity period overlaps with at least one day of this period.
    Person selection
    Person selection is the 'true' selection of choosing a group of employees for whom the report is to run.
    Sorting Data
    · The standard sort sequence lists personnel numbers in ascending order.
    · SORT function allows you to sort the report data otherwise. All the sorting fields are from infotype 0001.
    Report Class
    · You can suppress input fields which are not used on the selection screen by assigning a report class to your program.
    · If SAP standard delivered report classes do not satisfy your requirements, you can create your own report class through the IMG.
    Data Retrieval from LDB
    1. Create data structures for infotypes.
        INFOTYPES: 0001, "ORG ASSIGNMENT
                            0002, "PERSONAL DATA
                            0008. "BASIC PAY
    2. Fill data structures with the infotype records.
        Start-of-selection.
             GET PERNR.
        End-0f-selection. 
        Read Master Data
    Infotype structures (after GET PERNR) are internal tables loaded with data.
    The infotype records (selected within the period) are processed sequentially by the PROVIDE - ENDPROVIDE loop.
              GET PERNR.
                 PROVIDE * FROM Pnnnn BETWEEN PN/BEGDA AND PN/ENDDA
                        If Pnnnn-XXXX = ' '. write:/ Pnnnn-XXXX. endif.
                 ENDPROVIDE.
    Period-Related Data
    All infotype records are time stamped.
    IT0006 (Address infotype)
    01/01/1990   12/31/9999  present
              Which record to be read depends on the date selection period specified on the
              selection screen. PN/BEGDA PN/ENDDA.
    Current Data
    IT0006 Address  -  01/01/1990 12/31/9999   present
    RP-PROVIDE-FROM-LAST retrieves the record which is valid in the data selection period.
    For example, pn/begda = '19990931'    pn/endda = '99991231'
    IT0006 subtype 1 is resident address
    RP-PROVIDE-FROM-LAST P0006 1 PN/BEGDA PN/ENDDA.
    Process Infotypes
    RMAC Modules - RMAC module as referred to Macro, is a special construct of ABAP/4 codes. Normally, the program code of these modules is stored in table 'TRMAC'. The table key combines the program code under a given name. It can also be defined in programs.The RMAC defined in the TRMAC can be used in all Reports. When an RMAC is changed, the report has to be regenerated manually to reflect the change.
    Reading Infotypes - by using RMAC (macro) RP-READ-INFOTYPE
              REPORT ZHR00001.
              INFOTYPE: 0002.
              PARAMETERS: PERNR LIKE P0002-PERNR.
              RP-READ-INFOTYPE PERNR 0002 P0002 .
              PROVIDE * FROM P0002
                  if ... then ...endif.
              ENDPROVIDE.
    Changing Infotypes - by using RMAC (macro) RP-READ-INFOTYPE. 
    · Three steps are involved in changing infotypes:
    1. Select the infotype records to be changed;
    2. Make the required changes and store the records in an alternative table;
    3. Save this table to the database;
    The RP-UPDATE macro updates the database. The parameters of this macro are the OLD internal table containing the unchanged records and the NEW internal table containing the changed records. You cannot create or delete data. Only modification is possible.
    INFOTYPES: Pnnnn NAME OLD,
    Pnnnn NAME NEW.
    GET PERNR.
        PROVIDE * FROM OLD
               WHERE .... = ... "Change old record
               *Save old record in alternate table
               NEW = OLD.
        ENDPROVIDE.
        RP-UPDATE OLD NEW. "Update changed record
    Infotype with repeat structures
    · How to identify repeat structures.
    a. On infotype entry screen, data is entered in table form.
        IT0005, IT0008, IT0041, etc.
    b. In the infotype structure, fields are grouped by the same name followed by sequence number.
        P0005-UARnn P0005-UANnn P0005-UBEnn
        P0005-UENnn P0005-UABnn
    Repeat Structures
    · Data is entered on the infotype screen in table format but stored on the database in a linear  
      structure.
    · Each row of the table is stored in the same record on the database.
    · When evaluating a repeat structure, you must define the starting point, the increment and the
      work area which contains the complete field group definition.
    Repeat Structures Evaluation (I)
    · To evaluate the repeat structures
       a. Define work area.
           The work area is a field string. Its structure is identical to that of the field group.
       b. Use a DO LOOP to divide the repeat structure into segments and make it available for  
           processing in the work area, one field group (block) at a time.
    Repeat Structures Evaluation(II)
    Define work area
    DATA: BEGIN OF VACATION,
                  UAR LIKE P0005-UAR01, "Leave type
                  UAN LIKE P0005-UAN01, "Leave entitlement
                  UBE LIKE P0005-UBE01, "Start date
                  UEN LIKE P0005-UEN01, "End date
                  UAB LIKE P0005-UAB01, "Leave accounted
               END OF VACATION.
    GET PERNR.
         RP-PROVIDE-FROM-LAST P0005 SPACE PN/BEGDA PN/ENDDA.
         DO 6 TIMES VARYING VACATION
                 FROM P0005-UAR01 "Starting point
                     NEXT P0005-UAR02. "Increment
                 If p0005-xyz then ... endif.
          ENDDO.
    Processing 'Time Data'.
    · Dependence of time data on validity period
    · Importing time data
    · Processing time data using internal tables
    Time Data and Validity Period
    · Time data always applies to a specific validity period.
    · The validity periods of different types of time data are not always the same as the date selection period specified in the selection screen.
    Date selection period |----
    |
    Leave |----
    |
    · PROVIDE in this case is therefore not used for time infotypes.
    Importing Time Data
    · GET PERNR reads all time infotypes from the lowest to highest system data, not only those within the date selection period.
    · To prevent memory overload, add MODE N to the infotype declaration. This prevents the logical database from importing all data into infotype tables at GET PERNR.
    · Use macro RP-READ-ALL-TIME-ITY to fill infotype table.
    INFOTYPES: 2001 MODE N.
    GET PERNR.
        RP-READ-ALL-TIME-ITY PN/BEGDA PN/ENDDA.
        LOOP AT P0021.
             If P0021-XYZ = ' '. A=B. Endif.
        ENDLOOP.
    Processing Time Data
    · Once data is imported into infotype tables, you can use an internal table to process the interested data.
    DATA: BEGIN OF ITAB OCCURS 0,
                  BUKRS LIKE P0001-BUKRS, "COMPANY
                  WERKS LIKE P0001-WERKS, "PERSONNEL AREA
                  AWART LIKE P2001-AWART, "ABS./ATTEND. TYPE
                  ASWTG LIKE P2001-ASWTG, "ABS./ATTEND. DAYS
               END OF ITAB.
    GET PERNR.
    RP-PROVIDE-FROM-LAST P0001 SAPCE PN/BEGDA PN/ENDDA.
    CLEAR ITAB.
    ITAB-BUKRS = P0001-BURKS. ITAB-WERKS = P0001-WERKS.
    RP-READ-ALL-TIME-ITY PN/BEGDA PN/ENDDA.
    LOOP AT P2001.
          ITAB-AWART = P2001-AWART. ITAB-ASWTG = P2001-ASWTG.
          COLLECT ITAB. (OR: APPEND ITAB.)
    ENDLOOP.
    Database Tables in HR
    ·  Personnel Administration (PA) - master and time data infotype tables (transparent tables).
       PAnnnn: e.g. PA0001 for infotype 0001
    ·  Personnel Development (PD) - Org Unit, Job, Position, etc. (transparent tables).
       HRPnnnn: e.g. HRP1000 for infotype 1000
    ·  Time/Travel expense/Payroll/Applicant Tracking data/HR work areas/Documents (cluster  
       PCLn: e.g. PCL2 for time/payroll results.
    Cluster Table
    · Cluster tables combine the data from several tables with identical (or almost identical) keys
      into one physical record on the database.
    . Data is written to a database in compressed form.
    · Retrieval of data is very fast if the primary key is known.
    · Cluster tables are defined in the data dictionary as transparent tables.
    · External programs can NOT interpret the data in a cluster table.
    · Special language elements EXPORT TO DATABASE, IMPORT TO DATABASE and DELETE
      FROM DATABASE are used to process data in the cluster tables.
    PCL1 - Database for HR work area;
    PCL2 - Accounting Results (time, travel expense and payroll);
    PCL3 - Applicant tracking data;
    PCL4 - Documents, Payroll year-end Tax data
    Database Tables PCLn
    · PCLn database tables are divided into subareas known as data clusters.
    · Data Clusters are identified by a two-character code. e.g RU for US payroll result, B2 for
      time evaluation result...
    · Each HR subarea has its own cluster.
    · Each subarea has its own key.
    Database Table PCL1
    · The database table PCL1 contains the following data areas:
      B1 time events/PDC
      G1 group incentive wages
      L1 individual incentive wages
      PC personal calendar
      TE travel expenses/payroll results
      TS travel expenses/master data
      TX infotype texts
      ZI PDC interface -> cost account
    Database Table PCL2
    · The database table PCL2 contains the following data areas:
      B2 time accounting results
      CD cluster directory of the CD manager
      PS generated schemas
      PT texts for generated schemas
      RX payroll accounting results/international
      Rn payroll accounting results/country-specific ( n = HR country indicator )
      ZL personal work schedule
    Database Table PCL3
    · The database table PCL3 contains the following data areas:
      AP action log / time schedule
      TY texts for applicant data infotypes
    Data Management of PCLn
    · The ABAP commands IMPORT and EXPORT are used for management of read/write to
      database tables PCLn.
    · A unique key has to be used when reading data from or writing data to the PCLn.
      Field Name KEY Length Text
      MANDT X 3 Client
      RELID X 2 Relation ID (RU,B2..)
      SRTFD X 40 Work Area Key
      SRTF2 X 4 Sort key for dup. key
    Cluster Definition
    · The data definition of a work area for PCLn is specified in separate programs which comply  
       with fixed naming conventions.
    · They are defined as INCLUDE programs (RPCnxxy0). The following naming convention applies:
       n = 1 or 2 (PCL1 or PCL2)
       xx = Relation ID (e.g. RX)
       y = 0 for international clusters or country indicator (T500L) for different country cluster
    Exporting Data (I)
    · The EXPORT command causes one or more 'xy' KEY data objects to be written to cluster xy.
    · The cluster definition is integrated with the INCLUDE statement.
    REPORT ZHREXPRT.
    TABLES: PCLn.
    INCLUDE: RPCnxxy0. "Cluster definition
    Fill cluster KEY
    xy-key-field = .
    Fill data object
    Export record
    EXPORT TABLE1 TO DATABASE PCLn(xy) ID xy-KEY.
       IF SY-SUBRC EQ 0.
           WRITE: / 'Update successful'.
       ENDIF.
    Exporting Data (II)
    . Export data using macro RP-EXP-Cn-xy.
    · When data records are exported using macro, they are not written to the database but to a  
      main memory buffer.
    · To save data, use the PREPARE_UPDATE routine with the USING parameter 'V'.
    REPORT ZHREXPRT.
    *Buffer definition
    INCLUDE RPPPXD00. INCLUDE RPPPXM00. "Buffer management
    DATA: BEGIN OF COMMON PART 'BUFFER'.
    INCLUDE RPPPXD10.
    DATA: END OF COMMON PART 'BUFFER'.
    RP-EXP-Cn-xy.
    IF SY-SUBRC EQ 0.
        PERFORM PREPARE_UPDATE USING 'V'..
    ENDIF.
    Importing Data (I)
    · The IMPORT command causes data objects with the specified key values to be read from
       PCLn.
    · If the import is successful, SY-SUBRC is 0; if not, it is 4.
    REPORT RPIMPORT.
    TABLES: PCLn.
    INCLUDE RPCnxxy0. "Cluster definition
    Fill cluster Key
    Import record
    IMPORT TABLE1 FROM DATABASE PCLn(xy) ID xy-KEY.
       IF SY-SUBRC EQ 0.
    Display data object
       ENDIF.
    Importing data (II)
    · Import data using macro RP-IMP-Cn-xy.
    · Check return code SY-SUBRC. If 0, it is successful. If 4, error.
    · Need include buffer management routines RPPPXM00
    REPORT RPIMPORT.
    *Buffer definition
    INCLUDE RPPPXD00.
    DATA: BEGIN OF COMMON PART 'BUFFER'.
    INCLUDE RPPPXD10.
    DATA: END OF COMMON PART 'BUFFER'.
    *import data to buffer
    RP-IMP-Cn-xy.
    *Buffer management routines
    INCLUDE RPPPXM00.
    Cluster Authorization
    · Simple EXPORT/IMPORT statement does not check for cluster authorization.
    · Use EXPORT/IMPORT via buffer, the buffer management routines check for cluster
      authorization.
    Payroll Results (I)
    · Payroll results are stored in cluster Rn of PCL2 as field string and internal tables.
      n - country identifier.
    · Standard reports read the results from cluster Rn. Report RPCLSTRn lists all payroll results;
      report RPCEDTn0 lists the results on a payroll form.
    Payroll Results (II)
    · The cluster definition of payroll results is stored in two INLCUDE reports:
      include: rpc2rx09. "Definition Cluster Ru (I)
      include: rpc2ruu0. "Definition Cluster Ru (II)
    The first INCLUDE defines the country-independent part; The second INCLUDE defines the country-specific part (US).
    · The cluster key is stored in the field string RX-KEY.
    Payroll Results (III)
    · All the field string and internal tables stored in PCL2 are defined in the ABAP/4 dictionary. This
      allows you to use the same structures in different definitions and nonetheless maintain data
      consistency.
    · The structures for cluster definition comply with the name convention PCnnn. Unfortunately, 
       'nnn' can be any set of alphanumeric characters.
    *Key definition
    DATA: BEGIN OF RX-KEY.
         INCLUDE STRUCTURE PC200.
    DATA: END OF RX-KEY.
    *Payroll directory
    DATA: BEGIN OF RGDIR OCCURS 100.
         INCLUDE STRUCTURE PC261.
    DATA: END OF RGDIR.
    Payroll Cluster Directory
    · To read payroll results, you need two keys: pernr and seqno
    . You can get SEQNO by importing the cluster directory (CD) first.
    REPORT ZHRIMPRT.
    TABLES: PERNR, PCL1, PCL2.
    INLCUDE: rpc2cd09. "definition cluster CD
    PARAMETERS: PERSON LIKE PERNR-PERNR.
    RP-INIT-BUFFER.
    *Import cluster Directory
       CD-KEY-PERNR = PERNR-PERNR.
    RP-IMP-C2-CU.
       CHECK SY-SUBRC = 0.
    LOOP AT RGDIR.
       RX-KEY-PERNR = PERSON.
       UNPACK RGDIR-SEQNR TO RX-KEY-SEQNO.
       *Import data from PCL2
       RP-IMP-C2-RU.
       INLCUDE: RPPPXM00. "PCL1/PCL2 BUFFER HANDLING
    Function Module (I)
      CD_EVALUATION_PERIODS
    · After importing the payroll directory, which record to read is up to the programmer.
    · Each payroll result has a status.
      'P' - previous result
      'A' - current (actual) result
      'O' - old result
    · Function module CD_EVALUATION_PERIODS will restore the payroll result status for a period
       when that payroll is initially run. It also will select all the relevant periods to be evaluated.
    Function Module (II)
    CD_EVALUATION_PERIODS
    call function 'CD_EVALUATION_PERIODS'
         exporting
              bonus_date = ref_periods-bondt
              inper_modif = pn-permo
              inper = ref_periods-inper
              pay_type = ref_periods-payty
              pay_ident = ref_periods-payid
         tables
              rgdir = rgdir
              evpdir = evp
              iabkrs = pnpabkrs
         exceptions
              no_record_found = 1.
    Authorization Check
       Authorization for Persons
    ·  In the authorization check for persons, the system determines whether the user has the 
       authorizations required for the organizational features of the employees selected with
       GET PERNR.
    ·  Employees for which the user has no authorization are skipped and appear in a list at the end
       of the report.
    ·  Authorization object: 'HR: Master data'
    Authorization for Data
    · In the authorization check for data, the system determines whether the user is authorized to
      read the infotypes specified in the report.
    · If the authorization for a particular infotype is missing, the evaluation is terminated and an error
      message is displayed.
    Deactivating the Authorization Check
    · In certain reports, it may be useful to deactivate the authorization check in order to improve
      performance. (e.g. when running payroll)
    · You can store this information in the object 'HR: Reporting'.
    these are the main areas they ask q?

  • MATCHCAODE + standard screen

    Hi experts,
    I have a following requirement:
    create a  matchcode on REBZG (Number of the invoice) in the standard screen of the  the transaction mir7 (or fv60,fb60).
    How to do that? via a badi, user_exit?
    how to do techically the match-code (se11, in the user_exit, badi).
    the screen field in the standard screen is INVFO-REBZG where INVFO is a structure and not table? i dont know where the values of REBZG are stored? because INVFO and not a structure
    Many Thanks

    Hi,
    No, you can't avoid this. And the why is already on your question: the screen gets regenerated every time it gets changed. As simple as that.
    Edit: actually, there's a way to avoid it: do not change the selection screen
    Cheers,
    Custodio

  • Add Custom field to standard screen with table control

    Hello,
    I need to add two custom fields to a standard screen in CAT2 transaction(not using any screen exit).I will be given SSCR key.The standard screen (screen no. 2100) only has a table control.
    How can I add the custom field such that it appears as a field on the screen when CAT2 transaction is opened.
    Do i need to write any code?
    I'm new to ABAP so could you please give a detailed explanation.
    Also, do i need to change the 'fixed columns' field in the table control?
    Regards,
    Monica.

    hi,
    1) find the screen
    2) add new fields to the screen
    3) program PBO and PAI
    regards,
    Wojciech

  • What is module pool programming?how we can change the standard screen?

    Hi EXPERTS
    what is module pool programming?how we can change the standard screen using module pool programming ?
    please explain with example.

    Check the below link:
    http://wiki.ittoolbox.com/index.php/FAQ:What_is_module_pool_program_in_abap%3F
    http://help.sap.com/saphelp_46c/helpdata/en/35/26b1aaafab52b9e10000009b38f974/content.htm
    http://sap.mis.cmich.edu/sap-abap/abap09/sld011.htm
    http://sap.mis.cmich.edu/sap-abap/abap09/index.htm
    http://www.geocities.com/ZSAPcHAT
    http://www.allsaplinks.com/files/using_table_in_screen.pdf
    http://help.sap.com/saphelp_webas630/helpdata/en/9f/db9cdc35c111d1829f0000e829fbfe/content.htm
    http://www.sapdevelopment.co.uk/dialog/dialoghome.htm
    http://www.sap-img.com/
    http://help.sap.com/saphelp_46c/helpdata/en/08/bef2dadb5311d1ad10080009b0fb56/content.htm
    http://www.sapgenie.com/links/abap.htm
    http://help.sap.com/saphelp_nw04/helpdata/en/c9/5472fc787f11d194c90000e8353423/frameset.htm
    You can also check the transaction ABAPDOCU which gives you lot of sample programs.
    Also you can see the below examples...
    Go to se38 and give demodynpro and press F4.
    YOu will get a list of demo module pool programs.
    One more T-Code is ABAPDOCU.
    YOu can find more examples there.
    See the prgrams:
    DEMO_DYNPRO_TABLE_CONTROL_1 Table Control with LOOP Statement
    DEMO_DYNPRO_TABLE_CONTROL_2 Table Control with LOOP AT ITAB
    http://www.geocities.com/ZSAPcHAT
    http://www.allsaplinks.com/files/using_table_in_screen.pdf
    regards,
    venkat.

  • Abap program standards

    hi all,
         i need to design flow chart for checking for a program whether it satifies the abap coding standards or not. who to do it. if possible send me graphical representations [flow charts]  or links to find programming standards.
    some of my requirements in that folw chart are
      1. how to recognize a blank space in a given program,
      2. how to recognize a comment,
      3. how to check wheteher a keyword is used or not,
      4. how to identify the ' :' symbol
    thanks & regards,
    suresh babu aluri.

    plz go through this documementaion,
    i think its helpful.
    ABAP Programming StandardsContents
    1.     Objective     5
    2.     Naming Conventions     5
    2.1     Codes for naming conventions     5
    2.1.1     Module Codes     5
    2.1.2     Free text     6
    2.2     Naming Convention of Development Objects     6
    2.2.1     Package     6
    2.2.2     Executable Program     6
    2.2.3     BSP Application     7
    2.2.4     Logical Database     8
    2.2.5     SAP Scripts /Smartforms     9
    2.2.6     Idocs     9
    2.2.7     Transaction Code     10
    2.2.8     Function Groups     10
    2.2.9     Dictionary Objects     11
    2.2.10     Message Class     11
    2.2.11     Enhancement Projects (User Exits)     11
    2.2.12     LSMW Objects     12
    2.2.13     Classes     12
    2.2.14     BOR Object Types     13
    2.2.15     Screen / Transaction Variants     13
    2.2.16     Area Menu     13
    2.3     Naming of Sub-Objects     13
    2.3.1     Program Sub-Objects     13
    2.3.2     SAP Script /Smartform sub-objects     14
    3.     General Programming Guidelines     14
    3.1     Modification Logs     14
    3.2     Program Organization     15
    3.2.1     Executable Programs     15
    3.2.2     Dialog Programs     15
    3.3     Package     15
    3.3.1     Adding Components to existing objects     15
    3.3.2     Creation of New Objects     15
    3.4     Program Messages     15
    3.4.1     Adding Messages to existing landscapes     15
    3.4.2     Creation of New Objects     16
    3.5     Dictionary Objects     16
    4.     Structure of ABAP Programs     16
    4.1     Type     16
    4.2     Status     18
    4.3     Authority Check     18
    4.4     Program Structure     19
    4.4.1     Declaration data for global data, classes and selection screens     19
    4.4.2     Container for Processing Blocks     19
    4.4.3     Calling Processing Blocks     20
    4.5     Screen Flow Logic (Dialog Programs)     20
    4.5.1     Place the AT EXIT COMMAND at the beginning of the flow logic.     20
    4.5.2     Use FIELD and CHAIN statements to keep fields in error open for correction.     20
    4.6     Main Program     20
    4.6.1     Events     20
    5.     General Coding Standards     21
    5.1     One command per line     21
    5.2     Indented Source Code     21
    5.3     Extended Syntax Check     21
    5.4     Reusability and Modularity     21
    5.5     Text Handling     21
    5.6     Usage of System Variables     22
    5.7     Chaining Statements     22
    5.8     Common Routines     22
    5.9     Dialog Messages     22
    5.10     Function Keys     23
    5.11     Enqueuing and Dequeuing Data Objects     23
    5.12     Error Handling (SY-SUBRC)     23
    5.13     General Conventions and Hints     24
    5.14     Parameters in Sub-Routines     24
    6.     Performance Standards     25
    6.1     General Tips on Performance Tuning     25
    6.1.1     Avoid Redundant code     25
    6.1.2     Subroutine Usage     25
    6.1.3     Case vs. Nested IF     25
    6.1.4     Using the MOVE Statement     25
    6.1.5     SELECT Queries     25
    6.1.6     Using the READ statement     27
    6.1.7     Hashed table     27
    6.1.8     Transporting     28
    6.1.9     Using LDB     28
    6.1.10     Append Lines of     28
    6.1.11     Use WHILE     28
    6.1.12     DELETE <itab> WHERE     28
    6.1.13     Using WHERE clause in LOOP…….ENDLOOP     28
    1.     Objective
    The objective of this document is to describe general programming guidelines, methodologies, Naming conventions and performance guidelines for all the programs developed for SAP Project.
    2.     Naming Conventions
    This chapter describes the naming conventions to be followed for naming the programming objects for SAP project.
    2.1      Codes for naming conventions
    The variable portion of naming convention is given with Code ID given in angle brackets(<>). Use the following tables for replacing code IDs with codes in the object naming.
    2.1.1     Module Codes
    Code ID:  mm
    Code     Description
    FI     Finance
    CO     Controlling Module
    MM     Materials Management
    PP      Production Planning
    SD     Sales & Distribution
    QM      Quality Management
    PM     Plant Maintenance
    IM     Inventory Management
    WM     Warehouse Management
    BC     Basis Module
    BW     Business Warehouse
    WF     Workflows (Master Data Management)
    HR     Human Resources
    EBP     EBP
    PS     Project Systems
    PCP     Synpro: Product Costing
    PAP     Synpro: COPA
    DP     APO :  Demand Planning
    SP     APO :  Supply Network Planning
    DS      APO : Production Planning & Detailed Scheduling
    AT     APO : Global ATP
    TP     APO : Transportation Planning/Vehicle Scheduling
    CI     Core Interface
    LC     Live Cache
    2.1.2     Free text
    Code ID: ffff
    Developer should replace ‘ffff’ with meaningful text. The text can be multiple words separated by underscore.
    2.2     Naming Convention of Development Objects
    2.2.1     Package
    Naming Convention: Z<mm>_<ffff>.
    Notes:
    1.     Replace <mm> with Module codes given in section 2.1.1 above.
    2.     Replace <ffff> with the sub-landscape of the Module that this Message Class caters to as illustrated in examples below.
    3.     The maximum permissible length for development class is 30 characters
    Examples:
    Dev. Class     Description
    ZFI_AR     FI: Account Receivables
    ZCO_CCA     CO: Cost Center Accounting
    2.2.2     Executable Program
    Naming Convention: Z<mm>_<ffff>.
    Notes:
    1.     Replace <mm> with module codes given in section 2.1.1 above.
    2.     Replace <ffff> with meaningful text as illustrated in examples below.
    3.     The maximum permissible length for program name is 30 characters. However, the name should be restricted to 25 characters to accommodate appropriate Include naming as described in 2.2.2.
    Examples:
    Program Name     Description
    ZFI_VAT_RET     FI:  Report for VAT Return
    ZMM_AUTO_GR     MM: Automated Goods Receipt
    ZSD_XX_STCK_SHORTAGE     SD: Stock shortage report for stock allocation
    2.2.2.1     Includes for executable programs
    Naming Convention: Z<mm>_<ffff>_<Inn>.
    Notes:
    1.     All includes of executable program will be prefixed by Z, followed by the same program name as described in 2.2.2 above.
    2.     Replace <Inn> with include type and sequence number. Use the following table for includes.
    Include Type ID     Description
    TOP     Top Include.
    Fnn     Subroutine pool (Forms)
    Inn     PAI Modules
    Onn     PBO Modules
    Xnn     Other Includes
    The maximum permissible length for Include name is 30 characters.
    Examples:
    Include Name     Main Program Name     Description
    ZFI_VAT_RET_TOP     ZFI_VAT_RET     FI:  Report for VAT Return – Top Include
    ZFI_VAT_RET_F01     ZFI_VAT_RET     FI:  Report for VAT Return – Forms
    ZMM_AUTO_GR_TOP     ZMM_FR_AUTO_GR     MM: – Automated Goods Receipt – Top include
    ZMM_AUTO_GR_F01     ZMM_FR_AUTO_GR     MM:– Automated Goods Receipt – Forms
    2.2.3     BSP Application
    2.2.3.1     Main Application
    Naming Convention: BSP Applications shall follow the same Naming Convention as Executable Programs i.e. Z<mm>_<ffff>.
    Notes:
    1.     Replace <mm> with module codes given in section 2.1.1 above.
    2.     Replace <ffff> with meaningful text as illustrated in examples below.
    2.2.3.2     Pages & Controllers
    Naming Convention: <ffff>
    Notes:
    1.     Replace <ffff> with meaningful text, that adequately describes the function of the page/controller
    2.2.3.3     Theme
    Naming Convention: Z_<ffff>.
    Notes:
    1.     Replace <ffff> with meaningful text
    2.2.3.4     Mime Objects:
    Naming Convention: <ffff>
    1.     A MIME Object can be logo for the company.
    2.     Replace <ffff> with meaningful text, that adequately describes the function of the MIME objects
    2.2.3.5     Controller and Handler Classes:
    See section Classes (Section 2.2.133)
    2.2.3.6     BSP Extension
    Naming Convention: Z_<ffff>
    Notes:
    1.     Replace <ffff> with meaningful text
    2.2.3.7     BSP Layout elements id
    Label:     lb_fffff
    Input field:     if_fffff
    Button:     b_fffff
    Text Edit:     te_fffff
    Text View:     tv_fffff
    Radio button Group:     rbg_fffff
    Radio button:     rb_fffff
    Check Box Group:     cbg_fffff
    Check Box     cb_fffff
    Tray     tr_fffff
    Tabstrip     ts_fffff
    Tableview      tab_fffff
    1.  Replace <fffff> with meaningful text
    2.2.4     Logical Database
    Naming Convention: Z<mm>_<ffff>.
    Notes:
    1.     Replace <mm> with module codes given in section 2.1.1 above.
    2.     Replace <ffff> with meaningful text
    3.     The maximum permissible length for LDB name is 20 characters. However, the name should be restricted to 15 characters to accommodate appropriate Include naming
    4.     LDB Program and LDB Program Includes shall follow the naming convention Auto-Generated by SAP
    2.2.5     SAP Scripts /Smartforms
    Naming Convention: ZF<mm>_<ffff>.
    Notes:
    1.     Replace <mm> with module codes given in section 2.1.1 above.
    2.     Replace <ffff> with meaningful text as illustrated in examples below.
    Examples:
    Form Name     Description
    ZFFI_EMP_CONF     Employee Confirmation Letter
    ZFFI_ANN_TO     Annual Turnover Letter To Customers and Vendors
    2.2.6     Idocs
    2.2.6.1     Idoc Types
    Basic Type :
    Naming Convention : ZB<FFFF>NN
    Notes:
    1.Replace <NN> with sequence number.
    3.     Replace <ffff> with meaningful text.
    Extension Type : ZX<Basic type name>_NN
    Notes:
    1.     Replace <NN> with sequence number .
    2.2.6.2     Message Types
    Naming Convention :  ZM<mm><ffff>.
    Notes :
    1.   Replace <mm> with module codes given in section 2.1.1 above.
    2.  Replace <ffff> with meaningful text .
    2.2.6.3      Process Code
    Naming Convention :  Z<ffff>.
    Notes :
    1.     Replace <ffff> with meaningful text ..
    2.2.6.4     IDOC Segments
    Naming Convention :  Z1<ffff>.
    Notes :
    1.Replace <ffff> with meaningful text as illustrated in examples below.
    2.2.7     Transaction Code
    Notes:
    1.     The tcode name is provided by SAP TIN The Developer must write a mail to SAP Tin asking for the T-Code name with a filled form.
    The form can be found at :
    2.2.8     Function Groups
    Naming Convention: Z<mm><ffff>
    Notes:
    1.     Replace <mm> with relevant module code as given above
    2.     Replace <ffff> with meaningful text.
    2.2.8.1     Function Group Include Programs
    Naming Convention: LZ<Function Group><Inn>.
    Notes:
    1.     All includes of Function Group program will be prefixed by LZ, followed by the Function Group name
    2.     Replace <Inn> with include type and sequence number. Use the values from the table given in 2.2.2.1
    Examples:
    Include Name     Function Group Name     Description
    SAPLZMMPURCHASING     ZMMPURCHASING     F.Group-Purchasing: Main Program
    LZMMPURCHASINGO01     ZMMPURCHASING     F.Group-Purchasing: PBO
    LZMMPURCHASINGI01     ZMMPURCHASING     F.Group-Purchasing: PAI
    LZMMPURCHASINGF01     ZMMPURCHASING     F.Group-Purchasing: Forms
    LZMMPURCHASINGTOP     ZMMPURCHASING     F.Group-Purchasing: Data Declarations
    2.2.8.2     Function Modules
    2.2.8.2.1     Normal Function Modules
    Convention: Z_<mm>_<ffff>.
    Notes:
    1.     Replace <mm> with relevant module code as given above.
    2.     Replace <ffff> with meaningful text.
    2.2.8.2.2     IDOC Function Modules
    Convention: Z_IDOC_<mode>_<msg type>.
    Notes:
    1.     Replace <mode> with INPUT or OUTPUT depending on whether the function processes incoming or outgoing IDOC.
    2.     Replace <msg type> with the IDOC message type.
    2.2.9     Dictionary Objects
    Tables:      Z<mm><ffff>
    Structures:      ZS<mm><ffff>
    Views:      ZV<mm><ffff>
    Data Element:      ZDE<mm><ffff>
    Domain:      ZDO<mm><ffff>
    Table Type:      ZTT<mm><ffff>
    Type Group:      Z<ffff>
    Search Help:      ZSH<mm><ffff>
    Lock Object:      EZ<mm><ffff>
    Notes:
    1.     Replace <mm> with module code given above.
    2.     Replace <ffff> with meaningful text.
    2.2.10     Message Class
    Naming Convention: Z<mm>_<ffff>.
    Notes:
    1.     Replace <mm> with Module codes given in section 2.1.1 above.
    2.     Replace <ffff> with the sub-landscape of the Module that this Message Class caters to as illustrated in examples below.
    3.     The maximum permissible length for development class is 30 characters
    Examples:
    Msg. Class     Description
    ZFI_AR     FI: Account Receivables
    ZCO_CCA     CO: Cost Center Accounting
    2.2.11     Enhancement Projects (User Exits)
    Convention: Z<XX><nn>.
    Notes:
    1.     XX is the application area code e.g. for sales it is SD etc.
    2.     'nn'  is one up number for one application area. It starts with 001.
    3.     Maximum length of the Project name is 8.
    Example:  The name of the SD enhancement project can be ZSD001.
    2.2.12     LSMW Objects
    2.2.12.1     Project
    Naming Convention: ZM_<ffff>.
    Notes:
    1.     1.     Replace <ffff> with meaningful text
    2.     The maximum permissible length for Project name is 16 characters. But please limit it to 12.
    Example : ZM_VENDOR
    2.2.12.2     SubProject
    Naming Convention: ZM_<ffff>_<n>.
    Notes:
         Suffix Project name with a running sequence no.
    Example : ZM_VENDOR_1
    2.2.12.3     Object
    Naming Convention: ZM_<ffff>_<n><n>.
    Notes:
         Suffix Subproject name with a running sequence no.
    Example : ZM_VENDOR_11
    2.2.13     Classes
    Naming Convention: ZCL_[IM/DF/BSPCO/BSPHN/BADI]_<ffff>.
    1.     IM: Implementation Class;
    DF: Definition Class
    BSPCO: BSP Controller class
    BSPHN: BSP Handler class
    BADI : BADI implementation
    2.     Replace <ffff> with meaningful text: In case of Implementation classes, it should preferably be the same as that of the Definition Class
    3.     Example:
    IMPLEMENTATION Class: ZCL_IM_REBATE_SETTL
    DEFINITION: ZCL_DF_REBATE_SETTL
    2.2.14     BOR Object Types
    Object     Convention     Example
    Supertype     Z<ffff>     ZLVAPPL
    SubType     Z<SuperType><nn>     ZZLVAPPL01
    Program     <Subtype>     ZZLVAPPL01
    1.     Replace <nn> with a running 2 digit serial Number
    2.     Replace <ffff> with meaningful text
    2.2.15     Screen / Transaction Variants
    Naming Convention: <tcode>_<ffff>
    Where:
    1.     Replace <tcode> with the t-code that will be assigned to this Variant
    2.     Replace ffff with a meaningful text
    E.g.:
    For an SE16 variant for table KONA that will be used by T-Code Z_CH_SD_001:
    Z_CH_SD_001_KONA
    2.2.16     Area Menu
    Naming Convention: Z<mm>_<Main Menu>_<Sub Menu>…<ffff>
    Where:
    1.     Replace <mm> with the Module code
    2.     Followed by the hierarchical position of the immediate parent of this Area Menu
    3.     Followed by a Meaningful text for this Menu
    E.g.:
    ZSD
    ZSD_TAB
    ZSD_TAB_VIEW
    ZSD_TAB_UPDT
    Notes:
    1.     Clusters of Transactions should be introduced as Sub-Menus rather than as Folders
    2.     As a gradual process, the current Clusters that exist as Folders should also be replaced with Sub-Menus
    2.3     Naming of Sub-Objects
    2.3.1     Program Sub-Objects
    Naming of all the internal components of a program will be consistent across the project.
    Naming Convention: <Prefix>ffff.
    Notes:
    1.     Replace <Prefix> with the component prefix values given in the table below.
    Program Component     Prefixed by
    Program Constants     C_
    Global Variables     W_
    Types Definition     T_
    Global Structures     WA_
    Global Internal Tables     I_
    Select-Options     SO_
    Parameters     PO_
    Table Type     TT_
    Field Symbols     FS_
    Ranges     R_
    Local Constants     LC_
    Local Variables     L_
    Local Static Variables     LS_
    Local Internal Tables     LI_
    Local Work Area     LWA_
    Local Range     LR_
    Field Groups     FG_
    Container      CO_
    Macro     MA_
    Important: The Same sequence as above must be followed in the Data declaration part of all the ABAP/4 programs.
    2.3.2     SAP Script /Smartform sub-objects
    Naming of all the internal components of a SAPScript/SmartForm shall follow the same convention as for Programs (2.2.2), with the addition of the Field Label on the FRS. E.g. if the FRS has labeled a field for Sales Order Number as Field 27 on the Layout, the variable name should be W_27_VBELN.
    3.     General Programming Guidelines
    3.1     Modification Logs
    At the top of every ABAP Object Modified by a Developer, there should be a Modification Log Every Line Created/Changed by the developer should be Identifiable by the TR Number.
    ABAP Patterns: Following Patterns should be used for Uniform ModLogs:
    Nature of Change     Pattern to Use
    New Development     ZZNEWPROG
    In-Line Logs     ZZLINE
    Modification Logs at the Top of Object     ZZMODLOG
    3.2     Program Organization
    All the programs will be organized as described below.
    3.2.1     Executable Programs
    TOP Include: For global data declarations
    Form Include: For definition of all the FORMs.
    3.2.2     Dialog Programs
    TOP Include: For global data declarations
    Form Include: For definition of all the FORMs.
    PBO Include: Include for PBO Modules
    PAI Include: Include for PAI Modules
    3.3     Package
    All the related objects within a sub-module of SAP will be developed under a single Package.
    3.3.1     Adding Components to existing objects
    When adding new workbench components to existing Objects, the same Package will be used as has been used for the existing Components
    3.3.2     Creation of New Objects
    When creating new Objects or new Sub-lanscapes, Packages used should have the Naming convention as in Section 2 Above
    3.4     Program Messages
    All the messages within a sub-module of SAP will be grouped under a single Message Class.
    3.4.1     Adding Messages to existing landscapes
    When adding new messages for existing Objects, the same Message Class will be used as has been used for the existing Objects
    3.4.2     Creation of New Objects
    When creating new Objects or new Sub-landscapes, Message classes used should have the Naming convention as in Section 2 Above
    3.5     Dictionary Objects
    Whenever you create a Z table in  system always include MANDT field as the first field, except when the table contains client independent data. Also create the table with attribute Data Class as USER.
    4.     Structure of ABAP Programs
    4.1     Type
    •     When an ABAP program is run, its processing blocks are called. ABAP programs are controlled from outside the program itself by the processors in the current work process. For the purposes of program flow, we can summarize the screen processor and ABAP processor into the ABAP runtime environment. The runtime environment controls screens and ABAP processing blocks. It contains a range of special control patterns that call screens and processing blocks in certain orders. These sections are also called processors. When a ABAP program is run, the control passes between various processors.
    •     In the R/3 System, there are various types of ABAP program. The program type determines the basic technical attributes of the program, and must be set when created. The main difference between the different program types is the way in which the runtime environment calls its processing blocks.
    •     When an application program is run, it must at least call the first processing block from outside the program, that is, from the runtime environment. This processing block can then either call further processing blocks or return control to the runtime environment. When an ABAP program is started, the runtime environment starts a processor (dependent on the program type), which calls the first ABAP processing block.
    •     The following program types are relevant to application programming:
    Type 1
    •     Type 1 programs have the important characteristic that they do not have to be controlled using user-defined screens. Instead, they are controlled by the runtime environment, which calls a series of processing blocks (and selection screens and lists where necessary) in a fixed sequence. User actions on screens can then trigger further processing blocks.
    Type M
    •     The most important technical attribute of a type M program is that it can only be controlled using screen flow logic and run via a transaction code which is linked to the program and one of its screens (initial screen).
    •     ABAP programs with type M contain the dialog modules belonging to the various screens. They are therefore known as module pools.
    Type F
    •     Type F programs are containers for function modules, and cannot be started using a transaction code or by entering their name directly.
    •     Type F programs are known as function groups. Function modules may only be programmed in function groups. The Function Builder is a tool in the ABAP Workbench that is used to create function groups and function modules. Apart from function modules, function groups can contain global data declarations and subroutines. These are visible to all function modules in the group. They can also contain event blocks for screens in function modules.
    Type K
    •     Type K programs are containers for global classes in ABAP Objects. Type K programs are known as class definitions. The Class Builder is a tool in the ABAP Workbench that can be used to create class definitions.     
    Type J
    •     Type J programs are containers for global interface in ABAP Objects. Type J programs are known as interface definitions and are created in the Class Builder.
    Type I
    •     Type I programs - called includes - are a means of dividing up program code into smaller, more manageable units. The coding of an include program can be inserted at any point in another ABAP program using the INCLUDE statement. There is no technical relationship between include programs and processing blocks. Includes are more suitable for logical programming units, such as data declarations, or sets of similar processing blocks. The ABAP Workbench has a mechanism for automatically dividing up module pools and function groups into include programs.
    4.2     Status
    P = SAP standard production program
    K = Customer production program
    S = System program
    T = Test program
    Application
    •     Categorize the program according to the purpose it fulfills.
    4.3     Authority Check
    Authority checks will be carried out as given in the respective FRS’s.
    4.4     Program Structure
    ABAP programs are responsible for data processing within the individual dialog steps (ie. events) of an application program. This means that the program cannot be constructed as a single sequential unit, but must be divided into sections that can be assigned to the individual dialog steps. To meet this requirement, ABAP programs should have a modular structure. Each module is called a processing block. A processing block consists of a set of ABAP statements. When a program is run, effectively a series of processing blocks is called. Therefore, they should not be nested but modularized.
    •     Each ABAP program consists of the following two parts:
    4.4.1     Declaration data for global data, classes and selection screens
    •     The first part of an ABAP program is the declaration part for global data, classes, and selection screens. This consists of:
    •     All declaration statements for global data. Global data is visible in all internal  processing   blocks and should be defined using declarative statements that appear before the first processing block, in dialog modules, or in event blocks. Local data should not be declared in dialog modules or event blocks.
    •     All selection screen definitions.
    •     All local class definitions (CLASS DEFINITION statement). Local classes are part of ABAP Objects, the object-oriented extension of ABAP.
    •     Declaration statements which occur in procedures (methods, subroutines, function modules) form the declaration part for local data in those processing blocks. This data is only visible within the procedure in which it is declared.
    4.4.2     Container for Processing Blocks
    •     The second part of an ABAP program contains all of the processing blocks for the program. The following types of processing blocks are allowed:
    1.     Dialog modules (no local data area)
    2.     Event blocks (no local data area)
    3.     Procedures (methods, subroutines and function modules with their own local data area).
    •     Whereas dialog modules and procedures are enclosed in the ABAP keywords which define them, event blocks are introduced with event keywords and concluded implicitly by the beginning of the next processing block.
    •     All ABAP statements (except declarative statements in the declaration part of the program) are part of a processing block. Non-declarative ABAP statements, which occur between the declaration of global data and a processing block are automatically assigned to the START-OF-SELECTION processing block.
    4.4.3     Calling Processing Blocks
    •     Processing blocks can be called from either the ABAP program or using ABAP commands which are themselves part of a processing block. Dialog modules and event blocks are called from outside the ABAP program. Procedures are called using ABAP statements in ABAP programs.
    •     Calling event blocks is different from calling other processing blocks for the following reasons:
    •     An event block call is triggered by an event. User actions on selection screens and lists, and the runtime environment trigger events that can be processed in ABAP programs. Define event blocks for the events that the program needs to react to (whereas a subroutine call, for example, must have a corresponding subroutine). This ensures that while an ABAP program may react to a particular event, it is not forced to do so.
    4.5     Screen Flow Logic (Dialog Programs)
    4.5.1     Place the AT EXIT COMMAND at the beginning of the flow logic.
    Example:
    PROCESS AFTER INPUT
       MODULE EXIT_1170 AT EXIT-COMMAND.
       MODULE PAINT_1170.
    4.5.2     Use FIELD and CHAIN statements to keep fields in error open for correction.
    Example:
       PROCESS AFTER INPUT.
       MODULE EXIT_1170 AT EXIT-COMMAND.
       CHAIN.
          FIELD BTCH1170-JOBNAME.
          FIELD BTCH1170-USERNAME.
          FIELD BTCH1170-FROM_DATE.
          FIELD BTCH1170-FROM_TIME.
          MODULE PAINT_1170.
       ENDCHAIN.
    4.6     Main Program
    4.6.1     Events
    The Program MUST NOT be coded without the use of Proper Coding blocks
    •     Initializations
    •     Top-of-page during line-selection
    •     At Selection-Screen
    •     At Line-Selection
    •     At User-Command
    •     At Pfn
    •     Start-Of-Selection
    •     Top-Of-Page
    •     Get
    •     End-Of-Page
    •     End-Of-Selection
    NOTE: The coding for each event should be logically split into forms (subroutines). That is to say, each event will comprise mostly of ‘PERFORM’ statements.
    5.     General Coding Standards
    5.1     One command per line
    Each ABAP/4 command consists of a sentence ending with a period. Multiple commands can be on one line; however, as a standard start each new command on a new line. This will allow for easier deleting, commenting, and debugging.
    5.2     Indented Source Code
    The ABAP/4 editor has a "Pretty Printer" command to indent by 2 positions specific lines of code and add subroutine comments. Event keywords are typically not indented.
    5.3     Extended Syntax Check
    Extended Program Check (EPC) to be done on each object to make sure the code is Syntactically correct. There should be no Error/warning messages in the code.
    5.4     Reusability and Modularity
    If a block of code is executed more than once, it should be placed in a subroutine at the bottom of the code. This makes the code more readable, requires less indentation, and is easier to debug since the debugger can jump through an entire subroutine via a PF key. Also, when possible parameters should be passed to and from subroutines to make the purpose easier to understand and reduce the need for global variables. Always document the purpose of each parameter.
    5.5     Text Handling
    Text elements must be used to display any text messages.
    5.6     Usage of System Variables
    The system variables should be used wherever possible. The SY-SUBRC is to be checked after any function call, selection operation, etc.
    5.7     Chaining Statements
    •     Consecutive sentences with an identical beginning shall be combined into a chained statement.
    Example:
    Instead of the statements
    MOVE SY-MANDT TO D00001-MANDT.
    MOVE SY-LANGU TO D00001-SPRAS.
    A chained statement shall be used
    MOVE:
                 SY-MANDT TO D00001-MANDT,
                 SY-LANGU TO D00001-SPRAS,
                 SY-UNAME TO D00001-BNAME.
    5.8     Common Routines
    •     Standard sub-routines should be implemented as FUNCTION's rather than a FORM (ie. SUBROUTINE). A FUNCTION is easier to maintain and can be easily tested without a calling program. Standard SAP function modules are also available and the function library should be used to check if function modules already exist for a function that needs to be performed i.e.POPUP_TO_CONFIRM_LOSS_OF_DATA etc.
    •     Includes can also be created for re-usable or common code e.g. common data declaration statements.
    5.9     Dialog Messages
    Dialogue messages are stored in table T100. Programmers shall check to see if an appropriate message exists before adding a new message. Programs shall use the message-id which corresponds to the SAP module that the program most relates to.
    5.10     Function Keys
    PF-keys should be programmed to execute functions where required. SAP Standard function keys should be used where appropriate. The most commonly used buttons should be displayed as pushbuttons in the application toolbar.
    5.11     Enqueuing and Dequeuing Data Objects
    •     All database objects being processed by a program, for purposes other than for display, shall be enqueued before such processing is executed. If the enqueue is unsuccessful, then a message shall be returned stating why the enqueue was unsuccessful.
    •     Enqueue and Dequeue objects should be created via the data dictionary.
    5.12     Error Handling (SY-SUBRC)
    •     Return codes shall always be checked immediately after an event which returns a code.  
    Eg. Function calls, Select statements, Updates etc.
    •     The value of SY-SUBRC is 0 when successful and generally produces a value of 4 when unsuccessful (there are a few exceptions).
    Therefore, rather check SY-SUBRC with:
               IF SY-SUBRC <> 0
    than with
             IF SY-SUBRC = 4  (which is redundant and makes the system do a double check)
    •     Error messages displayed to the user must be clear and descriptive.
    •     Remember to group related / dependant steps together and to Rollback all changes for steps in that group should any one of them fail, thus maintaining the integrity of the system.
    •     Check whether an Error Log, (file), must be produced by your program and if so check on the format of the file.
    •     If any Error Logging is done to a custom table in the database then make sure this table is maintained and monitored correctly. (Dev. Note)
    •     Transaction SE91 provides the facility to create and utilize messages in their appropriate message class. Elaborate on the message if necessary, using the long text documentation for that message number.
    5.13     General Conventions and Hints
    •     There should be NO hard coding of values in programs – easy maintainability
    •     For amounts, use the CURRENCY command in write statements to automatically convert fields into their correct decimal format. The currency specified in the write statement is treated as a key for the table TCURX. If no entry exists for the currency specified, the system assumes two decimal places.
    •     For quantities, use the UNIT command in write statements to automatically convert fields into their correct decimal format. The contents of the unit specified are used on table T006. If no entry exists for the unit specified, the formatting has no effect.
    •     Use the ‘LIKE’ statement as often as possible to declare ‘DATA’ variables instead of an explicit ‘TYPE’ declarations.
    •     Try to use the ‘INCLUDE’ statement with standard SAP structures and tables for your structures and internal tables where possible.  If you use the include statement to include other program components in your code then document what those components are, what they do and how to use them.
    •     Try to make use of standard SAP Function Modules wherever possible rather than building your own. Use the pull down functionality in transaction SE37 to find suitable standard function modules.
    •     Make use of the SAP PATTERN tool to automatically insert the standard code for:
    •     CALL FUNCTION
    •     MESSAGE ID
    •     SELECT*FROM
    •     PERFORM
    •     AUTHORITY-CHECK
    •     WRITE
    •     CASE
    •     CALL DIALOG
    •     The standard date format to use is ‘DD/MM/YYYY’. (Dev. Note)
    The standard time format to use is ‘HH:MM:SS’.
    5.14     Parameters in Sub-Routines
    Naming convention for Parameters in subroutine is P_
    6.     Performance Standards
    6.1     General Tips on Performance Tuning
    6.1.1     Avoid Redundant code
    Avoid leaving "dead" code in the program. Comment out variables that are not referenced and code that is not executed. To analyze the program, use the Program Analysis function in SE38 -> Utilities -> Program Analysis.
    6.1.2     Subroutine Usage
    For good modularization, the decision of whether or not to execute a subroutine should be made before the subroutine is called.
    Example:
    IF f1 NE 0.
      PERFORM sub1.
    ENDIF.
    FORM sub1.
    ENDFORM.
    6.1.3     Case vs. Nested IF
    When testing fields "equal to" something, one can use either the nested IF or the CASE statement. The CASE is better for two reasons. It is easier to read and after about five nested IFs the performance of the CASE is more efficient.
    6.1.4     Using the MOVE Statement
    When records a and b have the exact same structure, it is more efficient to MOVE a TO b than to MOVE-CORRESPONDING a TO b.
    6.1.5     SELECT Queries
    The performance of  any ABAP program mainly depends on the ABAP Queries used in it. More optimum the queries , better the performance. Take care of the points mentioned nin the following sections while writing any ABAP queries.
    6.1.5.1     Using all the keys in SELECT statement
    When using the SELECT statement, study the key and always provide as much of the left-most part of the key as possible. The SELECT * command is to be avoided everywhere.
    6.1.5.2     Fetching Single Record
    If the entire key can be qualified, code a SELECT SINGLE not just a SELECT. If all the keys are not available, we should use SELECT UPTO 1 ROWS if we are interested only in the first record.
    6.1.5.3     Avoid SELECT-ENDSELECT
    Selecting data into an internal table using an array fetch versus a SELECT-ENDELECT loop will give at least a 2x performance improvement.  After the data has been put into the internal data, then row-level processing can be done.  
    Example:
    select ... from table <..>
               into <itab>
               where ...
    loop at <itab>
      <do the row-level processing here>
    endloop.
    6.1.5.4     Using Indexs
    Use indexes wherever possible. Tune the Query so that optimum Indexing will happen.
    6.1.5.5     Provide all the keys
    Give as many keys as possible in the WHERE clause to optimize the database fetching. Use the Index fields in the first position to optimize performance.
    6.1.5.6     Avoid “INTO CORRESPONDING”
    Avoid using INTO CORESPONDING FIELDS of Table. Instead, explicitly mention the fields. Else, The Table Fields should be in the same sequence as the selection
    6.1.5.7     SELECT statement inside LOOP
    Do not write SELECT statements inside the loop. Instead, use the FOR ALL ENTRIES Command
    Before using FOR ALL ENTRIES command, check that the
    1.     Corresponding Internal table is not empty. If the Internal table is empty, the statement will select ALL the entries in the Database
    2.     The Internal table is sorted by the Filed used in the Where Clause: This makes selection faster
    6.1.5.8     Nested SELECT statement
    Avoid Using nested SELECT statements. Instead, make use of different internal tables to fetch the data, and Use Nested LOOPS to read them.
    6.1.5.9     Select Distinct
    Whenever its possible avoid SELECT DISTINCT, instead select data into internal table, sort and use DELETE ADJACENT DUPLICATES
    6.1.5.10     Use of OR in Where Clause
    Do not use OR when selecting data from DB table using an index because The optimizer generally stops if the WHERE condition contains an OR expression.
    e.g.
    Instead of
         SELECT * FROM spfli WHERE carrid = ‘LH’
                                   AND (cityfrom = ‘FRANKFURT’ OR
                 city from = ‘NEWYORK’)
    Use
         SELECT * FROM spfli WHERE (carrid = ‘LH’ AND cityfrom = ‘FRANKFURT’)
                                      OR (carrid = ‘LH’ AND cityfrom = ‘NEWYORK’).
    6.1.5.11     Order By
    ORDER BY will Bypass buffer. So, performance will decrease. If you want to sort data, it is efficient to SORT them in INTERNAL TABLE rather than using ORDER BY. Only use an ORDER BY in your SELECT if the order matches the index, which should be used.
    6.1.6     Using the READ statement
    When reading a single record in an internal table, the READ TABLE WITH KEY is not a direct READ. The table needs to be sorted by the Key fields and the command READ TABLE WITH KEY BINARY SEARCH is to be used.
    6.1.7     Hashed table
    If the number of entries in the Internal Table is high then use Hashed Table with Keys to access the table.
    6.1.8     Transporting
    With READ or MODIFY Statements use TRANSPORTING
    6.1.9     Using LDB
    In order to improve performance in case of an LDB, individual tables can be excluded from selection. Under the section ‘Table Selection’ in the Documentation of LDB the fields with proper description has been given those fields can be set in the application report at the time of INITIALIZATION or at the START OF SELECTION. This can enhance the performance.
    6.1.10     Append Lines of
    Whenever it is possible use APPEND LINES OF to append the internal Tables instead of using loop and then APPEND Statement.
    6.1.11     Use WHILE
    Use WHILE instead of a DO+EXIT-construction, as WHILE is easier to understand and faster to execute
    6.1.12     DELETE <itab> WHERE
    Use DELETE <itab> WHERE…for deleting records from an internal table.
    e.g.
    Instead of
    LOOP AT <itab> WHERE <field> = ‘0001’
         DELETE <itab>.
    ENDLOOP.
    Use
    DELETE <itab>  WHERE <field> = ‘0001’.
    6.1.13     Using WHERE clause in LOOP…….ENDLOOP
    Use:
    Sort ITAB by NAME.
    Loop at itab where name EQ SY-UNAME
    Endloop.
    Instead Of:
    Read itab with key name = SY-UNAME.
    L_tabix = sy-tabix.
    Loop at itab from l_tabix.
    If name eq ‘bijoy’
    Endif.
    Endloop.

  • SAPMV45A standard screens

    Hi Guys,
    Can anyone check this in ecc6 if all these screens numbers are present for SAPMV45A .
    May screens are missing in comparison to 4.5B just want to know if this is a data loss or std new setup.
    Specifically one between the stars.
    0101 Sales doc.   
                 0102 Sales Document   
                 0103 Sales document     
                 0104 Sales doc.         
                 0105 Scheduling agrmt   
                 0125 Scheduling agrmt   
                 0126 Item proposals     
               0130 Sales Document     
              0150 Sales doc.         
              0151 Sales Document     
              0213 Sales Document     
             0250 Sales doc.         
             0251 Sales doc.         
            0252 Sales doc.         
            0253 Sales doc.         
            0254 Sales doc.         
            0255 Sales doc.         
            0256 Sales doc.         
            0257 Sales doc.         
            0258 Status change dialog
            0259 Sales doc.         
            0300 Sales document       
            *0301 Header - Business data*
           *0302 Sales doc.*
           *0303 Sales Document*
           *0304 Sales doc.*
          *0305 Sales document*       
          0306 Item proposal        
          0307 Sales doc.           
          0308 Independent reqs     
          0309 Sales doc.           
           0311 reserved for doc hdr-s
          0312 reserved for header su
          0351 Sales doc.           
         *0400 Order   (double-line o*
         *0401 Order*
         *0402 Auftrag*
         *0403 Sales Document*
         *0404 Sales Document*
        *0405 Sales Document*       
        0406 Sched.Agree./Contract
      0407 Sched.Agreement      
      0408 Sched.Agree./Contract
      0409 Sales Document       
      0410 Sales Document       
      0411 Inq./Quotation       
      0412 Item proposal        
      0413 Sales doc.           
      0414 Credit Memo Request -
      0415 Credit Memo Request: D
      0416 Sales Document       
      0417 Returns              
      0418 Quantity Contract    
      0419 Sales Document       
      0420 Contract             
      0421 Customer reqmnts     
      0422 Order                
      0423 MAIS overview (double-
      0424 MAIS overview (single-
      0425 Component supplier sch
      0426 Contract             
      0427 Contract             
      0428 Master contract      
      0429 MAIS - Incompletion  
      0430 Product proposal modul
      0431 Value contract       
      0432 Value contract       
      0450 Order                
      0451 Item     - Business da
      0452 Sales Document       
      0453 Sales Document       
      0454 Sales Document       
      0455 Cred.Memo /Sched.Agree
      0456 Sales document       
      0457 Sales Document       
      0458 reserved for item-subs
      0459 Sales Document       
      0460 Sales Document       
      0461 Sales Document       
      0462 reserved for item-subs
      0470 Assortment for transfe
      0471 Matl entry:Transfer fr
      0472 Assortment for Transfe
      0500 Sales doc.           
      0551 Sales doc.           
      0552 Sales doc.           
      0553 Verkaufsbeleg        
      0554 Sales doc.           
      0600 Forecast Dlv. Sched. D
      0601 JIT delivery schedule
      0602 Schedule Line: SA Rele
      0603 Sched.Agreement: Eng.
      0604 Sched.Agreement: Eng.
      0651 Export               
      0700 Sales document: Empty
    Thanks in advance
    Ritika
    Edited by: ritika red on May 19, 2010 3:33 PM

    >
    ritika red wrote:
    > I have followed the instructions in that thread and felt this is worth asking the question in detail.
    > As  only one screen is not missing there are many as i dont have another ECC6  sys access at this moment.
    > 
    > That is the reason i have listed all the screen numbers.
    >
    > It will be of gr8 help for my project to find the correct solution  if i can confirm this detail information.
    >
    >
    >
    > Thanks
    > Ritika
    Are you saying that ALL the screens you mentioned above, are missing? You are in trouble, then and should open a call with SAP.
    Just to put your poor soul to rest, here's all the SAP-standard  screens for SAPMV45A in an ECC 6.0:
    101
    102
    103
    104
    105
    125
    126
    130
    151
    213
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    304
    306
    308
    311
    312
    412
    421
    427
    430
    456
    457
    458
    460
    461
    462
    470
    471
    472
    500
    554
    700
    800
    810
    823
    824
    850
    900
    903
    910
    911
    913
    923
    924
    Want me to post the sub-screens also?
    If any/most/all of these are missing after an upgrade in your system: open a call with SAP

  • How to edit the attributes of a SAP standard screen?

    hello all,
    i would like to ask if it is possible to edit the attributes (particularly the language) of a SAP standard screen without using any access key? if yes, how would i be able to apply the changes?
    thanks!
    - annalyn

    Hi,
    Screen attributes are stored in table D020S. You can update this table using ABAP code. The language is stored in field SPRA of this table. The texts appearing on the screen are in D020T.
    It is likely you will not be allowed aa data modification statement (INSERT/UPDATE...) on these tables if you are on newer versions of SAP (46/47...). You can bypass that by using native SQL and some other workaround (which might be another thread here).
    It is most strongly recommended to not modify SAP standard objects, and specially not without an object key. However, if you are working on something like a miniSAP and want to play around with it, the method mentioned above shall do.
    Hope this helps,
    cheers,
    Ajay

  • 4:3 aspect ratio (standard screen) apple tv compatibility issues

    Hi folks,
    I'm hoping somebody can help me out. After reading through the forms I already
    know the bad news that Apple TV doesn't support 4:3 standard screen aspect ratio. Unfortunately, this is the type of TV that I have with no abilities to change it. Does anybody om this form know of a work around to this issue? My TV is not a HDTV but has the proper video (blue,green) inputs. I'm currently in the process of purchasing a new advanced AV home entertainment receiver that's able to support all types of video inputs so here's my question. Does anybody know of a AV receiver, or do they make an AV receiver that could recognize the Apple TV's 16:9 wide screen aspect ratio and convert it to 4:3? I have a $40.00
    digital converter box that does this so I'm thinking there's got to be an AV receiver that perhaps can do this.
    Bob

    Welcome. Will just add again, it is more up to the TV being able to deal with it. But as mentioned, if the TV has the component (or is it composite, I always forget ... why oh why did they name them so close) jacks, I would say there is a very high chance it will work just fine. Believe the setting in the AppleTV at setup would be 480i (or 480p)...one of those. If you pick the wrong one, it will figure it out and restart to let you choose the other.
    The movies I play all play fine. I will admit I get many from BitTorrent and convert them to MP4 and haven't had any issues. And those I rent/buy from iTunes all play well.
    The only place that is really a pain is the browsing of movies in the iTunes store from the AppleTV when viewing on a 4:3 TV. It all gets scrunched so reading the words below the images of the movie is a bit difficult, but not impossible. That is really the only place I wish worked better, but do understand they never meant for it to play on a 4:3 set (even if that set allows it).

  • Standard screen

    Hi all,
    Can i call a standard screen ( e.g. SE38 initial screen) using subscreen.
    Thanks & Regards
    Santhosh

    santosh,
    REPORT demo_dynpro_subscreens.
    DATA: ok_code TYPE sy-ucomm,
          save_ok TYPE sy-ucomm.
    DATA: number1(4) TYPE n VALUE '0110',
          number2(4) TYPE n VALUE '0130',
          field(10) TYPE c, field1(10) TYPE c, field2(10) TYPE c.
    CALL SCREEN 100.
    MODULE status_100 OUTPUT.
      SET PF-STATUS 'SCREEN_100'.
    ENDMODULE.
    MODULE fill_0110 OUTPUT.
      field = 'Eingabe 1'(001).
    ENDMODULE.
    MODULE fill_0120 OUTPUT.
      field = field1.
    ENDMODULE.
    MODULE fill_0130 OUTPUT.
      field = 'Eingabe 2'(002).
    ENDMODULE.
    MODULE fill_0140 OUTPUT.
      field = field2.
    ENDMODULE.
    MODULE cancel INPUT.
      LEAVE PROGRAM.
    ENDMODULE.
    MODULE save_ok INPUT.
      save_ok = ok_code.
      CLEAR ok_code.
    ENDMODULE.
    MODULE user_command_0110 INPUT.
      IF save_ok = 'OK1'.
        number1 = '0120'.
        field1 = field.
        CLEAR field.
      ENDIF.
    ENDMODULE.
    MODULE user_command_0130 INPUT.
      IF save_ok = 'OK2'.
        number2 = '0140'.
        field2 = field.
        CLEAR field.
      ENDIF.
    ENDMODULE.
    MODULE user_command_100 INPUT.
      CASE save_ok.
        WHEN 'SUB1'.
          number1 = '0110'.
        WHEN 'SUB2'.
          number1 = '0120'.
          CLEAR field1.
        WHEN 'SUB3'.
          number2 = '0130'.
        WHEN 'SUB4'.
          number2 = '0140'.
          CLEAR field2.
      ENDCASE.
    ENDMODULE.
    The next screen number of screen 100 is 100 (statically-defined). Its layout is as follows:
    There are four pushbuttons with the function codes SUB1 to SUB4, and two subscreen areas AREA1 and AREA2.
    In the same ABAP program, there are four subscreen screens 110 to 140. Each of these fits the subscreen area exactly. The layout is:
    The input/output field of all four subscreen screens has the name FIELD. The function codes of the pushbuttons on the subscreen screens 110 and 130 are OK1 and OK2.
    The screen flow logic for screen 100 is as follows:
    PROCESS BEFORE OUTPUT.
      MODULE status_100.
      CALL SUBSCREEN: area1 INCLUDING sy-repid number1,
                      area2 INCLUDING sy-repid number2.
    PROCESS AFTER INPUT.
      MODULE cancel AT EXIT-COMMAND.
      MODULE save_ok.
      CALL SUBSCREEN: area1,
                      area2.
      MODULE user_command_100.
    The screen flow logic of subscreen screens 110 and 130 is:
    PROCESS BEFORE OUTPUT.
      MODULE fill_0110|0130.
    PROCESS AFTER INPUT.
      MODULE user_command_0110|0130.
    The screen flow logic of subscreen screens 120 and 140 is:
    PROCESS BEFORE OUTPUT.
      MODULE fill_0120|0150.
    PROCESS AFTER INPUT.
    When you run the program, a screen appears on which subscreens 110 and 130 are displayed. The pushbuttons on the main screen allow you to choose between two subscreen screens for each screen area. The pushbuttons on the subscreens allow you to transfer the data from subscreens 110 and 130 to subscreens 120 and 140.
    Since the same field name FIELD is used on all subscreens, the identically-named ABAP field is transferred more than once in each PBO and PAI event of the main screen. For this reason, the values have to be stored in the auxiliary fields FIELD1 and FIELD2 in the ABAP program.
    The pushbuttons on the subscreen screens have different function codes, and they are handled normally in an ABAP field. If the function codes had had the same names, it would again have been necessary to use auxiliary fields.
    Note : With just change in this code you can achieve your goal.Use call screen where you want .
    don't forget to reward if useful.

  • How to deactivate the fields in a table control of a standard screen

    Hi,
       I have an requirement to deactivate the fields in a table control of a standard screen in ME22n transaction.I am using a BADI "ME_PROCESS_PO" and in item mathod i am looping at screen for the screen field name in the table control.But it is not working. Can anyone give me the possible solution . Thanx in advance.
    With Regards,
    Ajit.

    >
    Vivek Joshi wrote:
    > Hello Router ,
    >                      I do not want to set the focus , I want to get focus . User can click on any cell in the table and then press a button in the toolbar . Now in the event handler of the button i want to under which column User has set the focus .
    > I hope , I am clear now .
    > Thanks for your help
    > Regards
    > Vivek
    An yet you keep getting suggestions of how to set the focus.   I looked through the API documentation and I don't see anything that would suggest you can request to see where the current focus is.  Perhaps someone might still come along with a solution, but my hopes wouldn't be too high at this point.  I can pass the requirement onto Product Definition, as the use case does seem interesting.  Perhaps it is something we have even considered in the past. 
    But for now, there might be a better way to solve your problem.  It will probably mean redesign the interaction.  What exactly are your requirements?  Do you need to be able to get the data in a particular cell of table when a button is clicked?  Just throwing out some ideas here, but maybe just use the lead selection to select the row, but then have a button choice to choose the action associated with the column you want. A hack for sure - but it might work.  Also it doesn't help you right now, but in the near future update to NetWeaver 7.0, WDA does have a onColSelect event for the table.

  • Standard screen changes-addition of a field in vendor master table

    Hi Champs,
    My requirement is to add a field in LFB1 table.
    I have added the field in the table using append structure, that was fine.
    I need to add the same for input/output on the screen 215 of program SAPMF02K (for the screen of Payment transaction Accounting at company code level).
    The screen enhancement available for vendor master is for adding a new sub screen. But I need my field to be input/output on screen 215 of program SAPMF02K (for the screen of Payment transaction Accounting at company code level).
    The only option left with me was to make changes in the Standard SAP screen as there are no enhancements available to suffice my requirement.
    After taking the access key, if suppose i make changes in the standard screen viz. given a dictionary refrence to the new field created on screen 215. My query is do i need  to do any kind of coding in PBO or PAI of the screen.
    A quick reply would be overwhelming.
    Thanks
    Regards,
    Nishant

    Ofcouse Nishanth, u need to code in PBO and PAI event.
    PAI   -> To read the User input and for doing validations or some thing as per ur requirement
    Hope this helps,
    Shiva kankanala

  • Need some help in creating Search Help for standard screen/field

    I need some help in adding a search-help to a standard screen-field.
    Transaction Code - PP01,
    Plan Version - Current Plan (PLVAR = '01'),
    Object Type - Position ( OTYPE = 'S'),
    Click on Infotype Name - Object ( Infotype 1000) and Create.
    I need to add search help to fields Object Abbr (P1000-SHORT) / Object Name (P1000-STEXT).
    I want to create one custom table with fields, Position Abb, Position Name, Job. Position Abb should be Primary Key. And when object type is Position (S), I should be able to press F4 for Object Abb/Object Name fields and should return Position Abbr and Position Name.
    I specify again, I have to add a new search help to standard screen/field and not to enhance it.
    This is HR specific transaction. If someone has done similar thing with some other transation, please let me know.
    There is no existing search help for these fields. If sm1 ever tried or has an idea how to add new search help to a standard screen/field.
    It's urgent.
    Thanks in advace. Suitable answers will be rewarded

    Hi Pradeep,
    Please have a look into the below site which might be useful
    Enhancing a Standard Search Help
    https://www.sdn.sap.com/irj/sdn/go/portal/prtroot/docs/library/uuid/daeda0d7-0701-0010-8caa-
    edc983384237
    http://help.sap.com/saphelp_nw04/helpdata/en/cf/21ee93446011d189700000e8322d00/frameset.htm
    A search help exit is a function module for making the input help process described by the search help more flexible than possible with the standard version.
    This function module must have the same interface as function module F4IF_SHLP_EXIT_EXAMPLE. The search help exit may also have further optional parameters (in particular any EXPORTING parameters).
    A search help exit is called at certain timepoints in the input help process.
    Note: The source text and long documentation of the above-specified function module (including the long documentation about the parameters) contain information about using search help exits.
    Function modules are provided in the function library for operations that are frequently executed in search help exits. The names of these function modules begin with the prefix F4UT_. These function modules can either be used directly as search help exits or used within other search help exits. You can find precise instructions for use in the long documentation for the corresponding function module.
    During the input help process, a number of timepoints are defined that each define the beginning of an important operation of the input help process.
    If the input help process is defined with a search help having a search help exit, this search help exit is called at each of these timepoints. If required, the search help exit can also influence the process and even determine that the process should be continued at a different timepoint.
    timepoints
    The following timepoints are defined:
    1. SELONE
    Call before selecting an elementary search help. The possible elementary search helps are already in SHLP_TAB. This timepoint can be used in a search help exit of a collective search help to restrict the selection possibilities for the elementary search helps.
    Entries that are deleted from SHLP_TAB in this step are not offered in the elementary search help selection. If there is only one entry remaining in SHLP_TAB, the dialog box for selecting elementary search helps is skipped. You may not change the next timepoint.
    The timepoint is not accessed again if another elementary search help is to be selected during the dialog.
    2. PRESEL1
    After selecting an elementary search help. Table INTERFACE has not yet been copied to table SELOPT at this timepoint in the definition of the search help (type SHLP_DESCR_T). This means that you can still influence the attachment of the search help to the screen here. (Table INTERFACE contains the information about how the search help parameters are related to the screen fields).
    3. PRESEL
    Before sending the dialog box for restricting values. This timepoint is suitable for predefining the value restriction or for completely suppressing or copying the dialog.
    4. SELECT
    Before selecting the values. If you do not want the default selection, you should copy this timepoint with a search help exit. DISP should be set as the next timepoint.
    5. DISP
    Before displaying the hit list. This timepoint is suitable for restricting the values to be displayed, e.g. depending on authorizations.
    6. RETURN (usually as return value for the next timepoint)
    The RETURN timepoint should be returned as the next step if a single hit was selected in a search help exit.
    It can make sense to change the F4 flow at this timepoint if control of the process sequence of the Transaction should depend on the selected value (typical example: setting SET/GET parameters). However, you should note that the process will then depend on whether a value was entered manually or with an input help.
    7. RETTOP
    You only go to this timepoint if the input help is controlled by a collective search help. It directly follows the timepoint RETURN. The search help exit of the collective search help, however, is called at timepoint RETTOP.
    8. EXIT (only for return as next timepoint)
    The EXIT timepoint should be returned as the next step if the user had the opportunity to terminate the dialog within the search help exit.
    9. CREATE
    The CREATE timepoint is only accessed if the user selects the function "Create new values". This function is only available if field CUSTTAB of the control string CALLCONTROL was given a value not equal to SPACE earlier on.
    The name of the (customizing) table to be maintained is normally entered there. The next step returned after CREATE should be SELECT so that the newly entered value can be selected and then displayed.
    10. APP1, APP2, APP3
    If further pushbuttons are introduced in the hit list with function module F4UT_LIST_EXIT, these timepoints are introduced. They are accessed when the user presses the corresponding pushbutton.
    Note: If the F4 help is controlled by a collective search help, the search help exit of the collective search help is called at timepoints SELONE and RETTOP. (RETTOP only if the user selects a value.) At all other timepoints the search help exit of the selected elementary search help is called.
    If the F4 help is controlled by an elementary search help, timepoint RETTOP is not executed. The search help exit of the elementary search help is called at timepoint SELONE (at the
    F4IF_SHLP_EXIT_EXAMPLE
    This module has been created as an example for the interface and design of Search help exits in Search help.
    All the interface parameters defined here are mandatory for a function module to be used as a search help exit, because the calling program does not know which parameters are actually used internally.
    A search help exit is called repeatedly in connection with several
    events during the F4 process. The relevant step of the process is passed on in the CALLCONTROL step. If the module is intended to perform only a few modifications before the step, CALLCONTROL-STEP should remain unchanged.
    However, if the step is performed completely by the module, the following step must be returned in CALLCONTROL-STEP.
    The module must react with an immediate EXIT to all steps that it does not know or does not want to handle.
    Hope this info will help you.
    ***Reward points if found useful
    Regards,
    Naresh

  • How to remove fields from Standard Screen

    Hi,
        I Have faced one problem in screens(se51). When apply one SAP Note i have to change the screen manually(as per Note ) . My requirement is to remove some text fields and label fields. But I cant delete the Fields.
       Normally just select the object and Press delete Key to remove one object from screen. But here it is not working.
      How can i remove the objects from the screen as per SAP Note.
    Thanks in Advance,
    WIth Regards,
    Neptune.M

    Hi,
    T.code SHD0 helps you control which fields to appear, suppress and make mandatory in Standard Screen.
    refer
    https://forums.sdn.sap.com/click.jspa?searchID=4359065&messageID=2961760
    Regards

  • Search Help - Standard Screen Field: ME21n / ME22n

    Helow, experts.
    I have to create a search help in the standard screen field "Our Reference" (UNSEZ) in the tab  Communication to ME21n / ME22n, anyone could say me how can I code it?
    To populate this search help, I have to use 3 different tables.
    Thanks

    hi shatish
    code here in screen flow logic it will fire on F4 pressing.
    PROCESS ON VALUE-REQUEST
    module value_help.
    in program
    module value_help.
    populate the itab.
    CALL FUNCTION 'POPUP_WITH_TABLE'
                    EXPORTING
                      ENDPOS_COL         = <colvaluea>
                      ENDPOS_ROW         = <colvaluea>
                      STARTPOS_COL       = <colvaluea>
                      STARTPOS_ROW       = <colvaluea>
                      TITLETEXT          = 'VALUE HELP'
                  IMPORTING
                    CHOICE             =
                    TABLES
                      VALUETAB           = itab
                  EXCEPTIONS
                    BREAK_OFF          = 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.
    endmodole.
    regards
    shiba dutta

Maybe you are looking for

  • Old expansion pack loops won't show up

    Installing the new Garageband has been nothing but a headache. My main problem if that I can't get loops from older expansion packs to show up. I believe I've located my current new loops library and they're all .caf files while my old ones are .aif

  • All Midi devices Play at same time help in resolving

    Environment: 2 presounus Firepods,Oxygen 61, Yamaha DTX Exployer Drum Trigger, Panasonic SX KC-611 Keyboard, Logic Pro 8, Mac Book Pro, Mac OS X10.58. Question? How to get each midi device to be separate from each other so I can Play and record each

  • Dynamic query to produce crosstab/pivot report

    Hello, I've not been able to find any examples similar to my situation but perhaps I'm using the wrong search phrases... I'm basically trying to create a cross-tab type report based on a dynamic query (since I do not know how many accounts a person h

  • Mac OS X 10.6 snow leopard

    now, when it does come out, should i upgrade to it, i have read that its not a necessity but will only make things faster and better but nothing new really...is this true? if not can you just tell me what exactly its going to do differently. i know t

  • Dumb Question: Is there a way to snap to grids in Adobe line?

    While I'm able to snap to bumpers of objects drawn, this behavior doesn't appear to translate to grids. Is there an additional setting that has to be turned on in order to snap to grids on the canvas? I'm sorry if this is a dumb question, and thanks