BC ABAP Programming PHẦN 1 pptx

BC ABAP Programming
Release 4.6B
HELP.BCABA
BC - ABAP Programming SAP AG
2 December 1999
Copyright
© Copyright 2001 SAP AG. All rights reserved.
No part of this publication may be reproduced or transmitted in any form or for any purpose
without the express permission of SAP AG. The information contained herein may be
changed without prior notice.
Some software products marketed by SAP AG and its distributors contain proprietary
software components of other software vendors.
Microsoft
®
, WINDOWS
®
, NT
®
, EXCEL
®
, Word
®
, PowerPoint
®
and SQL Server
®
are
registered trademarks of
Microsoft Corporation.
IBM
®

, DB2
®
, OS/2
®
, DB2/6000
®
, Parallel Sysplex
®
, MVS/ESA
®
, RS/6000
®
, AIX
®
, S/390
®
,
AS/400
®
, OS/390
®
, and OS/400
®
are registered trademarks of IBM Corporation.
ORACLE
®
is a registered trademark of ORACLE Corporation.
INFORMIX
®
-OnLine for SAP and Informix

®
Dynamic Server
TM
are registered trademarks of
Informix Software Incorporated.
UNIX
®
, X/Open
®
, OSF/1
®
, and Motif
®
are registered trademarks of the Open Group.
HTML, DHTML, XML, XHTML are trademarks or registered trademarks of W3C
®
, World
Wide Web Consortium,
Massachusetts Institute of Technology.
JAVA
®
is a registered trademark of Sun Microsystems, Inc.
JAVASCRIPT
®
is a registered trademark of Sun Microsystems, Inc., used under license for
technology invented and implemented by Netscape.
SAP, SAP Logo, R/2, RIVA, R/3, ABAP, SAP ArchiveLink, SAP Business Workflow,
WebFlow, SAP EarlyWatch, BAPI, SAPPHIRE, Management Cockpit, mySAP.com Logo
and mySAP.com are trademarks or registered trademarks of SAP AG in Germany and in
several other countries all over the world. All other products mentioned are trademarks or

registered trademarks of their respective companies.
SAP AG BC - ABAP Programming
December 1999 3
Icons
Icon Meaning
Caution
Example
Note
Recommendation
Syntax
Tip
BC - ABAP Programming SAP AG
4 December 1999
Contents
BC - ABAP Programming 17
Introduction to ABAP 19
The R/3 Basis System: Overview 20
Position of the Basis System Within the R/3 System 21
Application Servers 27
Work Processes 32
Overview of the Components of Application Programs 37
Structure of an Application Program 38
Screens 40
Structure of ABAP Programs 44
Processing Blocks in ABAP Programs 49
ABAP Statements 56
Logical Databases and Contexts 60
Memory Structures of an ABAP Program 66
Creating and Changing ABAP Programs 68
Opening a Program from the Repository Browser 70

Opening Programs in the ABAP Editor 73
Opening Programs Using Forward Navigation 74
Maintaining Program Attributes 75
Editing Programs 79
The ABAP Programming Language 82
ABAP Syntax 83
Types and Objects 87
Basic Statements 90
Data Types and Data Objects 91
Data Types 92
Defining Data Types 96
Predefined ABAP Types 97
Local Data Types in Programs 100
Data Types in the ABAP Dictionary 105
The TYPE Addition 113
The LIKE Addition 117
Data Objects 119
Literals 120
Text Symbols 122
Variables 124
Constants 130
Interface Work Areas 131
Predefined Data Objects 133
Compatibility 134
Determining the Attributes of Data Objects 136
Examples of Data Types and Objects 141
Processing Data 144
Assigning Values 145
SAP AG BC - ABAP Programming
December 1999 5

