ABAP Program or transaction for hard workload testing

Hello ABAPers,
in my actual client we have the need of creating an error of memory overflow or Database workload overflow.
I think I once saw an standar program that replicates this kind of overflows. But I can´t remember or find this program.
May be it´s all my imagination, but I´m pretty sure there was a program/transaction/function module that could help me with this issue.
If anybody knows of anything about this, please answer this post.
Thank you very much and kind regards
Ibai Ramirez

Hi,
I will not recommanded to increase the size. If your using the ECC 6.0 it allow default size upto 4GB and before that upto 2 GB.
You can check it with using the transaction ST22 for dump analysis and observe the program name and check it is standard program or customer program ( i.e. Start from y or z ). if it standard program then write to SAP and if it is customer program it read more data then read the data in batches, process data and after processing unwanted internal table you have to refresh.
For analysis of the program you can used SE30 - Program runtime analysis, ST05-SQL analysis, ST12-Perticular transaction analysis and STAD.

Similar Messages

ABAP program to search for FM/User-Exit lookups

Hi everyone,
I have a need to find any and all Function Modules and User Exits that may have been written in BW that are used to do a lookup of data from one InfoProvider to another.   I have found the following program from Lijo John which works for Update Rules and Transfer Rules but I need the same type program that digs into Function Modules, DTP's and any other User-Exit type code where a lookup could be performed.   These are noted as the limitations in the program Lijo John created and I was hoping maybe someone has a solution for these as well.
https://www.sdn.sap.com/irj/scn/wiki?path=/display/bi/abapprogramtofindBIlookupsandcodePatterns
If someone has a program that they could share that would do this it would be greatly appreciated.
Thank you,
Dave

Thank you Ashish. This was somewhat helpful.   I guess if there isn't an ABAP program available like I need then the next best thing would be for me to know the BW table names that holds the actual Function Module and DTP source code so that I can then create my own ABAP program that would query them for the existence of the InfoProvider name anywhere in the code.
The goal with all of this is to find ANY lookup from ANYWHERE in BW for a specific InfoProvider so that we will know what will have to be "disconnected" if we decide to get ride of that specific InfoProvider.
So, if anyone can tell me the tables that contain the BW Function Module and DTP ABAP source code I would appreciate it.
Thank you,
Dave

ABAP program and FB for value mapping replication

Hi,
we are using a 40B system and I want to use the value mapping replication in XI. To refill the data into the XI database I must write an ABAP and a function module to transfer the data out of R/3 into XI (via RFC). Has anybody an example how the program (and the FB) must look like? i.e I want to read table mvke and extract the materialnumber and the prodhierarchy.
Thanks and best regards
Arnold

Hi Arnold,
First you need a table type with a structure like follows:
operation
groupid
context
identifier
agency
scheme
(corresponding to the Interface ValueMappingReplication)
All used data elements should have type string or charXX
for example: operation - char10, groupid - char32, rest - char120
Next you create a function module with attribute 'remote-enabled module'.
The import parameter is your new table structure.
Next you create an ABAP program. Here an example:
report z_value_mapping .
tables mvke.
data:
p_value_mapping type zvalue_mapping,
p_value_mapping_table type zvalue_mapping_table.
p_value_mapping-operation = 'Insert'.
p_value_mapping-context = 'http://xi.com/Material'.
select * from mvke where matnr between '170' and '501'.
check not mvke-prodh is initial.
* Create a value mapping group to join two entries.
* use a unique 32 digit number.
concatenate '00000000000000' mvke-prodh into p_value_mapping-groupid.
translate p_value_mapping-groupid using ' 0'.
* Store the mapping source as first entry to the group
p_value_mapping-identifier = mvke-matnr.
p_value_mapping-agency = 'SenderAgency'.
p_value_mapping-scheme = 'MATNR'.
append p_value_mapping to p_value_mapping_table.
* Store the mapping target as second entry to the group
p_value_mapping-identifier = mvke-prodh.
p_value_mapping-agency = 'ReceiverAgency'.
p_value_mapping-scheme = 'PRODH'.
append p_value_mapping to p_value_mapping_table.
endselect.
* Push data to XI
call function 'Z_VALUE_MAPPING' in background task
destination 'IS_XID'
exporting
value_mapping = p_value_mapping_table.
commit work.
Import the RFC to the Integration Builder, create a mapping between your RFC and the interface ValueMappingReplication.
Check this Blog for additional steps:
/people/sreekanth.babu2/blog/2005/02/23/value-mapping-replication
Choose names for context, agency and scheme which are useful your scenario.
Regards
Stefan

