Archive for June 2013
5 Basic Things in ABAP Programming
Basic things in ABAP with example
Arithmetic expressions in ABAP
In ABAP you
can program the following valid arithmetic expressions,
·
+
Addition
·
-
Subtraction
·
* Multiplication
·
/ Division
·
**
Exponentiation
·
DIV
Integral division without
remainder
·
MOD
Remainder after integral
division
Parameters
In our
previous program we have written a set of commands for the arithmetic
operations but the input to the variables where hardcoded in the program
itself, now what if the user wants to enter the value during runtime?
What if he
wants to enter different values each time?
So, we have
to write a program which asks input from the user and gives the output.
To get
input from user we should use the abap keyword ‘PARAMETERS’.
Ex:
PARAMETERS:
input1 type I,
input2 type I.
The variable Result should not be
defined in parameters because we are not going to get an input to the variable
result. (Therefore result should be defined by ‘DATA’)
Data types in abap
Data types
A data
type or simply type is a classification for identifying
types of data, such as integer, numeric,
character etc. that determines the possible values for that type; the
operations that can be done on values of that type; the meaning of the data;
and the way values of that type can be stored.
Here in abap we can classify them into two
groups.
·
Complete ABAP standard
types ( length will be fixed except string and xstring)
·
Incomplete ABAP
standard types
Complete types:
·
D
Type for date (D), format YYYYMMDD, LENGTH
8
·
T
Type for time (T), format HHMMSS, LENGTH
6
·
I
Type for integer (I), LENGTH 4
·
F
Type for floating point number (F), LENGTH 8
·
String
Type for dynamic length character string
·
Xstring
Type for dynamic length byte sequence
(HeXadecimal string)
Incomplete types:
·
C
Type for character
string, length should be specified.
·
N
Type for numerical
character, length should be specified.
·
X
Type for byte sequence,
length should be specified.
·
P
Type for packed number,
length should be specified as well as decimal points should be specified.
So with these data types the user
can define a variable in the program, (as how we used Integer in our program)
Conditional branches and logical expressions
In ABAP you
have two ways to execute different sequences of statements.
·
IF
·
CASE
IF-statement
|
CASE-statement
|
IF input1 > 0
Statements
ELSEIF input1 < 0
Statements
ELSEIF input1 = 0
Statements
ENDIF.
|
CASE input1.
When
‘0’.
Statements
When
‘100’
Statements
When
‘200’
Statements
ENDCASE.
|
As we know about the IF-statement and
CASE-statement lets update our previous program (arithmetic calculation) using
these conditional statements.
As you can
see the keyword ‘PARAMETERS’ is used for getting input from user, we are
getting three inputs from the user.
1. Operand1 (input1)
2. Operand2 (input2)
3. The operators ( ‘+’ ‘-’ ‘*’ ‘/’)
And the
output is stored in the variable ‘RESULT’ which is defined by the ‘DATA’
keyword.
Next comes
the conditional operator,
IF-statement:
It checks whether the value in variable
‘SYMBOL’ is one of the symbols described there.
If the
symbol is any of these ‘+, - , *, /’ it comes to the next statement (i.e.
CASE-statement) or else it executes the ‘ELSE’ part.
CASE-statement:
Depending
upon the symbol the case statement is executed i.e. when the symbol is ‘+’ it
executes the addition and when the symbol contains the value ‘-‘ the operation
subtraction is performed.
Whenever an
operation is performed the result is stored in the variable ‘RESULT’, and at
the end of the CASE-statement we are printing the result in the screen.
Now, come
back to the IF-statement (line 16).
If the
symbol contains value which is not defined there, it comes to the ELSE part.
The ELSE
part contains the code for writing an error ‘symbol is not defined in the
program’.
In line 16
the Relational operator OR is described after every condition.
See how the
compiler reads the program.
Line16 -> Checks whether the value in symbol is
‘+’ OR‘-‘ OR‘*’ OR ‘/’ .
(If the
value in symbol is any of the following above Line18 is executed or else Line 30 is executed)
Do you know :
·
Always give preference in using CASE-statements
than IF-statements because it’s
more transparent and performs better.
·
Always provide space between parentheses and operators since they are
ABAP keywords
|
Wednesday, June 12, 2013
Posted by Unknown
Sample ABAP Program
Getting Hands Dirty : ABAP-EDITOR
I
would like to remind a few things,
- The one we would be interacting is ‘PRESENTATION LAYER’;
- Your server is the ‘APPLICATION LAYER’ and finally
- The ‘DATABASE’.
And
in SAP-ABAP, SQL commands can be used; we can have NATIVE SQL or OPEN SQL. But
will go with OPEN SQL.
------------------------------------------------------------------------------------------------------------
The
one you are seeing above is the screen when you log-in to SAP from your desktop
or PC
<the screen above is the presentation layer>
On
top of the window are the menus, below the menu there is a text box with a
green tick, here is where we should enter the ‘TRANSACTION CODE’.
Here
are some are some commonly used transaction code.
TRANSACTION CODE
|
DESCRIPTION
|
SE80
|
OBJECT
NAVIGATOR
|
SE38
|
ABAP
EDITOR
|
SE37
|
ABAP
FUNCTION MODULES
|
SE24
|
CLASS
BUILDER
|
SE11
|
ABAP
DICTIONARY
|
SE51
|
SCREEN
PAINTER
|
SMARTFORMS
|
SAP
SMART FORMS
|
So,
first let’s have a sample report program.
Go
to Transaction -> SE80 -> REPOSITRY BROWSER -> <in the drop down choose> PROGRAM -> <below the drop down enter the program name> ZSAMPLE and press ENTER.
screen 1.1
A
popup will appear as above conforming to create a program, click YES.
Un Check the TOP INCL <if you check it will include a ‘TOP INCLUDE in your program>
and 'enter'.
screen 1.2
screen 1.3
It will ask for package, for now save it as local object.
It will ask for package, for now save it as local object.
Finally your program editor will be opened.
Now, we are going to write a program to do all
the arithmetic operations.
I have given all the definitions on the program itself as comments.
Comments can be given by following ‘*’ or ' “ ' symbol.
The first part is to define variables;
We are having three variables in our program, input1, input2 and result.
All of the variables are integer format.
To define a variable in SAP you have to write a keyword “DATA”.
If you have multiple variables to be defined use the keyword “DATA” followed by “:“ and at the end of the type use ‘,’ (comma) instead of ‘.’ (Full stop) and when final variable
is declared use “.”.
And now the arithmetic operations take place,
the result is stored in the variable result.To display the result,we should use
a keyword “WRITE” similar to cout and printf in c and c++..CLEAR keyword clears
the memory of the variable next to it, so after that the variable will not be
holding any values.
Remember,
|
Saturday, June 1, 2013
Posted by Unknown
SAP ABAP - A Brief Introduction to Reports and Module Pool Programming
Getting Started: SAP-ABAP
Just a few steps ahead before we get our hands
dirty. It’s necessary to know the concept and other technical related things in
ABAP.
ABAP stands for Advanced Business Application Programming.
It’s a programming language
similar to COBAL and the programs we do will not be stored as a separate
external file like JAVA/C++ programs. All ABAP programs reside inside the SAP database.
As
in other programming languages, an ABAP program is either an executable unit or
a library, which provides reusable code to other programs and is not
independently executable.
ABAP
distinguishes two types of executable programs:
·
Reports ( Can be
executed directly )
·
Module pools (
They can be executed only via a ‘TRANSACTION CODE’ )
REPORTS:
Example:
You have created
a report program which gives the employee id of all the employees in your
company filtered by some parameter (take department code as parameter).so
when you execute the program it will ask for department code and gives the
result.
|
MODULE POOL:
Module pools are used to get data from the user and
store in the SAP database as well as to display them
from the database. They contain user defined screens designed using screen
painter. (Remember whenever we create screens in module pool program we have to
name them in numbers, and so we should not name our screens as ‘1000’ because
its SAP’s standard screen is ‘1000’, which it uses in report
programming and selection screens. Each screen has its own flow logic, which is
divided into a "PBO" (Process before Output) and "PAI"
(Process after Input) section. The term “dynpro” (dynamic program) refers to
the combination of the screen and its flow logic.
After all your
programming you can’t directly execute a module pool program, you have to
create a ‘TRANSACTION CODE’.
What is a transaction code?
Transaction
code is a short cut key attached to a screen. It should have only numbers and
characters (ztcode or zt42).for example if you create a transaction code for
your program, and enter the transaction code the program will be executed and
the corresponding screen will be called.
To
make it clear and easier lets have an example,
Example:
<don’t worry about the programming
logic, just try to understand this example, we shall see the programming
logic later>
You have created
a program that first requires a validation (i.e. you have to enter your
user_name and password) and then you will be redirected to your screen where
you will have all the details of you salary, expense and all.
(to make get the
point)
So, here we have
to create two screens,
Assume Screen no.
2000 for validating the user_name and password.
Screen no. 2001
for details of salary, expense.
Now create a
transaction code, eg; zuser01
Now, when you
enter the transaction code this the magic that happens, J
|
|
So, from this you
will have clear that PBO Executes before the screen and PAI loads after
receiving an input from the user.
So we will have a
command like this in PAI.
**********************************************
PAI of screen
2000.
When ‘SUBMIT’ <when submit button
is clicked>
Call screen 2001. <the next screen is called>
**********************************************
The next PBO of
screen 2001 loads and the screen will be displayed
<remember this
is just for you to understand module pool program and the events (PAI &
PBO) in them, and programming concepts will be explained later>
|
OK, now come back
to the point so far we have seen executable programs in SAP ABAP. Now we shall
have a little explanation for non-executable programs.
Include modules: An INCLUDE module
gets included at generation time into the calling unit; it is often used to
subdivide very large programs.
Example:
INCLUDE zemployee.
<here zemployee is the include, when the compiler comes here, it
executes all the commands inside zemployee>
|
Subroutine pools: Subroutine pools contain blocks of code enclosed by FORM /ENDFORM
statements and invoked with PERFORM.
Example:
PERFORM zemployee.
When the compiler comes into the above line, the commands or programs
inside the subroutine zemployee will be executed <i.e. the commands within
FORM and ENDFORM of the subroutine name, here ‘zemployee’>
FORM zemployee
ENDFORM
|
Function groups: Function groups are libraries of
self-contained function modules enclosed
by FUNCTION / END FUNCTION and invoked with CALL FUNCTION.
Object classes and
Interfaces: Object
classes and interfaces are similar to Java classes and interfaces; the first
define a set of methods and attributes, the second contain
"empty" method definitions, for which any class implementing the interface
must provide explicit code.
Type pools: Type pools define collections of data
types and constants.
<for the last three, giving
examples will make you confuse, when we get our hands dirty we shall have a
clear look on those types>
Posted by Unknown