Assigning Values with MOVE 146
Assigning Values with WRITE TO 149
Resetting Values to Their Initial Value 151
Numerical Operations 152
Arithmetic Calculations 153
Mathematical Functions 157
Business Calculations 159
Date and Time Calculations 160
Processing Character Strings 162
Shifting Field Contents 163
Replacing Field Contents 166
Converting to Upper or Lower Case or Replacing Characters 168
Converting into a Sortable Format 169
Overlaying Character Fields 170
Finding Character Strings 171
Finding the Length of a Character String 174
Condensing Field Contents 175
Concatenating Character Strings 176
Splitting Character Strings 177
Assigning Parts of Character Strings 178
Single Bit Processing in Hexadecimal Fields 179
Setting and Reading Bits 180
Bit Operations 182
Set Operations Using Bit Sequences 184
Type Conversions 187
Conversion Rules for Elementary Data Types 188
Conversion Rules for References 192
Conversion Rules for Structures 193
Conversion Rules for Internal Tables 195
Alignment of Data Objects 196

Processing Sections of Strings 197
Field Symbols and Data References 201
Field Symbols 202
Defining Field Symbols 204
Assigning Data Objects to Field Symbols 208
Basic Form of the ASSIGN Statement 209
Assigning Components of Structures to a Field Symbol 214
Defining the Data Type of a Field Symbol 216
Data Areas for Field Symbols 218
Data References 220
Reference Variables 221
Creating Data Objects Dynamically 222
Getting References to Data Objects 223
Dereferencing Data References 224
Data References: Example 225
BC - ABAP Programming SAP AG
6 December 1999
Logical Expressions 226
Comparisons Between Different Data Types 227
Comparing Strings 231
Comparing Bit Sequences 234
Checking Whether a Field Belongs to a Range 236
Checking for the Initial Value 237
Checking Selection Criteria 238
Checking Whether a Field Symbol is Assigned 239
Combining Several Logical Expressions 240
Controlling the Program Flow 241
Branching Conditionally 243
Loops 246
Processing Large Volumes of Data 251

Internal tables 252
Creating Internal Tables 255
Internal table types 256
Internal table objects 260
Special Features of Standard Tables 262
Processing Internal Tables 264
Operations on Entire Internal Tables 265
Assigning Internal Tables 266
Initializing Internal Tables 268
Comparing Internal Tables 270
Sorting Internal Tables 272
Internal Tables as Interface Parameters 277
Determining the Attributes of Internal Tables 278
Operations on Individual Lines 279
Operations for all Table Types 282
Inserting Lines into Tables 283
Appending Summarized Lines 286
Reading Lines of Tables 288
Changing Lines 293
Deleting Lines 296
Processing Table Entries in Loops 300
Operations for Index Tables 307
Appending Table Lines 308
Inserting Lines Using the Index 312
Reading Lines Using the Index 315
Binary Search in Standard Tables 316
Finding Character Strings in Internal Tables 317
Changing Table Lines Using the Index 319
Deleting Lines Using the Index 322
Specifying the Index in Loops 325

Access Using Field Symbols 327
Using Header Lines as Work Areas 329
SAP AG BC - ABAP Programming
December 1999 7
Extracts 332
Defining an Extract 333
Filling an Extract with Data 335
Processing Extracts 337
Reading an Extract 338
Sorting an Extract 341
Processing Control Levels 344
Calculating Numbers and Totals 348
Formatting Data 351
Example of Formatted Data 352
Formatting Data During Reading 354
Refining Data Using Internal Tables 356
Formatting Data Using Extracts 360
Saving Data Externally 362
Saving Data Objects as Clusters 363
Data Clusters in ABAP Memory 364
Saving Data Objects in Memory 365
Reading Data Objects from Memory 366
Deleting Data Clusters from Memory 368
Data Clusters in the Database 369
Cluster Databases 370
Structure of a Cluster Database 371
Example of a Cluster Database 373
Saving Data Objects in Cluster Databases 375
Creating a Directory of a Data Cluster 377
Reading Data Objects From Cluster Databases 379

Deleting Data Clusters from Cluster Databases 381
Open SQL Statements and Cluster Databases 383
Working with Files 385
Working with Files on the Application Server 386
File Handling in ABAP 387
Opening a File 388
Basic Form of the OPEN DATASET Statement 389
Opening a File for Read Access 390
Opening a File for Write Access 391
Opening a File for Appending Data 394
Using Binary Mode 396
Using Text Mode 398
Opening a File at a Given Position 400
Executing Operating System Commands 402
Receiving Operating System Messages 403
Closing a File 404
Deleting a File 405
Writing Data to Files 406
Reading Data from Files 408
BC - ABAP Programming SAP AG
8 December 1999
Automatic Checks in File Operations 410
Authorization Checks for Programs and Files 411
General Checks for File Access 414
Working with Files on the Presentation Server 417
Writing Data to Presentation Server (Dialog) 418
Writing Data to Presentation Server (no Dialog) 421
Reading Data from Presentation Server (Dialog) 424
Reading Data from Presentation Server (no Dialog) 427
Checking Files on the Presentation Server 430