Crystal Report on SAP R/3 ABAP Program or Transaction Code

Hi Experts,
I am working on SAP BI, my current requirement is to develop a dashboard. Client given the list of reports and they want to see these reports as a dashboard in BO. All these reports are SAP R/3 ABAP Programs. My doubt here is, is it possible to connect directly or bring directly a ABAP program in crystal reports. I know that form crystal reports we can connect to SAP R/3 through SAP Table, Cluster , Function Modules and so on.
Anyone please clarify this doubt.
Thanks & Regards
Ramakrishna Kamurthy

Moving to Integration kits forum: Questions re: Crystal Reports/Enterprise to SAP Integration Kit - SAP

How much ABAP programming is required for a typical SRM install?

I was wondering if there is a document that defines best practices for the use of ABAP with the installation and customization of SRM. Such as amount of ABAP coding typically required, and best practices around the use of ABAP for customization and configuration.
Thanks.

You may need following developments...
- Validations for data with SRM Data or with ECC Data at BBP_DOC_CHECK_BADI
- Changes to the Data in SRM at Document Creation / Change BBP_DOC_CHANGE_BADI
- Based on your Purchsing Contract Settings in Backend you may need some Enhancements.
<like mapping SRM conditions to ECC, creating consignment or subcontracting Contracts e.t.c>
- Most importantly customization of workflows.
- If your Buyers has any specific Requirement to be validated or evaluate then you should go for SOCO Custom rules.
- You can group multiple Requirements (SC) into one Purchase Order.
ABAP is required at the time of standard issues with SRM5.0, to debug and find which note to apply -- I believe this is a critical part where an abaper can help in SRM instalation.
All the best,
Vamsi

ABAP programming in BW for past date calculation

Dear BWGurus,
the requirement in BW is to calculate past date depending on number of months entered by user.
1. is there any FM available in BW .
2. I have tried fo FM 'CCM_GO_BACK_MONTHS' but it is not available in BW.
3. will this logic work properly.
DATA : l_mon(2) TYPE n,
       l_days(1000) TYPE n,
       l_udate LIKE SY-DATUM,
       l_frmdate LIKE SY-DATUM.
get number of days from months
GETTING THE FROM DATE
l_frmdate = l_udate - l_days.
4. is it possible in BW to debug the userexit for
with regards,
Rajesh c

Hi,
This FM is available in BI7, but Iam not sure abt 3.x....if it is not available in 3.X find the below logic in FM:
FUNCTION SEPA_MANDATE_ADD_MONTH_TO_DATE.
""Lokale Schnittstelle:
*" IMPORTING
*"     VALUE(MONTHS)
*"     VALUE(OLDDATE) LIKE SY-DATUM
*" EXPORTING
*"     VALUE(NEWDATE) LIKE SY-DATUM
DATA:       BEGIN OF DAT,
              JJJJ(4) ,
              MM(2) ,
              TT(2) ,
              END OF DAT,
              BEGIN OF HDAT,
              JJJJ(4) ,
              MM(2) ,
              TT(2) ,
              END OF HDAT,
              NEWMM TYPE P,
              DIFFJJJJ TYPE P.
WRITE: OLDDATE+0(4) TO DAT-JJJJ,
          OLDDATE+4(2) TO DAT-MM,
          OLDDATE+6(2) TO DAT-TT.
DIFFJJJJ =   ( DAT-MM + MONTHS - 1 ) DIV 12.
NEWMM    =   ( DAT-MM + MONTHS - 1 ) MOD 12 + 1.
DAT-JJJJ = DAT-JJJJ + DIFFJJJJ.
IF NEWMM < 10.
    WRITE '0' TO DAT-MM+0(1).
    WRITE NEWMM TO DAT-MM+1(1).
ELSE.
    WRITE NEWMM TO DAT-MM.
