Place symbols in ABAP Program Documenatation

Hi All,
I am preparing the documentation for ABAP Program.
From Main menu GOTO-->Dcouemnataion.
I want to place the symbol 'Empty circle'.
I am creating using Insert-->SAp symbols.But for evry symbol it is showing Square box.
What would be the pblm.How can i place empty circle in the documenatation.
Thanks,

i have solved my self the pblm.For you information that SYM_CIRCLE is not working it is taking the symbol as Square box.
Swapna.

Similar Messages

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

  • Reading Webservice information from ABAP Program

    Hi All,
    How to read a webservice information from a ABAP program ?
    Are there any webservices available in ABAP which can do this .
    Gopal.

    Hi,
    The following code will call the web service and fill the data into internal table which was received from the Web service. This code will send & Receive the data from ABAP to Webservice.
    Change the Header detail as per your Webservice.
    REPORT  ZWORKORDER.
    TYPES: BEGIN OF OUTTAB1 ,
      JOBCODE(20),
      COMPONENTCODE(20),
      ACCURATEHOURS(20),
      ACCURATECOST(20),
      LENGTH TYPE I,
       END OF OUTTAB1 .
    DATA: OUTTAB TYPE  TABLE OF OUTTAB1.
    DATA: TAB TYPE OUTTAB1.
    DATA: WF_O LIKE LINE OF OUTTAB .
    DATA: XSLT_ERR TYPE REF TO CX_XSLT_EXCEPTION .
    DATA: RLENGTH TYPE I,
          TXLEN TYPE STRING  .
    DATA: HTTP_CLIENT TYPE REF TO IF_HTTP_CLIENT .
    DATA: WF_STRING TYPE STRING .
    DATA: WF_STRING1 TYPE STRING .
    DATA: WF_PROXY TYPE STRING ,
          WF_PORT TYPE STRING .
    CLEAR WF_STRING .
    Form the input string to send the Input Data to Web service.
    CONCATENATE
    '<?xml version="1.0" encoding="utf-8"?>'
    '<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">'
    '  <soap:Body>'
    '    <GetWorkOrder xmlns="http://*******erica.net/webservices/">'
    '      <nWorkOrder>2</nWorkOrder>'
    '      <nDistributorCode>4871</nDistributorCode>'
    '      <model>HM400</model>'
    '     <type>1 </type>'
    '    </GetWorkOrder>'
    '  </soap:Body>'
    '</soap:Envelope>'
    INTO WF_STRING .
    CLEAR :RLENGTH , TXLEN .
    RLENGTH = STRLEN( WF_STRING ) .
    MOVE: RLENGTH TO TXLEN .
    CLEAR: WF_PROXY, WF_PORT .
    CALL METHOD CL_HTTP_CLIENT=>CREATE
      EXPORTING
        HOST    = '192.168.1.41' "'http://****merica.net/webservices'
        SERVICE = '8080'
        SCHEME  = '1'
      IMPORTING
        CLIENT  = HTTP_CLIENT.
    HTTP_CLIENT->PROPERTYTYPE_LOGON_POPUP = HTTP_CLIENT->CO_DISABLED.
    CALL METHOD HTTP_CLIENT->REQUEST->SET_HEADER_FIELD
      EXPORTING
        NAME  = '~request_method'
        VALUE = 'POST'.
    CALL METHOD HTTP_CLIENT->REQUEST->SET_HEADER_FIELD
      EXPORTING
        NAME  = '~server_protocol'
        VALUE = 'HTTP/1.1'.
    CALL METHOD HTTP_CLIENT->REQUEST->SET_HEADER_FIELD
      EXPORTING
        NAME  = '~request_uri'
        VALUE = '/service/accurate/workorder.asmx?'.
    CALL METHOD HTTP_CLIENT->REQUEST->SET_HEADER_FIELD
      EXPORTING
        NAME  = 'Content-Type'
        VALUE = 'text/xml; charset=utf-8'.
    CALL METHOD HTTP_CLIENT->REQUEST->SET_HEADER_FIELD
      EXPORTING
        NAME  = 'Content-Length'
        VALUE = TXLEN.
    CALL METHOD HTTP_CLIENT->REQUEST->SET_HEADER_FIELD
      EXPORTING
        NAME  = 'SOAPAction'
        VALUE = 'http://********merica.net/webservices/GetWorkOrder'.
    CALL METHOD HTTP_CLIENT->REQUEST->SET_CDATA
      EXPORTING
        DATA   = WF_STRING
        OFFSET = 0
        LENGTH = RLENGTH.
    Send the Input Data to Web service.
    CALL METHOD HTTP_CLIENT->SEND
      EXCEPTIONS
        HTTP_COMMUNICATION_FAILURE = 1
        HTTP_INVALID_STATE         = 2.
    Receive the Input from Web Serice.
    CALL METHOD HTTP_CLIENT->RECEIVE
      EXCEPTIONS
        HTTP_COMMUNICATION_FAILURE = 1
        HTTP_INVALID_STATE         = 2
        HTTP_PROCESSING_FAILED     = 3.
    CLEAR WF_STRING1 .
    WF_STRING1 = HTTP_CLIENT->RESPONSE->GET_CDATA( ).
    DATA: LENGTH TYPE I.
    LENGTH = STRLEN( WF_STRING1 ).
    DATA: VALUE_FIELD TYPE NAME_KOMP.
    DATA: VALUE TYPE REF TO DATA.
    FIELD-SYMBOLS: <FS_CONVERTED_DATA>.
    DATA: TAB1 TYPE TABLE OF STRING.
    DATA: FROM_LENGTH TYPE I VALUE 1.
    DATA: TO_LENGTH TYPE I.
    DATA: DIFF TYPE I.
    DATA: START TYPE I VALUE 1.
    DO.
    JOBCODE.
      SEARCH WF_STRING1 FOR 'JobCode=' . "STARTING AT START .
      IF SY-SUBRC <> 0.
        EXIT.
      ENDIF.
      FROM_LENGTH = SY-FDPOS .
      FROM_LENGTH = FROM_LENGTH  + 8.
      SEARCH WF_STRING1 FOR 'JobDescription=' ."STARTING AT START ..
      TO_LENGTH = SY-FDPOS .
      DIFF = TO_LENGTH - FROM_LENGTH .
      MOVE WF_STRING1+FROM_LENGTH(DIFF) TO TAB-JOBCODE.
      TO_LENGTH = DIFF + TO_LENGTH.
      SHIFT WF_STRING1 BY TO_LENGTH PLACES.
    COMPONENT CODE
      SEARCH WF_STRING1 FOR 'ComponentCode=' .
      IF SY-SUBRC <> 0.
        EXIT.
      ENDIF.
      FROM_LENGTH = SY-FDPOS .
      FROM_LENGTH = FROM_LENGTH  + 14.
      SEARCH WF_STRING1 FOR 'ComponentDescription=' .
      TO_LENGTH = SY-FDPOS .
      DIFF = TO_LENGTH - FROM_LENGTH .
      MOVE WF_STRING1+FROM_LENGTH(DIFF) TO TAB-COMPONENTCODE.
      TO_LENGTH = DIFF + TO_LENGTH.
      SHIFT WF_STRING1 BY TO_LENGTH PLACES.
    AccurateHours
      SEARCH WF_STRING1 FOR 'AccurateHours=' .
      IF SY-SUBRC <> 0.
        EXIT.
      ENDIF.
      FROM_LENGTH = SY-FDPOS .
      FROM_LENGTH = FROM_LENGTH  + 14.
      SEARCH WF_STRING1 FOR 'AccurateCost='.
      TO_LENGTH = SY-FDPOS .
      DIFF = TO_LENGTH - FROM_LENGTH .
      MOVE WF_STRING1+FROM_LENGTH(DIFF) TO TAB-ACCURATEHOURS.
      TO_LENGTH = DIFF + TO_LENGTH.
    AccurateCost
      SEARCH WF_STRING1 FOR 'AccurateCost='.
      FROM_LENGTH =  SY-FDPOS.
      FROM_LENGTH =  FROM_LENGTH + 13.
      SEARCH WF_STRING1 FOR '/>'.
      TO_LENGTH = SY-FDPOS.
      DIFF = TO_LENGTH - FROM_LENGTH .
      MOVE WF_STRING1+FROM_LENGTH(DIFF) TO TAB-ACCURATECOST.
      TO_LENGTH = DIFF + TO_LENGTH.
      SHIFT WF_STRING1 BY TO_LENGTH PLACES.
      APPEND TAB TO OUTTAB.
    ENDDO.
    WRITE: (10) 'JOBCODE'.
    WRITE (20) 'COMPONENTCODE'.
    WRITE (30) 'ACCURATEHOURS'.
    WRITE (40) 'ACCURATECOST'.
    LOOP AT OUTTAB INTO TAB.
      WRITE:/ TAB-JOBCODE .
      WRITE (20) TAB-COMPONENTCODE.
      WRITE (30) TAB-ACCURATEHOURS.
      WRITE (40) TAB-ACCURATECOST.
    ENDLOOP .
    It is better to create a proxy, it then puts a level of abstraction between in that coding. All you need to do is then access the proxy class.
    Besides that i think you can do it by configuring the ITS and calling the webservice by means of using BSP applications in ABAP
    <b>I believe you need to create a proxy in order to consume your web service.
    http://help.sap.com/saphelp_nw2004s/helpdata/en/bf/d005244e9d1d4d92b2fe7935556b4c/frameset.htm
    Reward points</b>
    Regards

  • SAP naming conventions: customer DDIC objects, ABAP programming

    SAP Note 16466 Customer name range for SAP objects contains the SAP naming conventions for customer DDIC objects. Rule of thumb is that the names reserved for customer objects start with 'Y' or 'Z'. However, this note contains the naming convention for DDIC objects only.
    ABAP Code Inspector (transaction SCI) contains the following naming convention for ABAP programming:
    - Global types: T_
    - Global constants: C_
    - Global data: gv_
    - Global field-symbols: FS_
    - Global parameters: P_
    - Global select-options: S_
    - Global field-groups: FS_
    - Local types: LT_
    - Local constants: LC_
    - Local data: v_
    - Local field-symbols: LFS_
    This is the only place I know for ABAP programming naming convention. Does SAP has somewhere else any additional naming convention guidelines for ABAP programming?
    Thanks in advance for your help.
    Regards,
    Jarmo Tuominen

    Naming convention guidelines for ABAP programming is available in here: [Manage Successful Customer Development|https://websmp206.sap-ag.de/~sapidb/011000358700004444532001E].
    Naming Data Types and Objects
    The names of data types and objects have the form: <Classifier>_<Data type>_<Descriptor>.
    The names of data types and objects have up to 30 characters.
    Exceptions: names of input parameters and select options have up to 8 characters, and <Data type> and _ are omitted.
    First component: Classifier
    T Data type
    C  Constant
    G  Global data object
    L  Local data object
    FS Field symbol
    P  Input parameter
    S  Select option
    P  Formal parameter in form
    FM Formal parameter in function
    Second component: Data Type
    <t> Elementary data type, optionally followed by length
    C<n> Type C of length <n>
    N<l> Type N of length <n>
    X<l> Type X of length <n>
    D    Type D
    T    Type T
    I    Type I
    P<d> Type P with <d> decimals
    F    Type F
    WA  Work area
    IT  Internal table
    Third component: Descriptor
    Use meaningful English names. Later, your code may be maintained or analyzed by a programmer or support consultant who is not familiar with another language.
    Use only alphanumeric characters (A-Z and 0-9) and separate words with underscores (_). Hyphens are reserved for separating components in structured data types.
    Examples:
    G_I_COUNTER (global counter)
    T_IT_BOOKING_LIST (type for list of bookings)
    G_IT_BOOKINGS (global internal table of bookings)
    PSMOKER (input parameter for smoker flag: note omission of data type and _ for brevity)
    Edited by: Jarmo Tuominen on Feb 21, 2011 2:13 PM

  • Termination occurred in the ABAP program "RK2APA00_POST" - in

    Hi everybody...I have a cancelled job when run only in applications servers , I see a dump "message typeX" , but when job run in Central Instance not cancelled and finish ok.
    The name Job is Zcupon and attach to continue dump info , sorry for extended but I want send all information possible.
    know if you can add a file with the abstract and not have to paste the text of the dump, thanks for the help they can deliver.
    Regards....Freddy Solar....
    Errores tiempo ejec.   MESSAGE_TYPE_X
    Fecha y hora           18.11.2008 06:35:30
    Texto breve
    The current application triggered a termination with a short dump.
    ¿Qué ha sucedido?
    The current application program detected a situation which really
    should not occur. Therefore, a termination with a short dump was
    triggered on purpose by the key word MESSAGE (type X).
    Anál.errores
    Short text of error message:
    RFC_ERROR 4 Conversation 93690218 not found / CPIC-CALL: 'ThSA
    Technical information about the message:
    Message classe...... "KE"
    Number.............. 628
    Variable 1.......... "RFC_ERROR"
    Variable 2.......... 4
    Variable 3.......... "Conversation 93690218 not found / CPIC-CALL: 'ThSA"
    Variable 4.......... " "
    Last error logged in SAP kernel
    Component............ "SAP-Gateway"
    Place................ "SAP-Gateway on host SCPAPP1 / sapgw03"
    Version.............. 2
    Error code........... 728
    Error text........... "Conversation 93690218 not found"
    Description.......... " "
    System call.......... " "
    Module............... "gwxxrd.c"
    Line................. 6156
    The error reported by the operating system is:
    Error number..... " "
    Error text....... " "
    Notas para corregir errores
    Probably the only way to eliminate the error is to correct the program.
    You may able to find an interim solution to the problem
    in the SAP note system. If you have access to the note system yourself,
    please use the following search criteria:
    "RK2APA00_POST" "MESSAGE_TYPE_X"
    If you cannot solve the problem yourself, please send the
    following documents to SAP:
    1. A hard copy print describing the problem.
    To obtain this, select the "Print" function on the current screen.
    2. A suitable hardcopy prinout of the system log.
    To obtain this, call the system log with Transaction SM21
    and select the "Print" function to print out the relevant
    part.
    3. If the programs are your own programs or modified SAP programs,
    supply the source code.
    To do this, you can either use the "PRINT" command in the editor or
    print the programs using the report RSINCL00.
    4. Details regarding the conditions under which the error occurred
    or which actions and input led to the error.
    Entorno sistema
    SAP-Release 700
    Application server... "SCPAPP1"
    Network address...... "10.1.40.130"
    Operating system..... "Windows NT"
    Release.............. "5.2"
    Hardware type........ "4x AMD64 Level"
    Character length.... 16 Bits
    Pointer length....... 64 Bits
    Work process number.. 3
    Shortdump setting.... "full"
    Database server... "BALTICO"
    Database type..... "DB400"
    Database name..... "SCP"
    Database user ID.. "R3SCPDATA"
    Char.set.... "C"
    SAP kernel....... 700
    created (date)... "Jun 30 2008 00:10:07"
    create on........ "NT 5.2 3790 Service Pack 1 x86 MS VC++ 14.00"
    Database version. "DB4_53"
    Patch level. 167
    Patch text.. " "
    Database............. "V5R3, V5R4, V6R1"
    SAP database version. 700
    Operating system..... "Windows NT 5.0, Windows NT 5.1, Windows NT 5.2, Windows
    NT 6.0"
    Memory consumption
    Roll.... 16192
    EM...... 159213920
    Heap.... 0
    Page.... 5660672
    MM Used. 145143664
    MM Free. 5680112
    Usuario y transacción
    Client.............. 400
    User................ "ZUSRTARJETAS"
    Language key........ "S"
    Transaction......... " "
    Program............. "RK2APA00_POST"
    Screen.............. "SAPMSSY0 1000"
    Screen line......... 6
    Info posición de cancelación
    Termination occurred in the ABAP program "RK2APA00_POST" - in
    "INSERT_CE4_FLUSH_BUFFERS".
    The main program was "ZVI_CUPON ".
    In the source code you have the termination point in line 100
    of the (Include) program "RKEVRK2A_POST_COMMIT__FIX".
    The program "RK2APA00_POST" was started as a background job.
    Job Name....... "ZCUPON"
    Job Initiator.. "ZUSRTARJETAS"
    Job Number..... 02044200
    Detalle código fuente
    Lín.
    Txt.fte.
    70
    subrc = sy-subrc.
    71
    CLEAR: g_t_ce4a_dbbuf[], g_t_ce4_dbbuf[].
    72
    73
    case subrc.
    74
    when 1.
    75
        Records were to be inserted into the acct.ref. table CE4xxxx_ACCT
    76
        but the acct. reference numbers were already occupied. Most likely
    77
        This problem is due to a explicit or implicit change to the
    78
        number range COPA_OBJ (subobject is the operating concern)
    79
        e.g. caused by illegally transporting the contents of CO-PA
    80
        transaction data table contents (CE4xxxx / CE4xxxx_ACCT).
    81
        Please check OSS for notes with keywords RKEVRK2A_POST, KF216
    82
        and CE4XXXX_ACCT. If you do not find any applicable notes please
    83
        log an OSS message.
    84
    MESSAGE x216(kf) WITH gc_ce4acct_name.
    85
    86
    when 2.
    87
        Records were to be inserted into the segment table CE4xxxx
    88
        but the segment numbers were already occupied. Most likely
    89
        This problem is due to a explicit or implicit change to the
    90
        number range COPA_OBJ (subobject is the operating concern)
    91
        e.g. caused by illegally transporting the contents of CO-PA
    92
        transaction data table contents (CE4xxxx).
    93
        Please check OSS for notes with keywords RKEVRK2A_POST, KF203
    94
        and CE4XXXX. If you do not find any applicable notes please
    95
        log an OSS message.
    96
    MESSAGE x203(kf).
    97
    98
    when 3 or 4.
    99
        Communication error in RFC-Call
    >>>>>
    message x628(ke) with 'RFC_ERROR' subrc msg_text.
    101
    102
    endcase.
    103
    104
    ENDFORM.
    105
    Edited by: freddy solar on Jan 2, 2009 8:39 PM

    Hi,
    it looks like you have some problem with RFC. It stopped on the following line:
    * Communication error in RFC-Call
    message x628(ke) with 'RFC_ERROR' subrc msg_text.
    Ask your basis guy to check it. The job on application server tried to connect to the central instance and it failed. The job run on central instance does not need to make any RFC call. Hence there is no problem in this case.
    Regards

  • Migration influence in ABAP program

    hi guys,
    We are going for migration from 4.6C (Op.sys - HP-Unix, DB-Oracle 8.0) to 4.6C(Op.sys-Solaris,DB-Oracle 9.0).
    We need to analyse what are the changes required to be considered before migration.
    I guess below things are basic things
    1-External command.
    2-OS level application execution command.
    3-OPEN file path(logical path,physical path)
    other than this is there any thing i have to considered for OS and Database difference inside ABAP programs.
    appreciate if you Can give me check list...if possible
    Pls suggest me.
    thanks.
    Ambi.

    MESSAGE  ext TYPE mtype ... .
    This variant sends a character string contained in text as a message of the message type specified in mtype. You can enter a character-type data object text, which will be used as a short text for the message. Only the first 300 characters in text are taken into account. No long text can be defined for a message of this type.
    For mtype, a character-type data object is expected, which must contain the message type in capital letters. Invalid message types generate an untreatable exception.
    Notes
    : In this variant, the additions WITH and INTO are not allowed in message_options.
    If field symbols or formal parameters of the type any or data are specified for text, these must be of character type when the statement is executed. The syntactically identical variant MESSAGE oref cannot be executed with generically typed field symbols or formal parameters.
    Because the system fields sy-msgid and sy-msgno are filled unspecifically when a character string is entered, this variant should only be used on rare occasions if the content of the system fields is not required for identification of the message. Otherwise, in all cases in which messages are transferred (for example, from function modules) or logged (for example, in batch input) using these system fields, language-independent access to the message text would be lost.
    Example
    : Output of an exception text as an information message.
    DATA: oref TYPE REF TO cx_sy_arithmetic_error,
          text TYPE string.
    TRY.
      CATCH cx_sy_arithmetic_error INTO oref.
        text = oref->get_text( ).
        MESSAGE text TYPE 'I'.
    ENDTRY.

  • RRi for query using ABAP program

    For a report, we are using RRI (jump to target) functionality to see invoices in R/3 system using an ABAP program. I do not have much idea on R/3 systems how invoices are setup in R/3 Dev, test and prod. The ABAP report is done by a backend person. I need to place that in RSBBS. Here, my doubt is that do we need to follow the same procedure for this to move it to production system i.e, first create that RRI and ABAP in respective dev systems and transport both to test and then to Prod? Could anyone please explain me the steps on how this will work in real-time?
    Points will be assigned.
    Thanks

    Hi,
    I am not able to find how the two reports are conncted.
    You can check in RSBBS t-code. RRI will be defined here to jump from One Query yo another and many more options.
    My work is to copy the parent query a nd do some modification to it. Please let me know how to check and achieve that.
    You can do this BEx Query Designer itself.
    Regards,
    Suman

  • Error in Posting Data Using ABAP Program.

    I am Using Scenario SAP(RFC) to Webservice through XI
    I called My RFC into ABAP Program  and given RFC Destination
    and executing it goes into Short DUMP.
    I gives an Error message as
    " alternativeServiceIdentifier:party/service from channel configuration are not"
    Wat should i Do for this Error.
    regards,
    Jayasimha Jangam

    Hi
    Please look into these threads
    alternativeServiceIdentifier: party/service from channel configuration are.
    Rfc sender problem(sap r/3 -se37) 'alternativeServiceIdentifier: party/serv
    Also this Blog will help you,
    /people/michal.krawczyk2/blog/2005/09/07/xi-why-dont-start-searching-for-all-errors-from-one-place
    Reward points if found usefull............

  • Creating Infoset query based on ABAP program

    Hello
    I have 3 tables FEBEP, BKPF and BSEG and I need to join the 3 tables based on:
    FEBEP-MANDT = BKPF-MANDT = BSEG-MANDT
    FEBEP-NBBLN = BKPF-BELNR = BSEG-AUGBL
    FEBEP-GJAHR = BKPF-GJAHR = BSEG-GJAHR
    Then I have a few view fields from all the 3 tables. After this I can build an infoset query based on structure + ABAP program, and a generic datasource on top of it.
    Can someone give me the ABAP code to be written SE38? Also should I select integrated program/external program in the infoset query?
    Thanks,
    Srini.

    Hi,
    Even if you create an ABAP program for infoset, you will writing a SELECT statement from BSEG table which is quite huge.
    And you will putting JOIN with other tables.
    Performance wise this is not advisble.
    Why do not try the following other tables and check if the fields you need are available?
    You can't join BSEG as it is a Cluster Table.In the place of BSEG you can use:
    Account Recivables data use BSID and BSAD tables
    GL Account Related data use BSIS and BSAS tables
    Account payables data use BSIK and BSAK tables
    Thanks.

  • How to improve the performance of the abap program

    hi all,
    I have created an abap program. And it taking long time since the number of records are more. And can anyone let me know how to improve the performance of my abap program.
    Using se30 and st05 transaction.
    can anyone help me out step by step
    regds
    haritha

    Hi Haritha,
    ->Run Any program using SE30 (performance analysis)
    Note: Click on the Tips & Tricks button from SE30 to get performance improving tips.
    Using this you can improve the performance by analyzing your code part by part.
    ->To turn runtim analysis on within ABAP code insert the following code
    SET RUN TIME ANALYZER ON.
    ->To turn runtim analysis off within ABAP code insert the following code
    SET RUN TIME ANALYZER OFF.
    ->Always check the driver internal tables is not empty, while using FOR ALL ENTRIES
    ->Avoid for all entries in JOINS
    ->Try to avoid joins and use FOR ALL ENTRIES.
    ->Try to restrict the joins to 1 level only ie only for tables
    ->Avoid using Select *.
    ->Avoid having multiple Selects from the same table in the same object.
    ->Try to minimize the number of variables to save memory.
    ->The sequence of fields in 'where clause' must be as per primary/secondary index ( if any)
    ->Avoid creation of index as far as possible
    ->Avoid operators like <>, > , < & like % in where clause conditions
    ->Avoid select/select single statements in loops.
    ->Try to use 'binary search' in READ internal table. -->Ensure table is sorted before using BINARY SEARCH.
    ->Avoid using aggregate functions (SUM, MAX etc) in selects ( GROUP BY , HAVING,)
    ->Avoid using ORDER BY in selects
    ->Avoid Nested Selects
    ->Avoid Nested Loops of Internal Tables
    ->Try to use FIELD SYMBOLS.
    ->Try to avoid into Corresponding Fields of
    ->Avoid using Select Distinct, Use DELETE ADJACENT
    Check the following Links
    Re: performance tuning
    Re: Performance tuning of program
    http://www.sapgenie.com/abap/performance.htm
    http://www.thespot4sap.com/Articles/SAPABAPPerformanceTuning_PerformanceAnalysisTools.asp
    check the below link
    http://www.sap-img.com/abap/performance-tuning-for-data-selection-statement.htm
    See the following link if it's any help:
    http://www.thespot4sap.com/Articles/SAPABAPPerformanceTuning_PerformanceAnalysisTools.asp
    Check also http://service.sap.com/performance
    and
    books like
    http://www.sap-press.com/product.cfm?account=&product=H951
    http://www.sap-press.com/product.cfm?account=&product=H973
    http://www.sap-img.com/abap/more-than-100-abap-interview-faqs.htm
    http://www.thespot4sap.com/Articles/SAPABAPPerformanceTuning_PerformanceAnalysisTools.asp
    Performance tuning for Data Selection Statement
    http://www.sap-img.com/abap/performance-tuning-for-data-selection-statement.htm
    Debugger
    http://help.sap.com/saphelp_47x200/helpdata/en/c6/617ca9e68c11d2b2ab080009b43351/content.htm
    http://www.cba.nau.edu/haney-j/CIS497/Assignments/Debugging.doc
    http://help.sap.com/saphelp_erp2005/helpdata/en/b3/d322540c3beb4ba53795784eebb680/frameset.htm
    Run Time Analyser
    http://help.sap.com/saphelp_47x200/helpdata/en/c6/617cafe68c11d2b2ab080009b43351/content.htm
    SQL trace
    http://help.sap.com/saphelp_47x200/helpdata/en/d1/801f7c454211d189710000e8322d00/content.htm
    CATT - Computer Aided Testing Too
    http://help.sap.com/saphelp_47x200/helpdata/en/b3/410b37233f7c6fe10000009b38f936/frameset.htm
    Test Workbench
    http://help.sap.com/saphelp_47x200/helpdata/en/a8/157235d0fa8742e10000009b38f889/frameset.htm
    Coverage Analyser
    http://help.sap.com/saphelp_47x200/helpdata/en/c7/af9a79061a11d4b3d4080009b43351/content.htm
    Runtime Monitor
    http://help.sap.com/saphelp_47x200/helpdata/en/b5/fa121cc15911d5993d00508b6b8b11/content.htm
    Memory Inspector
    http://help.sap.com/saphelp_47x200/helpdata/en/a2/e5fc84cc87964cb2c29f584152d74e/content.htm
    ECATT - Extended Computer Aided testing tool.
    http://help.sap.com/saphelp_47x200/helpdata/en/20/e81c3b84e65e7be10000000a11402f/frameset.htm
    Just refer to these links...
    performance
    Performance
    Performance Guide
    performance issues...
    Performance Tuning
    Performance issues
    performance tuning
    performance tuning
    You can go to the transaction SE30 to have the runtime analysis of your program.Also try the transaction SCI , which is SAP Code Inspector.
    edited by,
    Naveenan

  • Call to Java web service from abap program

    HI,
    I want to call to Java WS from abap program and i read some post how to do that in release of NW 6.4 but I want to know what is the simplest way to do that in release 7.0 .
    Many Thanks,
    Nina

    Hi Uwe,
    Thank you.
    I have WSDL or URL how i can call to them ,in the example that you send i don't find the place that it called.
    Do i have to create proxy for that ?
    BR
    Nina

  • Access table using ABAP program in other database

    Dear SAP Expert,
    We have requirement that related to SAP interface.
    Our SAP system run on Oracle database 11g (Unix).
    Illustration: SAP system = A non SAP system = B
    We need to access a table using ABAP program (from SAP system A) in other database (system B) that are not necessarily SAP database. The non-SAP system using SQL Server 2008 (Windows).
    What is the best practice for this interface
    Do we need database link? If yes, please help to inform me the details step to configure it.
    Thanks and Regards

    Hi Friend,
    You try using an intermediate system..passing your input required to fetch the data..and PI should call the respective query to retrive record..once the full flow is completed you should get the return through some table in the calling program.
    else.
    ask the other system guy to write a function with select query and ask him to expose as RFC and that RFC we have to call it as RFC in our program to get the required values and only thing we need here is a proper connector in place.
    Regards
    S.Janagar

  • ABAP Programming PDF

    Hello ABAP Programmers,
    I am new to ABAP. I am learning ABAP Programming. I have the SAP PDF file of the ABAP Programming but it is of version April 2001.
    Is any body have latest version of the same.
    Please provide me some link of the PDFs.
    Thanks in Advance,
    Prashant

    go through the links
    Start with this.Refer this
    http://www.sapbrain.com/FAQs/TECHNICAL/SAP_ABAP_DATADICTIONARY_FAQ.html
    http://www.****************/InterviewQ/interviewQ.htm
    http://help.sap.com/saphelp_46c/helpdata/en/35/2cd77bd7705394e10000009b387c12/frameset.htm
    Reports
    http://www.sapgenie.com/abap/reports.htm
    http://www.allsaplinks.com/material.html
    http://www.sapdevelopment.co.uk/reporting/reportinghome.htm
    http://www.sapfans.com/forums/viewtopic.php?t=58286
    http://www.sapfans.com/forums/viewtopic.php?t=76490
    http://www.sapfans.com/forums/viewtopic.php?t=20591
    http://www.sapfans.com/forums/viewtopic.php?t=66305 - this one discusses which way should you use - ABAP Objects calls or simple function modules.
    ALE/ IDOC
    http://help.sap.com/saphelp_erp2004/helpdata/en/dc/6b835943d711d1893e0000e8323c4f/content.htm
    http://www.sapgenie.com/sapgenie/docs/ale_scenario_development_procedure.doc
    http://edocs.bea.com/elink/adapter/r3/userhtm/ale.htm#1008419
    http://www.netweaverguru.com/EDI/HTML/IDocBook.htm
    http://www.sapgenie.com/sapedi/index.htm
    http://www.sappoint.com/abap/ale.pdf
    http://www.sappoint.com/abap/ale2.pdf
    http://www.sapgenie.com/sapedi/idoc_abap.htm
    http://help.sap.com/saphelp_erp2005/helpdata/en/0b/2a60bb507d11d18ee90000e8366fc2/frameset.htm
    http://help.sap.com/saphelp_erp2005/helpdata/en/78/217da751ce11d189570000e829fbbd/frameset.htm
    http://www.allsaplinks.com/idoc_sample.html
    http://www.sappoint.com/abap.html
    http://help.sap.com/saphelp_erp2004/helpdata/en/dc/6b835943d711d1893e0000e8323c4f/content.htm
    http://www.sapgenie.com/sapgenie/docs/ale_scenario_development_procedure.doc
    http://edocs.bea.com/elink/adapter/r3/userhtm/ale.htm#1008419
    http://www.netweaverguru.com/EDI/HTML/IDocBook.htm
    http://www.sapgenie.com/sapedi/index.htm
    http://www.allsaplinks.com/idoc_sample.html
    Check these step-by-step links
    https://www.sdn.sap.com/irj/servlet/prt/portal/prtroot/com.sap.km.cm.docs/library/uuid/ccab6730-0501-0010-ee84-de050a6cc287
    https://sdn.sap.com/irj/servlet/prt/portal/prtroot/com.sap.km.cm.docs/library/uuid/8fd773b3-0301-0010-eabe-82149bcc292e
    https://www.sdn.sap.com/irj/servlet/prt/portal/prtroot/com.sap.km.cm.docs/library/uuid/3c5d9ae3-0501-0010-0090-bdfb2d458985
    for Smartforms material
    http://www.sap-basis-abap.com/sapsf001.htm
    http://www.sap-press.com/downloads/h955_preview.pdf
    http://www.ossincorp.com/Black_Box/Black_Box_2.htm
    http://www.sap-img.com/smartforms/sap-smart-forms.htm
    http://www.sap-img.com/smartforms/smartform-tutorial.htm
    http://www.sapgenie.com/abap/smartforms.htm
    How to trace smartform
    http://help.sap.com/saphelp_47x200/helpdata/en/49/c3d8a4a05b11d5b6ef006094192fe3/frameset.htm
    http://www.help.sap.com/bp_presmartformsv1500/DOCU/OVIEW_EN.PDF
    http://www.sap-img.com/smartforms/smart-006.htm
    http://www.sap-img.com/smartforms/smartforms-faq-part-two.htm
    Re: Need FAQ's
    check most imp link
    http://www.sapbrain.com/ARTICLES/TECHNICAL/SMARTFORMS/smartforms.html
    step by step good ex link is....
    http://smoschid.tripod.com/How_to_do_things_in_SAP/How_To_Build_SMARTFORMS/How_To_Build_SMARTFORMS.html
    SAPScripts
    http://esnips.com/doc/1ff9f8e8-0a4c-42a7-8819-6e3ff9e7ab44/sapscripts.pdf
    http://esnips.com/doc/1e487f0c-8009-4ae1-9f9c-c07bd953dbfa/script-command.pdf
    http://esnips.com/doc/64d4eccb-e09b-48e1-9be9-e2818d73f074/faqss.pdf
    http://esnips.com/doc/cb7e39b4-3161-437f-bfc6-21e6a50e1b39/sscript.pdf
    http://esnips.com/doc/fced4d36-ba52-4df9-ab35-b3d194830bbf/symbols-in-scripts.pdf
    http://esnips.com/doc/b57e8989-ccf0-40d0-8992-8183be831030/sapscript-how-to-calculate-totals-and-subtotals.htm
    SAP SCRIPT FIELDS
    http://help.sap.com/saphelp_erp2005vp/helpdata/en/d1/8033ea454211d189710000e8322d00/content.htm
    scripts easy material
    http://www.allsaplinks.com/sap_script_made_easy.html
    Debugging Document.
    http://www.cba.nau.edu/haney-j/CIS497/Assignments/Debugging.doc
    http://help.sap.com/saphelp_47x200/helpdata/en/c6/617ca9e68c11d2b2ab080009b43351/content.htm
    http://www.cba.nau.edu/haney-j/CIS497/Assignments/Debugging.doc
    http://help.sap.com/saphelp_erp2005/helpdata/en/b3/d322540c3beb4ba53795784eebb680/frameset.htm
    http://help.sap.com/saphelp_nw04/helpdata/en/84/1f624f4505144199e3d570cf7a9225/frameset.htm
    http://help.sap.com/saphelp_bw30b/helpdata/en/c6/617ca9e68c11d2b2ab080009b43351/content.htm
    http://help.sap.com/saphelp_erp2005/helpdata/en/b3/d322540c3beb4ba53795784eebb680/frameset.htm
    BAPI
    http://help.sap.com/saphelp_46c/helpdata/en/9b/417f07ee2211d1ad14080009b0fb56/frameset.htm
    http://searchsap.techtarget.com/originalContent/0,289142,sid21_gci948835,00.html
    Checkout !!
    http://searchsap.techtarget.com/originalContent/0,289142,sid21_gci948835,00.html
    http://techrepublic.com.com/5100-6329-1051160.html#
    http://www.sap-img.com/bapi.htm
    http://www.sap-img.com/abap/bapi-conventions.htm
    http://www.sappoint.com/abap/bapiintro.pdf
    http://www.sapgenie.com/abap/bapi/example.htm
    http://help.sap.com/printdocu/core/Print46c/en/data/pdf/BCMIDAPII/CABFAAPIINTRO.pdf
    http://help.sap.com/printdocu/core/Print46c/en/data/pdf/CABFABAPIREF/CABFABAPIPG.pdf
    http://help.sap.com/printdocu/core/Print46c/en/data/pdf/BCFESDE8/BCFESDE8.pdf
    List of all BAPIs
    http://www.planetsap.com/LIST_ALL_BAPIs.htm
    http://www.sappoint.com/abap/bapiintro.pdf
    http://www.sappoint.com/abap/bapiprg.pdf
    http://www.sappoint.com/abap/bapiactx.pdf
    http://www.sappoint.com/abap/bapilst.pdf
    http://www.sappoint.com/abap/bapiexer.pdf
    http://service.sap.com/ale
    http://service.sap.com/bapi
    http://www.geocities.com/mpioud/Abap_programs.html
    http://www.sapdevelopment.co.uk/reporting/reportinghome.htm
    Simple ALV report
    http://www.sapgenie.com/abap/controls/alvgrid.htm
    http://wiki.ittoolbox.com/index.php/Code:Ultimate_ALV_table_toolbox
    ALV
    1. Please give me general info on ALV.
    http://www.sapfans.com/forums/viewtopic.php?t=58286
    http://www.sapfans.com/forums/viewtopic.php?t=76490
    http://www.sapfans.com/forums/viewtopic.php?t=20591
    http://www.sapfans.com/forums/viewtopic.php?t=66305 - this one discusses which way should you use - ABAP Objects calls or simple function modules.
    2. How do I program double click in ALV?
    http://www.sapfans.com/forums/viewtopic.php?t=11601
    http://www.sapfans.com/forums/viewtopic.php?t=23010
    3. How do I add subtotals (I have problem to add them)...
    http://www.sapfans.com/forums/viewtopic.php?t=20386
    http://www.sapfans.com/forums/viewtopic.php?t=85191
    http://www.sapfans.com/forums/viewtopic.php?t=88401
    http://www.sapfans.com/forums/viewtopic.php?t=17335
    4. How to add list heading like top-of-page in ABAP lists?
    http://www.sapfans.com/forums/viewtopic.php?t=58775
    http://www.sapfans.com/forums/viewtopic.php?t=60550
    http://www.sapfans.com/forums/viewtopic.php?t=16629
    5. How to print page number / total number of pages X/XX in ALV?
    http://www.sapfans.com/forums/viewtopic.php?t=29597 (no direct solution)
    6. ALV printing problems. The favourite is: The first page shows the number of records selected but I don't need this.
    http://www.sapfans.com/forums/viewtopic.php?t=64320
    http://www.sapfans.com/forums/viewtopic.php?t=44477
    7. How can I set the cell color in ALV?
    http://www.sapfans.com/forums/viewtopic.php?t=52107
    8. How do I print a logo/graphics in ALV?
    http://www.sapfans.com/forums/viewtopic.php?t=81149
    http://www.sapfans.com/forums/viewtopic.php?t=35498
    http://www.sapfans.com/forums/viewtopic.php?t=5013
    9. How do I create and use input-enabled fields in ALV?
    http://www.sapfans.com/forums/viewtopic.php?t=84933
    http://www.sapfans.com/forums/viewtopic.php?t=69878
    10. How can I use ALV for reports that are going to be run in background?
    http://www.sapfans.com/forums/viewtopic.php?t=83243
    http://www.sapfans.com/forums/viewtopic.php?t=19224
    11. How can I display an icon in ALV? (Common requirement is traffic light icon).
    http://www.sapfans.com/forums/viewtopic.php?t=79424
    http://www.sapfans.com/forums/viewtopic.php?t=24512
    12. How can I display a checkbox in ALV?
    http://www.sapfans.com/forums/viewtopic.php?t=88376
    http://www.sapfans.com/forums/viewtopic.php?t=40968
    http://www.sapfans.com/forums/viewtopic.php?t=6919
    Go thru these programs they may help u to try on some hands on
    ALV Demo program
    BCALV_DEMO_HTML
    BCALV_FULLSCREEN_DEMO ALV Demo: Fullscreen Mode
    BCALV_FULLSCREEN_DEMO_CLASSIC ALV demo: Fullscreen mode
    BCALV_GRID_DEMO Simple ALV Control Call Demo Program
    BCALV_TREE_DEMO Demo for ALV tree control
    BCALV_TREE_SIMPLE_DEMO
    BC_ALV_DEMO_HTML_D0100
    Remote Function Call:
    RFC is an SAP interface protocol. Based on CPI-C, it considerably simplifies the programming of communication processes between systems.
    RFCs enable you to call and execute predefined functions in a remote system - or even in the same system.
    RFCs manage the communication process, parameter transfer and error handling.
    http://help.sap.com/saphelp_47x200/helpdata/en/22/042860488911d189490000e829fbbd/frameset.htm.
    ALE/ IDOC
    http://help.sap.com/saphelp_erp2004/helpdata/en/dc/6b835943d711d1893e0000e8323c4f/content.htm
    http://www.sapgenie.com/sapgenie/docs/ale_scenario_development_procedure.doc
    http://edocs.bea.com/elink/adapter/r3/userhtm/ale.htm#1008419
    http://www.netweaverguru.com/EDI/HTML/IDocBook.htm
    http://www.sapgenie.com/sapedi/index.htm
    http://www.sappoint.com/abap/ale.pdf
    http://www.sappoint.com/abap/ale2.pdf
    http://www.sapgenie.com/sapedi/idoc_abap.htm
    http://help.sap.com/saphelp_erp2005/helpdata/en/0b/2a60bb507d11d18ee90000e8366fc2/frameset.htm
    http://help.sap.com/saphelp_erp2005/helpdata/en/78/217da751ce11d189570000e829fbbd/frameset.htm
    http://www.allsaplinks.com/idoc_sample.html
    http://www.sappoint.com/abap.html
    http://help.sap.com/saphelp_erp2004/helpdata/en/dc/6b835943d711d1893e0000e8323c4f/content.htm
    http://www.sapgenie.com/sapgenie/docs/ale_scenario_development_procedure.doc
    http://edocs.bea.com/elink/adapter/r3/userhtm/ale.htm#1008419
    http://www.netweaverguru.com/EDI/HTML/IDocBook.htm
    http://www.sapgenie.com/sapedi/index.htm
    http://www.allsaplinks.com/idoc_sample.html
    Refer this
    http://www.sapbrain.com/FAQs/TECHNICAL/SAP_ABAP_DATADICTIONARY_FAQ.html
    http://www.****************/InterviewQ/interviewQ.htm
    http://help.sap.com/saphelp_46c/helpdata/en/35/2cd77bd7705394e10000009b387c12/frameset.htm
    http://www.techinterviews.com/?p=198
    http://www.techinterviews.com/?p=326
    http://www.sap-img.com/abap/answers-to-some-abap-interview-questions.htm
    http://www.sap-img.com/abap/more-than-100-abap-interview-faqs.htm
    http://www.geekinterview.com/Interview-Questions/SAP-R-3/ABAP
    http://sap.ittoolbox.com/documents/popular-q-and-a/abap-sample-interview-questions-3240
    http://www.sap-img.com/abap/abap-interview-question.htm
    http://www.allinterview.com/Interview-Questions/ABAP.html
    new to abap
    New to ABAP
    New to ABAP
    new to ABAP
    Reward points..

  • The performance of ABAP programs

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

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

  • How to check frequency of ABAP program usage

    Dear Experts,
    How to find out the frequency of ABAP programs executed by users? the reason is because we want to do a housekeeping on all the ABAP reports that we have developed over the years, we want to deactivate those reports that are no longer executed by the user within 1 year. Anyone can give suggestion?
    I already tried using SM36, but this is only for those programs scheduled in background or immediate, how about those programs running on foreground?

    Hello,
    You can use the trxn SM20N. But bear in mind some prior config needs to be in place for the logging to be active (trxn SM19).
    For further details on SM20 read this: [Security Audit Log|http://help.sap.com/SAPhelp_nw70/helpdata/en/2c/c59d37d373243de10000009b38f8cf/frameset.htm]
    @Sap Fan: STAD can be used in case the audit log is not available (e.g., due to missing config) but afaik there is a limitation on the date range you can provide.
    BR,
    Suhas
    Edited by: Suhas Saha on Sep 7, 2010 9:39 AM

Maybe you are looking for