Using Platform-Independent Filenames 433
Maintaining Syntax Groups 434
Assigning Operating Systems to Syntax Groups 435
Creating and Defining Logical Paths 437
Creating and Defining Logical Filenames 439
Using Logical Files in ABAP Programs 440
Modularization Techniques 443
Source Code Modules 445
Macros 446
Include Programs 449
Procedures 451
Subroutines 453
Defining Subroutines 454
Global Data from the Main Program 455
Local Data in the Subroutine 457
The Parameter Interface 461
Terminating Subroutines 466
Calling Subroutines 468
Naming Subroutines 469
Passing Parameters to Subroutines 472
Examples of Subroutines 475
Shared Data Areas 480
Function Modules 483
Function Groups 484
Calling Function Modules 486
Creating Function Modules 492
Organization of External Procedure Calls 498
Special Techniques 500
Catchable Runtime Errors 501
Program Checks 502

Catching Runtime Errors 504
Checking Authorizations 506
Checking User Authorizations 508
Defining an Authorization Check 509
Checking the Runtime of Program Segments 512
GET RUN TIME FIELD 513
Runtime Measurement of Database Accesses 515
SAP AG BC - ABAP Programming
December 1999 9
Generating and Running Programs Dynamically 517
Creating a New Program Dynamically 518
Changing Existing Programs Dynamically 520
Running Programs Created Dynamically 521
Creating and Starting Temporary Subroutines 524
ABAP User Dialogs 527
Screens 528
Screen Elements 530
Screen Attributes 531
Screen Elements 532
Screen Fields 534
Screen Flow Logic 537
Processing Screens 539
User Actions on Screens 540
Processing Input/Output Fields 542
Pushbuttons on the Screen 547
Checkboxes and Radio Buttons with Function Codes 550
Using GUI Statuses 553
Reading Function Codes 561
Finding Out the Cursor Position 563
Calling ABAP Dialog Modules 566

Simple Module Calls 568
Controlling the Data Transfer 571
Calling Modules Unconditionally 574
Conditional Module Calls 578
Input Checks 583
Automatic Input Checks 584
Checking Fields in the Screen Flow Logic 587
Input Checks in Dialog Modules 590
Field Help, Input Help, and Dropdown Boxes 595
Field Help 596
Input Help 601
Input Help from the ABAP Dictionary 602
Input Help on the Screen 607
Input Help in Dialog Modules 609
Dropdown Boxes 613
Modifying Screens Dynamically 617
Setting Attributes Dynamically 618
The Field Selection Function 626
Setting the Cursor Position 637
Switching on Hold Data Dynamically 639
Complex Screen Elements 641
Status Icons 642
Context Menus 645
Subscreens 653
BC - ABAP Programming SAP AG
10 December 1999
Tabstrip Controls 660
Custom Controls 668
Table Controls 676
Using the LOOP Statement 678

Looping Through an Internal Table 679
Example Transaction: Table Controls 680
Looping Directly Through a Screen Table 684
How the System Transfers Data Values 686
Using Step Loops 688
Selection Screens 691
Selection Screens and Logical Databases 693
Defining Selection Screens 696
Defining Input Fields for Single Values 699
Basic Form of Parameters 700
Dynamic Dictionary Reference 702
Default Values for Parameters 704
SPA/GPA Parameters as Default Values 705
Allowing Parameters to Accept Upper and Lower Case 706
Reducing the Visible Length 707
Defining Required Fields 708
Search Helps for Parameters 709
Checking Input Values 710
Defining Checkboxes 712
Defining Radio Buttons 713
Hiding Input Fields 715
Modifying Input Fields 716
Defining Complex Selections 718
Selection Tables 719
Basic Form of Selection Criteria 722
Selection Criteria and Logical Databases 727
Default Values for Selection Criteria 729
Restricting Entry to One Row 731
Restricting Entry to Single Fields 732
Additional Options for Selection Criteria 733