ENDIF.
IF DAT-TT > '28'.
    HDAT-TT = '01'.
    NEWMM   = ( DAT-MM ) MOD 12 + 1.
    HDAT-JJJJ = DAT-JJJJ + ( ( DAT-MM ) DIV 12 ).
    IF NEWMM < 10.
      WRITE '0' TO HDAT-MM+0(1).
      WRITE NEWMM TO HDAT-MM+1(1).
    ELSE.
      WRITE NEWMM TO HDAT-MM.
    ENDIF.
    IF DAT-TT = '31'.
      NEWDATE = HDAT.
      NEWDATE = NEWDATE - 1.
    ELSE.
      IF DAT-MM = '02'.
        NEWDATE = HDAT.
        NEWDATE = NEWDATE - 1.
      ELSE.
        NEWDATE = DAT.
      ENDIF.
    ENDIF.
ELSE.
    NEWDATE = DAT.
ENDIF.
ENDFUNCTION.

How to make an ABAP program run for a specified number of times ?

assalamoalikum all!!!
Can some 1 plz tell me that How can I make my ABAP program run ONLY for 2 times (after it went in production etc)
AND when the program runs for 2 times It then gets hanged/Locked foreever.
Suppose my program is:
REPORT twice002.
write ' I will run only twice bye bye'.

Well, I guess the only full proof way is to create a custom "Z" table which will hold the counter, in your program you would update this table every time the program runs. In this same program before updating the counter, you would retrieve the counter and check if it is = 2, if so, then write a message and RETURN.
Regards,
Rich Heilman

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 FRSs.
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> WHEREfor 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.

File to File and then Call ABAP Program and pass file name and location

Hi
I am new to PI and am working on the following requirement and some guidance would help:
A file is picked up from a third party server using FTP and is put in an SAP server in a specific location. After I have put in the file successfully, I need to call an ABAP program and provide the name and location of the file for further processing by the ABAP program.
Although I am familiar with File to File, how can I add in the ABAP call with the filename and location? I do not want to pass any other information to the ABAP program.
Thanks for your help.
Manoj

