Abap program standards

[Former Member]

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.

[Former Member]

Hi

In each orgn there will be a std programming stds that should be followed by all the developers.

It may vary from orgn to orgn.

It mostly contains the Naming conventions for the different Objects used in the Program, and the Standards of Code, like whether to use Nested Selects, Loops

conditions like IF..else.endif..case and endcase..

some of them are:

1) Dont use nested seelct statement

2) If possible use for all entries in addition

3) In the where addition make sure you give all the primary key

4) Use Index for the selection criteria.

5) You can also use inner joins

6) You can try to put the data from the first select statement into an Itab and then in order to select the data from the second table use for all entries in.

7) Use the runtime analysis SE30 and SQL Trace (ST05) to identify the performance and also to identify where the load is heavy, so that you can change the code accordingly

Reward points if useful

Regards

Anji

[Former Member]

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.

[Former Member]

hi,

actually my requiremnet is we r developing a tool for checking all the coding standards of a report program for that first i need to design a flow chart for that standards, how to do it even for a few of them . [graphically presentation and if possible code for standard checking]

thanks & regards

suresh babu aluri.

[Former Member]

Hello Bhaskar,

Could you send me this document in digital format, please? If the format would be rtf or something like that, it will be fantastic. I am writting a naming convention document in my company, and this document could help me as template.

e-mail address: albertomgalindo@gmail.com

Thanks in advanced!

Regards!

[surjith_kumar]

Hi

Did you got in e-format, if not reply me,

I will send.

[Former Member]

make use of some of these fm's and statements

FM - PROGRAM_CHECK_FOR_TEXTS

NAMETAB_GET'

SCAN ABAP-SOURCE <source> KEYWORDS FROM <> STATEMENTS INTO <>

TOKENS INTO <>

WITH ANALYSIS.

• WITH COMMENTS .

READ TEXTPOOL <> INTO <> LANGUAGE sy-langu .

[Former Member]

answered