Formatting Selection Screens 734
Blank Lines, Underlines, and Comments 735
Several Elements in a Single Line 738
Blocks of Elements 740
Calling Selection Screens 742
Calling Standard Selection Screens 743
Calling User-Defined Selection Screens 745
User Actions on Selection Screens 752
Pushbuttons on the Selection Screen 753
Checkboxes and Radio Buttons with Function Codes 755
Pushbuttons in the Application Toolbar 756
SAP AG BC - ABAP Programming
December 1999 11
Changing the Standard GUI Status 758
Selection Screen Processing 759
Basic Form 762
PBO of the Selection Screen 763
Processing Single Fields 765
Processing Blocks 766
Processing Radio Buttons 768
Processing Multiple Selections 770
Defining Field Help 772
Defining Input Help 774
Subscreens and Tabstrip Controls on Selection Screens 777
Selection Screens as Subscreens 778
Tabstrip Controls on Selection Screens 783
Subscreens on Selection Screens 787
Using Selection Criteria 789
Selection Tables in the WHERE Clause 790
Selection Tables in Logical Expressions 791

Selection Tables in GET Events 794
Lists 797
Creating Lists 799
Creating Simple Lists with the WRITE Statement 800
The WRITE Statement 801
Positioning WRITE Output on the List 804
Formatting Options 806
Displaying Symbols and Icons on the List 809
Blank Lines and Drawing Lines 810
Displaying Field Contents as Checkboxes 812
Using WRITE via a Statement Structure 813
Creating Complex Lists 817
The Standard List 818
Structure of the Standard List 819
GUI Status for the Standard List 822
The Self-Defined List 825
Individual Page Header 826
Determining the List Width 828
Creating Blank Lines 830
Determining the Page Length 832
Defining a Page Footer 834
Lists with Several Pages 836
Programming Page Breaks 837
Standard Page Headers of Individual Pages 840
Page length of individual pages 842
Page Width of List Levels 846
Scrolling in Lists 847
Scrolling Window by Window 848
BC - ABAP Programming SAP AG
12 December 1999

Scrolling by Pages 849
Scrolling to the Margins of the List 851
Scrolling by Columns 853
Defining Where the User Can Scroll on a Page 855
Laying Out List Pages 859
Positioning the Output 860
Absolute Positioning 861
Relative Positioning 863
Formatting Output 867
The FORMAT Statement 868
Colors in Lists 869
Enabling Fields for Input 875
Outputting Fields as Hotspots 877
Special Output Formats 879
Lines in Lists 883
Interactive Lists 891
Detail Lists 892
Dialog Status for Lists 897
Context Menus for Lists 903
List Events in an ABAP Program 905
Lists in Dialog Boxes 909
Passing Data from Lists to Programs 911
Passing Data Automatically 912
Passing Data by Program Statements 915
Manipulating Detail Lists 924
Scrolling in Detail Lists 925
Setting the Cursor from within the Program 927
Modifying List Lines 930
Lists and Screens 933
Starting Lists from Screen Processing 934

Calling Screens from List Processing 938
Printing Lists 942
Printing a List after Creating it 943
Printing a List while Creating it 945
Print Parameters 946
Execute and Print 947
Printing from within the Program 950
Printing Lists from a Called Program 954
Print Control 957
Determining Left and Upper Margins 958
Determining the Print Format 960
Indexing Print Lists for Optical Archiving 964
Messages 967
Message Management 968
Messages 969
Message Processing 971
SAP AG BC - ABAP Programming
December 1999 13
Messages Without Screens 972
Messages on Screens 973
Messages on Selection Screens 974
Messages in Lists 975
Messages in Function Modules and Methods 976
Running ABAP Programs 977
Defining Processing Blocks 980
Event blocks 981
Dialog modules 984
Running Programs Directly - Reports 985
Linking to a Logical Database 987
Report Transactions 991