I think I get what you're saying. This additional file would have the file and the path in it's content. I would then use this as a source (FCC?) for Mapping with the RFC. Right?
Exactly and yes, FCC would be helpful
Would you have a sample OS script to do the above?
Actually it depends on the operating system on which your PI system is standing. For instance for Windows, you might try with the following as a start point (but I was not able to test it, so I can't guarantee it will do the job):
cmd.exe /C "%f %F > C:\target_directory\%DATE%_%TIME%.txt"
In case you needed more, try googling on "windows batch script" or similar.
Hope this helps,
Greg

Calling BSP from abap program by interfacing EP

Dear Friends...
I am cslling a BSP... from an ABAP program... for that I have used this class and also a function module to ckeck.. actually from the abap program it invoks the BSP page very nicely and as my logic for invoking the BSP is a part of the Business Object and it is associated with the Enterprise portal so... when i reach the ep and trigger that business object to instantiate the BSP page from my calling logic of abap... it goes to the ITS and port 80 or something and didnt produce the BSP.. and only the blank screen was there...kindly help me how i am supposed to instantiate the BSP from properly from ABAP by interfacing the EP... my code is given below...
data :
lv_url type string.
concatenate
'http://sapdevbp.sbic.co.za:8041/sap(bD1lbiZjPTIwMA==)'
'/bc/bsp/sap/z_updatemng/bp.htm?bpid=' object-key-businesspartnerid
into lv_url.
call method cl_gui_frontend_services=>execute
exporting
document = lv_url
exceptions
others = 1.
please help....
me...
regards
Naim

hi ,
you can try using FM CALL_BROWSER in your report(ABAP code)to call bsp,like
data url(200) type c.
url = 'http://<server>.<domain><port>:'.
concatenate url '/sap/bc/bsp/sap/' into url.
concatenate url 'your_bsp_app_name/your_start_page.bsp' into url.
concatenate url '?sap-user=<userid>' into url.
concatenate url '&sap-password=<passowrd>' into url.
CALL FUNCTION 'CALL_BROWSER'
EXPORTING
    URL                          = url
   WINDOW_NAME                  = ' '
   NEW_WINDOW                   = ' '
   BROWSER_TYPE                 =
   CONTEXTSTRING                =
EXCEPTIONS
   FRONTEND_NOT_SUPPORTED       = 1
   FRONTEND_ERROR               = 2
   PROG_NOT_FOUND               = 3
   NO_BATCH                     = 4
   UNSPECIFIED_ERROR            = 5
   OTHERS                       = 6
IF SY-SUBRC <> 0.
MESSAGE ID SY-MSGID TYPE SY-MSGTY NUMBER SY-MSGNO
        WITH SY-MSGV1 SY-MSGV2 SY-MSGV3 SY-MSGV4.
ENDIF.
For this to work you have to enable SSO on your server.
you can check if it is enabled or not by runnning the BSP application "SYSTEM" ,page "SSO2TEST.htm" .
Follow the instructions on the page for testing.
This may not be a great way as your userid password are passed via URL,still it works
Cheers!

Finding User Exists in an ABAP program

**How to findout where there is an exit are there in the ABAP Programs.
Thankyou for your time in giving the answers.
Bhaskar.

use cmod /smod transaction..
below is demo code to find BADI n user exits for a transaction ( u can go to se93 and create a transaction for ur report program) and then execute this piece of code -
reward if helpfull
TABLES : TSTC,
TADIR,
MODSAPT,
MODACT,
TRDIR,
TFDIR,
ENLFDIR,
SXS_ATTRT ,
TSTCT.
DATA : JTAB LIKE TADIR OCCURS 0 WITH HEADER LINE.
DATA : FIELD1(30).
DATA : V_DEVCLASS LIKE TADIR-DEVCLASS.
PARAMETERS : P_TCODE LIKE TSTC-TCODE,
P_PGMNA LIKE TSTC-PGMNA .
DATA wa_tadir type tadir.
START-OF-SELECTION.
IF NOT P_TCODE IS INITIAL.
SELECT SINGLE * FROM TSTC WHERE TCODE EQ P_TCODE.
ELSEIF NOT P_PGMNA IS INITIAL.
TSTC-PGMNA = P_PGMNA.
ENDIF.
IF SY-SUBRC EQ 0.
SELECT SINGLE * FROM TADIR
WHERE PGMID = 'R3TR'
AND OBJECT = 'PROG'
AND OBJ_NAME = TSTC-PGMNA.
MOVE : TADIR-DEVCLASS TO V_DEVCLASS.
IF SY-SUBRC NE 0.
SELECT SINGLE * FROM TRDIR
WHERE NAME = TSTC-PGMNA.
IF TRDIR-SUBC EQ 'F'.
SELECT SINGLE * FROM TFDIR
WHERE PNAME = TSTC-PGMNA.
SELECT SINGLE * FROM ENLFDIR
WHERE FUNCNAME = TFDIR-FUNCNAME.
SELECT SINGLE * FROM TADIR
WHERE PGMID = 'R3TR'
AND OBJECT = 'FUGR'
AND OBJ_NAME EQ ENLFDIR-AREA.
MOVE : TADIR-DEVCLASS TO V_DEVCLASS.
ENDIF.
ENDIF.
SELECT * FROM TADIR INTO TABLE JTAB
WHERE PGMID = 'R3TR'
AND OBJECT in ('SMOD', 'SXSD')
AND DEVCLASS = V_DEVCLASS.
SELECT SINGLE * FROM TSTCT
WHERE SPRSL EQ SY-LANGU
AND TCODE EQ P_TCODE.
FORMAT COLOR COL_POSITIVE INTENSIFIED OFF.
WRITE:/(19) 'Transaction Code - ',
20(20) P_TCODE,
45(50) TSTCT-TTEXT.
SKIP.
IF NOT JTAB[] IS INITIAL.
WRITE:/(105) SY-ULINE.
FORMAT COLOR COL_HEADING INTENSIFIED ON.
Sorting the internal Table
sort jtab by OBJECT.
data : wf_txt(60) type c,
wf_smod type i ,
wf_badi type i ,
wf_object2(30) type C.
clear : wf_smod, wf_badi , wf_object2.
Get the total SMOD.
LOOP AT JTAB into wa_tadir.
at first.
FORMAT COLOR COL_HEADING INTENSIFIED ON.
WRITE:/1 SY-VLINE,
2 'Enhancement/ Business Add-in',
41 SY-VLINE ,
42 'Description',
105 SY-VLINE.
WRITE:/(105) SY-ULINE.
endat.
clear wf_txt.
at new object.
if wa_tadir-object = 'SMOD'.
wf_object2 = 'Enhancement' .
elseif wa_tadir-object = 'SXSD'.
wf_object2 = ' Business Add-in'.
endif.
FORMAT COLOR COL_GROUP INTENSIFIED ON.
WRITE:/1 SY-VLINE,
2 wf_object2,
105 SY-VLINE.
endat.
case wa_tadir-object.
when 'SMOD'.
wf_smod = wf_smod + 1.
SELECT SINGLE MODTEXT into wf_txt
FROM MODSAPT
WHERE SPRSL = SY-LANGU
AND NAME = wa_tadir-OBJ_NAME.
FORMAT COLOR COL_NORMAL INTENSIFIED OFF.
when 'SXSD'.
For BADis
wf_badi = wf_badi + 1 .
select single TEXT into wf_txt
from SXS_ATTRT
where sprsl = sy-langu
and EXIT_NAME = wa_tadir-OBJ_NAME.
FORMAT COLOR COL_NORMAL INTENSIFIED ON.
endcase.
WRITE:/1 SY-VLINE,
2 wa_tadir-OBJ_NAME hotspot on,
41 SY-VLINE ,
42 wf_txt,
105 SY-VLINE.
AT END OF object.
write : /(105) sy-ULINE.
ENDAT.
ENDLOOP.
WRITE:/(105) SY-ULINE.
SKIP.
FORMAT COLOR COL_TOTAL INTENSIFIED ON.
WRITE:/ 'No.of Exits:' , wf_smod.
WRITE:/ 'No.of BADis:' , wf_badi.
ELSE.
FORMAT COLOR COL_NEGATIVE INTENSIFIED ON.
WRITE:/(105) 'No userexits or BADis exist'.
ENDIF.
ELSE.
FORMAT COLOR COL_NEGATIVE INTENSIFIED ON.
WRITE:/(105) 'Transaction does not exist'.
ENDIF.
AT LINE-SELECTION.
data : wf_object type tadir-object.
clear wf_object.
GET CURSOR FIELD FIELD1.
CHECK FIELD1(8) EQ 'WA_TADIR'.
read table jtab with key obj_name = sy-lisel+1(20).
move jtab-object to wf_object.
case wf_object.
when 'SMOD'.
SET PARAMETER ID 'MON' FIELD SY-LISEL+1(10).
CALL TRANSACTION 'SMOD' AND SKIP FIRST SCREEN.
when 'SXSD'.
SET PARAMETER ID 'EXN' FIELD SY-LISEL+1(20).
CALL TRANSACTION 'SE1 ' AND SKIP FIRST SCREEN.
endcase.

ABAP program to load an infocube

Hello All,
I am new to BW and have learnt the basic concepts only. I now have to write an ABAP program to load one of the infocube after receiving the data in the form of a flat file from an external system. Any ideas on how I can go about this will be greatly appreciated and rewarded! Thanks in advance.
Regards
Veena

Hi,
I guess you can try to raise an event to trigger the PC or IP to load the cube.
You should raise the event through your ABAP code and schedule the PC or IP to run once this event is raised.
Create event in tcode SM62
Use FM: BP_EVENT_RAISE to raise an event
Use after event in the start variant of the process chain.
You create user events in SM62. In SM62, next to "User even names", click on Maintain and press Enter. Click on the Create icon to create a new event (let's call it ZEVENT).
Next, in your process chain, change the Start variant to be scheduled "After event", and put in ZEVENT for the event name. Also, click on the "Periodic job" at the bottom. This will automatically reschedule the jobs for the process chain after it executes.
Next, create an ABAP program (let's call it Z_EVENT_RAISE) to call the function module BP_EVENT_RAISE. You're code can look like this:
codeREPORT Z_EVENT_RAISE.
PARAMETERS: P_EVENT LIKE TBTCO-EVENTID.
CALL FUNCTION 'BP_EVENT_RAISE'
EXPORTING
EVENTID = P_EVENT.
IF sy-subrc 0.
MESSAGE ID SY-MSGID TYPE SY-MSGTY NUMBER SY-MSGNO
WITH SY-MSGV1 SY-MSGV2 SY-MSGV3 SY-MSGV4.
ENDIF.[/code]
This ABAP program will prompt for an event name, so you will need to create a variant (let's call it ZEVENT) which will save the value of the event name (also ZEVENT). You will need the variant name to be able to trigger the event in a batch job.
Now all you need is the batch job. Use tcode SM36 to create a batch job where you call the ABAP program (Z_EVENT_RAISE) using the variant (ZEVENT).
Raise an event to trigger process chain in BI
http://sapbwneelam.blogspot.com/2007/09/how-to-start-process-chain-through.html
how do we raise an event to trigger process chain in BI
Hope this helps.
Thanks,
JituK

TCode for abap program performance testing

Hi
I have tuned a abap program which was consuming lot of time. I still have the old version with diff name. I would like to know the tcodes where in i could see the performance of the program.
regards
Balaji

Hi balaji,
This is kiran Kumar.G.I will give some steps.you better to follow those steps to get ur report performance.
If u r satisfy with my answer give me REWARD POINTS.
            HAVE A NICE DAY.
STEPS:
1.OPEN UR REPORT IN SE38 TRANSACTION.
2.SELECT THE MENU PATH
UTILITIES-->MORE UTILITIES-->RUNTIME ANALYSIS
3.SELECT THE PROGRAM RADIO BUTTON AND GIVE UR REPORT NAME THERE.AND CLICK <b>EXECUTE</b> BUTTON
4.IT WILL TAKE U TO ANOTHER SCREEN THERE U CAN EXECUTE UR REPORT AND COME BACK.
5.CLICK ON ANALYZE BUTTON.(PRESENT IN BELOW OF THE SCREEN).
THEN U WILL GET ONE GRAPH
NOTE:
1.IF IT IS RED UR PROGRAM IS HAVING VERY POOR PERFORMANCE
2.IF IT IS GREEN IT IS OK.
ABAP GRAPH : TELLS UR CODING IN THE REPORT.
DATABASE GRAPH : U R RETREIVE DATA FROM DATABASE IN UR REPORT..
SOME STEPS USED TO IMPROVE UR PERFORMANCE:
1.     Avoid using SELECT...ENDSELECT... construct and use SELECT ... INTO TABLE.
2.     Use WHERE clause in your SELECT statement to restrict the volume of data retrieved.
3.     Design your Query to Use as much index fields as possible from left to right in your WHERE statement
4.     Use FOR ALL ENTRIES in your SELECT statement to retrieve the matching records at one shot.
5.     Avoid using nested SELECT statement, SELECT within LOOPs.
6.     Avoid using INTO CORRESPONDING FIELDS OF TABLE. Instead use INTO TABLE.
7.     Avoid using SELECT * and Select only the required fields from the table.
8.     Avoid nested loops when working with large internal tables.
9.     Use assign instead of into in LOOPs for table types with large work areas
10.     When in doubt call transaction SE30 and use the examples and check your code
11.     Whenever using READ TABLE use BINARY SEARCH addition to speed up the search. Be sure to sort the internal table before binary search. This is a general thumb rule but typically if you are sure that the data in internal table is less than 200 entries you need not do SORT and use BINARY SEARCH since this is an overhead in performance.
12.     Use "CHECK" instead of IF/ENDIF whenever possible.
13.     Use "CASE" instead of IF/ENDIF whenever possible.
14.     Use "MOVE" with individual variable/field moves instead of "MOVE-
CORRESPONDING", creates more coding but is more effcient.
Regards,
Kiran Kumar.G

R3 environment for test my abap programs

Hi forum:
I download the Sneak Preview Download Full ABAP Edition Trial, but i just want to test with simple abap programs for practice this language, but don´t know i can do it with this tool, because i think that this software it´s only for programing with ABAP WebDynpro, if this is true, is there some free server in Internet to practice my programming with simple ABAP?
thnks
Josue

Hi,
If you want to learn ABAP properly, go through a book called as ABAP OBJECTS. Its a very good book. Along with book, you will get miniSAP CD's on which you can practice your ABAP programs.
Reward points if the answer is helpful.
Regards,
Mukul

How to create a job thru ABAP program for calling a program with variant???

Hello experts,
can u give me step wise procedure to create jobs for a program with a variant name thru ABAP???
Also, can a transaction can be scheduled as a job to run in background with a variant name???
Edited by: SAP USER on Jul 22, 2008 6:08 AM

Hi,
To create a job through ABAP program you can do the following.
Go to Menu bar.
In there, go to SYTSTEM> SERVICES> JOBS--> DEFINE JOB.
Then give the JOB NAME and CLASS in the screen that comes up.
This is how we schedule a program.
Now, to create a variant for a program -
First activate your program in SE38. Then execute it .
Now, click on SAVE button. It will open up the variant creation screen. Give the details there like variant name and value for the fields. Save and come back.
Hope this helps.
Regards,
Hari Kiran

ABAP Program or transaction for hard workload testing

Similar Messages

Maybe you are looking for