Event Blocks in Executable Programs 992
Description of Events 993
INITIALIZATION 994
AT SELECTION-SCREEN 997
START-OF-SELECTION 998
GET 999
GET … LATE 1002
END-OF-SELECTION 1004
Leaving Event Blocks 1007
Leaving Event Blocks Using STOP 1008
Leaving Event Blocks Using EXIT 1011
Leaving Event Blocks Using CHECK 1015
Leaving a GET Event Block Using REJECT 1020
Dialog-Driven Programs: Transactions 1023
Dialog Programs: Overview 1024
Sample Transaction 1028
Maintaining Transactions 1036
Dialog Transactions 1037
Report Transactions 1038
Variant Transactions 1039
Parameter Transaction 1040
Screen Sequences 1041
Static Next Screen 1043
Dynamic Next Screen 1045
Leaving a Screen from a Program 1047
Starting a Screen Sequence 1048
Calling Modal Dialog Boxes 1051
Screen Sequences: Example Transaction 1052
Calling Programs 1057
Calling Executable Programs 1059

Filling the Selection Screen of a Called Program 1060
Affecting Lists in Called Programs 1064
Program Statements to Leave a Called Program 1066
Calling Transactions 1068
BC - ABAP Programming SAP AG
14 December 1999
Calling Screen Sequences as Modules 1069
Passing Data Between Programs 1073
Filling an Initial Screen using SPA/GPA Parameters 1074
ABAP Database Access 1078
Accessing the Database in the R/3 System 1079
Open SQL 1082
Reading Data 1084
Defining Selections 1087
Specifying a Target Area 1094
Specifying Database Tables 1101
Selecting Lines 1108
Grouping Lines 1116
Selecting Groups of Lines 1119
Specifying a Sort Order 1121
Subqueries 1124
Using a Cursor to Read Data 1128
Locking Conflicts 1134
Changing Data 1135
Inserting Lines into Tables 1136
Changing Lines 1139
Deleting Lines 1142
Inserting or Changing Lines 1145
Committing Database Changes 1147
Performance Notes 1148

Keep the Result Set Small 1152
Minimize the Amount of Data Transferred 1153
Minimize the Number of Data Transfers 1154
Minimize the Search Overhead 1156
Reduce the Database Load 1158
Native SQL 1161
Native SQL for Oracle 1166
Native SQL for Informix 1184
Native SQL for DB2 Common Server 1199
Logical Databases 1210
Structure of Logical Databases 1213
Selection Views 1220
Example of a Logical Database 1222
Using Logical Databases 1227
Linking a Logical DB to an Executable Program 1230
Calling a Logical Database Using a Function Module 1234
Editing Logical Databases 1241
Creating a Logical Database 1242
Processing the Structure 1244
Editing a Search Help 1246
Editing Selections 1247
Editing the Database Program 1251
Dynamic Selections in the Database Program 1258
SAP AG BC - ABAP Programming
December 1999 15
Field Selections in the Database Program 1262
Search Helps in the Database Program 1265
Independent Calls and the Database Program 1269
Editing Other Components 1270
Improving Performance 1271

Using Contexts 1273
What are Contexts? 1274
The Context Builder in the ABAP Workbench 1275
Creating and Editing a Context 1276
Using Tables as Modules 1278
Using Function Modules as Modules 1281
Using Contexts as Modules 1285
Testing a Context 1288
Buffering Contexts 1290
Fields 1293
Modules 1295
Interfaces 1297
Using Contexts in ABAP Programs 1298
Finding and Displaying a Context 1299
Creating an Instance of a Context 1301
Supplying Context Instances with Key Values 1302
Querying Data from Context Instances 1303
Message Handling in Contexts 1305
Message Handling in Table Modules 1306
Message Handling in Function Module Modules 1308
Working With Contexts - Hints 1311
Programming Database Updates 1312
Transactions and Logical Units of Work 1313
Database Logical Unit of Work (LUW) 1314
SAP LUW 1317
SAP Transactions 1321
The R/3 Lock Concept 1322
Example Transaction: SAP Locking 1326
Update Techniques 1328
Asynchronous Update 1329

Updating Asynchronously in Steps 1332
Synchronous Update 1333
Local Update 1334
Creating Update Function Modules 1335
Calling Update Functions 1336
Calling Update Functions Directly 1337
Adding Update Task Calls to a Subroutine 1338
Special LUW Considerations 1339
Transactions That Call Update Function Modules 1340
Dialog Modules that Call Update Function Modules 1341
Error Handling for Bundled Updates 1342
ABAP Objects 1344
BC - ABAP Programming SAP AG
16 December 1999
What is Object Orientation? 1345
What are ABAP Objects? 1348
From Function Groups to Objects 1349
Example 1352
Classes 1353
Overview Graphic 1358
Classes - Introductory Example 1359
Object Handling 1360
Overview Graphic 1363
Objects - Introductory Example 1364
Declaring and Calling Methods 1365
Methods in ABAP Objects - Example 1368
Inheritance 1380
Inheritance: Overview Graphic 1385
Inheritance: Introductory Example 1388
Interfaces 1390

Overview Graphics 1394
Interfaces - Introductory Example 1395
Triggering and Handling Events 1397
Overview Graphic 1400
Events: Introductory Example 1403
Events in ABAP Objects - Example 1405
Class Pools 1411
Appendix 1414
Programs, Screens, and Processing Blocks 1415
Introductory Statements for Programs 1419
Overview of ABAP Calls 1421
Call Contexts 1422
Internal Calls 1423
External Procedure Calls 1425
External Program Calls 1427
Callable Units 1429
ABAP Programs 1430
Procedures 1432
Screens and Screen Sequences 1434
ABAP Statement Overview 1437
ABAP System Fields 1498
ABAP Glossary 1522
Syntax Conventions 1540
SAP AG BC - ABAP Programming
BC - ABAP Programming
December 1999 17
BC - ABAP Programming
This documentation describes how to write application programs within the three-tier client/server
architecture of the R/3 System.
Application

Presentation
Database
SAP
SAP
GUI
GUI
SAP
SAP
GUI
GUI
SAP
SAP
GUI
GUI
SAP
SAP
GUI
GUI




ABAP
ABAP
ABAP
ABAP
RDBMS
RDBMS
R/3 applications are written in the ABAP programming language, and run within the application
layer of the R/3 System.

ABAP programs communicate with the database management system of the central relational
database (RDBMS), and with the graphical user interface (SAPgui) at presentation level.
Contents
The documentation is divided into five sections:
Introduction to ABAP [Page 19]
This contains the basics of application programming in the R/3 System. This information
is essential for an understanding of ABAP programming. Following an overview of the
R/3 Basis system, it introduces the essential features of application programs and the
ABAP programming language. Finally, it gives a short introduction to how you can
create an application program in the ABAP Workbench.
The ABAP Programming Language [Page 82]
This section describes the statements in the ABAP programming language. Beginning
with simple statements for data declarations, data processing, and program flow control,
it progresses to topics such as modularization and special techniques, explaining which
ABAP statements can be used for which purposes.
ABAP User Dialogs [Page 527]
BC - ABAP Programming SAP AG
BC - ABAP Programming
18 December 1999
This section describes the different user dialogs that you can use in ABAP programs,
and shows how you can program and control the interaction between program and user.
Running ABAP Programs [Page 977]
This section explains how ABAP programs are executed in the R/3 System. It shows
how you can start programs, the conditions under which you must start them, and the
different kinds of program execution.
ABAP Database Access [Page 1078]
This section explains how to work with the database in the R/3 System. It describes the
parts of the programming language that are converted into SQL statements in the
database, and shows how you can program database updates.
ABAP Objects [Page 1344]

This is an introduction to ABAP Objects, the object-oriented extension of ABAP. The
section introduces objects, classes, and interfaces - the basic elements of ABAP Objects
- and shows how you can define classes on their own, or using interfaces or inheritance.
It then goes on to introduce further components of classes, namely methods and events.
Appendix [Page 1414]
The appendix contains summary descriptions and overviews, including a reference of
ABAP statements and a glossary.
Further Reading
SAP Style Guide [Extern]
Changing the SAP Standard [Extern]
ABAP Workbench Tools [Extern]
ABAP Dictionary [Extern]
Remote Communications [Extern]
RFC Programming in ABAP [Extern]
ABAP as an OLE Automation Controller [Extern]
Basis Programming Interfaces [Extern]
ABAP Query [Extern]
SAP AG BC - ABAP Programming
Introduction to ABAP
December 1999 19
Introduction to ABAP
… but before you start, please read
the following sections:
The R/3 Basis System: Overview [Page 20]
Overview of the Components of Application Programs [Page 37]
Creating and Changing ABAP Programs [Page 68]
BC - ABAP Programming SAP AG
The R/3 Basis System: Overview
20 December 1999
The R/3 Basis System: Overview

The R/3 Basis system is the platform for all other applications (financial accounting, logistics,
human resources management) in the R/3 System.
This documentation explains just what the Basis system is, and how it ties in with the R/3 System
as a whole. It starts by introducing the Basis system in general. The second part concentrates on
one central component - the application server. Finally, it will explain about work processes,
which are components of the application server.
Position of the Basis System Within the R/3 System [Page 21]
Application Server [Page 27]
Work Processes [Page 32]
SAP AG BC - ABAP Programming
Position of the Basis System Within the
R/3 System
December 1999 21
Position of the Basis System Within the R/3 System
The following sections describe three different views of the R/3 System, which show the role of
the Basis system.
Logical View
The following illustration represents a logical view of the R/3 System.
R/3 User
R/3 User
R/3
Basis
System
ABAP
Workbench
ABAP
Workbench
R/3
Application 1
R/3

Application n
Kernel & Basis Services
Kernel & Basis Services
Database Management System
Database
Presentation Components
Presentation Components


The difference between the logical view and a hardware- or software-based view is that not all of
the above components can be assigned to a particular hardware or software unit. The above
diagram shows how the R/3 Basis system forms a central platform within the R/3 System. Below
are listed the tasks of the three logical components of the R/3 Basis system.
Kernel and Basis Services
The kernel and basis services component is a runtime environment for all R/3 applications that is
hardware-, operating system- and database-specific. The runtime environment is written
principally in C and C++. However, some parts are also written in ABAP. The tasks of the kernel
and basis services component are as follows:
• Running applications
All R/3 applications run on software processors (virtual machines) within this component.
• User and process administration
An R/3 System is a multi-user environment, and each user can run several independent
BC - ABAP Programming SAP AG
Position of the Basis System Within the R/3 System
22 December 1999
applications. In short, this component is responsible for the tasks that usually belong to an
operating system. Users log onto the R/3 System and run applications within it. In this way,
they do not come into contact with the actual operating system of the host. The R/3 System
is the only user of the host operating system.
• Database access

Each R/3 System is linked to a database system, consisting of a database management
system (DBMS) and the database itself. The applications do not communicate directly with
the database. Instead, they use Basis services.
• Communication
R/3 applications can communicate with other R/3 Systems and with non-SAP systems. It is
also possible to access R/3 applications from external systems using a BAPI interface. The
services required for communication are all part of the kernel and basis services component.
• System Monitoring and Administration
The component contains programs that allow you to monitor and control the R/3 System
while it is running, and to change its runtime parameters.
ABAP Workbench
The ABAP Workbench component is a fully-fledged development environment for applications
in the ABAP language. With it, you can create, edit, test, and organize application developments.
It is fully integrated in the R/3 Basis system and, like other R/3 applications, is itself written in
ABAP.
Presentation Components
The presentation components are responsible for the interaction between the R/3 System and
the user, and for desktop component integration (such as word processing and spreadsheets).
Software-oriented View
The following illustration represents a software-oriented view of the R/3 System. The software-
oriented view describes the various software components that make up the R/3 System. In the
software-oriented view, all of the SAPgui components and application servers in the R/3 System
make up the R/3 Basis system.
SAP AG BC - ABAP Programming
Position of the Basis System Within the
R/3 System
December 1999 23
SAP GUI

Presentation
Layer
Application
Layer
Database
Layer
SAP GUI SAP GUI SAP GUI
Application Server 1 Application Server n
Message Server
Database Management System
Database
The R/3 Basis system is a multi-tier client/server system. The individual software components are
arranged in tiers and function, depending on their position, as a client for the components below
them or a server for the components above them. The classic configuration of an R/3 System
contains the following software layers:
Database Layer
The database layer consists of a central database system containing all of the data in the R/3
System. The database system has two components - the database management system
(DBMS), and the databse itself. SAP does not manufacture its own database. Instead, the R/3
System supports the following database systems from other suppliers: ADABAS D, DB2/400 (on
AS/400), DB2/Common Server, DB2/MVS,INFORMIX, Microsoft SQL Server, ORACLE, and
ORACLE Parallel Server.
The database does not only contain the master data and transaction data from your business
applications, all data for the entire R/3 System is stored there. For example, the database
contains the control and Customizing data that determine how your R/3 System runs. It also
contains the program code for your applications. Applications consist of program code, screen
definitions, menus, function modules, and various other components. These are stored in a
special section of the database called the R/3 Repository, and are accordingly called Repository

objects. You work with them in the ABAP Workbench.
Application Layer
The application layer consists of one or more application servers and a message server. Each
application server contains a set of services used to run the R/3 System. Theoretically, you only
need one application server to run an R/3 System. In practice, the services are distributed across
more than one application server. This means that not all application servers will provide the full
BC - ABAP Programming SAP AG
Position of the Basis System Within the R/3 System
24 December 1999
range of services. The message server is responsible for communication between the application
servers. It passes requests from one application server to another within the system. It also
contains information about application server groups and the current load balancing within them.
It uses this information to choose an appropriate server when a user logs onto the system.
Presentation Layer
The presentation layer contains the software components that make up the SAPgui (graphical
user interface). This layer is the interface between the R/3 System and its users. The R/3 System
uses the SAPgui to provide an intuitive graphical user interface for entering and displaying data.
The presentation layer sends the user’s input to the application server, and receives data for
display from it. While a SAPgui component is running, it remains linked to a user’s terminal
session in the R/3 System.
This software-oriented view can be expanded to include further layers, such as an Intenet
Transaction Server (ITS).
Software-oriented and Hardware-oritented View
The software-oriented view has nothing to do with the hardware configuration of the system.
There are many different hardware configuration possibilities for both layers and components.
When distributing the layers, for example, you can have all layers on a single host, or, at the
other extreme, you could have at least one host for each layer. When dealing with components,
the distribution of the database components depends on the database sytsem you are using. The
application layer and presentation layer components can be distributed across any number of
hosts. It is also possible to install more than one application server on a single host. A common

configuration is to run the database system and a single application server (containing special
database services) on one host, and to run each further application server on its own host. The
presentation layer components usually run on the desktop computers of the users.
Advantages of the Multi-tier Architecture
The distribution of the R/3 software over three layers means that the system load is also
distributed. This leads to better system performance.
Since the database system contains all of the data for the entire R/3 System, it is subject to a
very heavy load when the sytsem is running. It is therefore a good idea not to run application
programs on the same host. The architecture of the R/3 System, in which the application layer
and database layer are separate, allows you to install them on separate hosts and let them
communicate using the network.
It also makes sense to separate program execution from the tasks of processing user input and
formatting data output. This is made possible by separating the presentation layer and the
application layer. SAPgui and the application servers are designed so that the minimum amount
of data has to be transported between the two layers. This means that the presentation layer
components can even be used on hosts that have slow connections to application servers a long
way away.
The system is highly scalable, due to the fact that the software components of an R/3 System
can be distributed in almost any configuration across various hosts. This is particularly valuable
in the application layer, where you can easily adapt your R/3 System to meet increasing demand
by installing further application servers.
Consequences for Application Programming
The fact that the application and presentation layers are separate carries an important
consequence for application programmers. When you run an application program that requires
SAP AG BC - ABAP Programming
Position of the Basis System Within the
R/3 System
December 1999 25
user interaction, control of the program is continually passed backwards and forwards between
the layers. When a screen is ready for user input, the presentation layer is active, and the

application server is inactive with regard to that particular program, but free for other tasks. Once
the user has entered data on the screen, program control passes back to the application layer.
Now, the presentation layer is inactive. The SAPgui is still visible to the user during this time, and
it is still displaying the screen, but it cannot accept user input The SAPgui does not become
active again until the application program has called a new screen and sent it to the presentation
server.
As a consequence, the program logic in an application program that occurs between two screens
is known as a dialog step.
Presentation Layer:
User
interaction
Application Layer
System processes
dialog steps
Scrn 1
Scrn 1
Scrn 2
Scrn 2
Scrn 3
Scrn 3
SAP GUI inactive SAP GUI Inactive
Inactive Inactive
SAP GUI
Inactive
Dialog
step
Dialog
step