Free Download SAP ABAP Books, Projects, Reports, FAQ’s

The R/3 Basis System: Overview

2008-07-30T22:00:00.002+05:30

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

Application Server

Work Processes

Position of the Basis System Within the R/3 System

2008-07-30T22:00:00.001+05:30

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.

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

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

User-oriented View

The following illustration represents a user-oriented view of the R/3 System:

For the user, the visible components of the R/3 System are those that appear as a window on the screen. The windows are generated by the presentation layer of the R/3 System, and form a part of the R/3 Basis system.

Before the user logs onto the R/3 System, he or she must start a utility called SAP Logon, which is installed at the front end. In SAP Logon, the user chooses one of the available R/3 Systems. The program then connects to the message server of that system and obtains the address of a suitable (most lightly-used) application server. It then starts a SAPgui, connected to that application server. The SAP Logon program is then no longer required for this connection.

SAPgui starts the logon screen. Once the user has successfully logged on, it displays the initial screen of the R/3 System in an R/3 window on the screen. Within SAPgui, the R/3 window is represented as a session. After logging on, the user can open up to five further sessions (R/3 windows) within the single SAPgui. These behave almost like independent SAPguis. The different sessions allow you to run different applications in parallel, independently of one another.

Within a session, the user can run applications that themselves call further windows (such as dialog boxes and graphic windows). These windows are not independent - they belong to the session from which they were called. These windows can be either modal (the original window is not ready for input) or amodal (both windows are ready for input).

The user can open other SAPguis, using SAP Logon, to log onto the same system or another R/3 System. The individual SAPguis and corresponding R/3 terminal sessions are totally independent. This means that you can have SAPguis representing the presentation layers of several R/3 Systems open on your desktop computer.

Application Servers in SAP

2008-07-30T21:59:00.001+05:30

R/3 programs run on application servers. They are an important component of the R/3 System. The following sections describe application servers in more detail.

Structure of an Application Server

The application layer of an R/3 System is made up of the application servers and the message server. Application programs in an R/3 System are run on application servers. The application servers communicate with the presentation components, the database, and also with each other, using the message server.

The following diagram shows the structure of an application server:

The individual components are:

Work Processes

An application server contains work processes, which are components that can run an application. Each work process is linked to a memory area containing the context of the application being run. The context contains the current data for the application program. This needs to be available in each dialog step. Further information about the different types of work process is contained later on in this documentation.

Dispatcher

Each application server contains a dispatcher. The dispatcher is the link between the work processes and the users logged onto the application server. Its task is to receive requests for dialog steps from the SAPgui and direct them to a free work process. In the same way, it directs screen output resulting from the dialog step back to the appropriate user.

Gateway

Each application server contains a gateway. This is the interface for the R/3 communication protocols (RFC, CPI/C). It can communicate with other application servers in the same R/3 System, with other R/3 Systems, with R/2 Systems, or with non-SAP systems.

The application server structure as described here aids the performance and scalability of the entire R/3 System. The fixed number of work processes and dispatching of dialog steps leads to optimal memory use, since it means that certain components and the memory areas of a work process are application-independent and reusable. The fact that the individual work processes work independently makes them suitable for a multi-procecssor architecuture. The methods used in the dispatcher to distribute tasks to work processes are discussed more closely in the section Dispatching Dialog Steps.

Shared Memory

All of the work processes on an application server use a common main memory area called shared memory to save contexts or to buffer constant data locally.

The resources that all work processes use (such as programs and table contents) are contained in shared memory. Memory management in the R/3 System ensres that the work processes always address the correct context, that is the data relevant to the current state of the program that is running. A mapping process projects the required context for a dialog step from shared memory into the address of the relevant work process. This reduces the actual copying to a minimum.

Local buffering of data in the shared memory of the application server reduces the number of database reads required. This reduces access times for application programs considerably. For optimal use of the buffer, you can concentrate individual applications (financial accounting, logistics, human resources) into separate application server groups.

Database Connection

When you start up an R/3 System, each application server registers its work proceses with the database layer, and receives a single dedicated channel for each. While the system is running, each work process is a user (client) of the database system (server). You cannot change the work process registration while the system is running. Neither can you reassign a database channel from one work process to another. For this reason, a work process can only make database changes within a single database logical unit of work (LUW). A database LUW is an inseparable sequence of database operations. This has important consequences for the programming model explained below.

Dispatching Dialog Steps

The number of users logged onto an application server is often many times greater than the number of available work processes. Furthermore, it is not restricted by the R/3 system architecture. Furthermore, each user can run several applications at once. The dispatcher has the important task of distributing all dialog steps among the work processes on the application server.

The following diagram is an example of how this might happen:

The dispatcher receives the request to execute a dialog step from user 1 and directs it to work process 1, which happens to be free. The work process addresses the context of the application program (in shared memory) and executes the dialog step. It then becomes free again.
The dispatcher receives the request to execute a dialog step from user 2 and directs it to work process 1, which is now free again. The work process executes the dialog step as in step 1.
While work process 1 is still working, the dispatcher receives a further request from user 1 and directs it to work process 2, which is free.
After work processes 1 and 2 have finished processing their dialog steps, the dispatcher receives another request from user 1 and directs it to work process 1, which is free again.
While work process 1 is still working, the dispatcher receives a further request from user 2 and directs it to work process 2, which is free.

From this example, we can see that:

A dialog step from a program is assigned to a single work process for execution.
The individual dialog steps of a program can be executed on different work processes, and the program context must be addressed for each new work process.
A work process can execute dialog steps of different programs from different users.

The example does not show that the dispatcher tries to distribute the requests to the work processes such that the same work process is used as often as possible for the successive dialog steps in an application. This is useful, since it saves the program context having to be addressed each time a dialog step is executed.

Dispatching and the Programming Model

The separation of application and presentation layer made it necessary to split up application programs into dialog steps. This, and the fact that dialog steps are dispatched to individual work processes, has had important consequences for the programming model.

As mentioned above, a work process can only make database changes within a single database logical unit of work (LUW). A database LUW is an inseparable sequence of database operations. The contents of the database must be consistent at its beginning and end. The beginning and end of a database LUW are defined by a commit command to the database system (database commit). During a database LUW, that is, between two database commits, the database system itself ensures consistency within the database. In other words, it takes over tasks such as locking database entries while they are being edited, or restoring the old data (rollback) if a step terminates in an error.

A typical SAP application program extends over several screens and the corresponding dialog steps. The user requests database changes on the individual screens that should lead to the database being consistent once the screens have all been processed. However, the individual dialog steps run on different work processes, and a single work process can process dialog steps from other applications. It is clear that two or more independent applications whose dialog steps happen to be processed on the same work process cannot be allowed to work with the same database LUW.

Consequently, a work process must open a separate datables LUW for each dialog step. The work process sends a commit command (database commit) to the database at the end of each dialog step in which it makes database changes. These commit commands are called implicit database commits, since they are not explicitly written into the application program.

These implicit database commits mean that a database LUW can be kept open for a maximum of one dialog step. This leads to a considerable reduction in database load, serialization, and deadlocks, and enables a large number of users to use the same system.

However, the question now arises of how this method (1 dialog step = 1 database LUW) can be reconciled with the demand to make commits and rollbacks dependent on the logical flow of the application program instead of the technical distribution of dialog steps. Database update requests that depend on one another form logical units in the program that extend over more than one dialog step. The database changes associated with these logical units must be executed together and must also be able to be undone together.

The SAP programming model contains a seies of bundling techniques that allow you to group database updates together in logical units. The section of an R/3 application program that bundles a set of logically-associated database operations is called an SAP LUW. Unlike a database LUW, a SAP LUW includes all of the dialog steps in a logical unit, including the database update.

Work Processes in SAP ABAP

2008-07-30T21:58:00.002+05:30

Work processes execute the individual dialog steps in R/3 applications. The next two sections describe firstly the structure of a work process, and secondly the different types of work process in the R/3 System.

Structure of a Work Process

Work processes execute the dialog steps of application programs. They are components of an application server. The following diagram shows the components of a work process:

Each work process contains two software processors and a database interface.

Screen Processor

In R/3 application programming, there is a difference between user interaction and processing logic. From a programming point of view, user interaction is controlled by screens. As well as the actual input mask, a screen also consists of flow logic. The screen flow logic controls a large part of the user interaction. The R/3 Basis system contains a special language for programming screen flow logic. The screen processor executes the screen flow logic. Via the dispatcher, it takes over the responsibility for communication between the work process and the SAPgui, calls modules in the flow logic, and ensures that the field contents are transferred from the screen to the flow logic.

ABAP-Prozessor

The actual processing logic of an application program is written in ABAP - SAP’s own programing language. The ABAP processor executes the processing logic of the application program, and communicates with the database interface. The screen processor tells the ABAP processor which module of the screen flow logic should be processed next. The following screen illustrates the interaction between the screen and the ABAP processors when an application program is running.

Database Interface

The database interface provides the following services:

Establishing and terminating connections between the work process and the database.

Access to database tables

Access to R/3 Repository objects (ABAP programs, screens and so on)

Access to catalog information (ABAP Dictionary)

Controlling transactions (commit and rollback handling)

Table buffer administration on the application server.

The following diagram shows the individual components of the database interface:

The diagram shows that there are two different ways of accessing databases: Open SQL and Native SQL.

Open SQL statements are a subset of Standard SQL that is fully integrated in ABAP. They allow you to access data irrespective of the database system that the R/3 installation is using. Open SQL consists of the Data Manipulation Language (DML) part of Standard SQL; in other words, it allows you to read (SELECT) and change (INSERT, UPDATE, DELETE) data. The tasks of the Data Definition Language (DDL) and Data Control Language (DCL) parts of Standard SQL are performed in the R/3 System by the ABAP Dictionary and the authorization system. These provide a unified range of functions, irrespective of database, and also contain functions beyond those offered by the various database systems.

Open SQL also goes beyond Standard SQL to provide statements that, in conjunction with other ABAP constructions, can simplify or speed up database access. It also allows you to buffer certain tables on the application server, saving excessive database access. In this case, the database interface is responsible for comparing the buffer with the database. Buffers are partly stored in the working memory of the current work process, and partly in the shared memory for all work processes on an application server. Where an R/3 System is distributed across more than one application server, the data in the various buffers is synchronized at set intervals by the buffer management. When buffering the database, you must remember that data in the buffer is not always up to date. For this reason, you should only use the buffer for data which does not often change.

Native SQL is only loosely integrated into ABAP, and allows access to all of the functions contained in the programming interface of the respective database system. Unlike Open SQL statements, Native SQL statements are not checked and converted, but instead are sent directly to the database system. Programs that use Native SQL are specific to the database system for which they were written. R/3 applications contain as little Native SQL as possible. In fact, it is only used in a few Basis components (for example, to create or change table definitions in the ABAP Dictionary).

The database-dependent layer in the diagram serves to hide the differences between database systems from the rest of the database interface. You choose the appropriate layer when you install the Basis system. Thanks to the standardization of SQL, the differences in the syntax of statements are very slight. However, the semantics and behavior of the statements have not been fully standardized, and the differences in these areas can be greater. When you use Native SQL, the function of the database-dependent layer is minimal.

Types of Work Process

Although all work processes contain the components described above, they can still be divided into different types. The type of a work process determines the kind of task for which it is responsible in the application server. It does not specify a particular set of technical attributes. The individual tasks are distributed to the work processes by the dispatcher.

Before you start your R/3 System, you determine how many work processes it will have, and what their types will be. The dispatcher starts the work processes and only assigns them tasks that correspond to their type. This means that you can distribute work process types to optimize the use of the resources on your application servers.

The following diagram shows again the structure of an application server, but this time, includes the various possible work process types:

The various work processes are described briefly below. Other parts of this documentation describe the individual components of the application server and the R/3 System in more detail.

Dialog Work Process

Dialog work processes deal with requests from an active user to execute dialog steps.

Update Work Process

Update work processes execute database update requests. Update requests are part of an SAP LUW that bundle the database operations resulting from the dialog in a database LUW for processing in the background.

Background Work Process

Background work processes process programs that can be executed without user interaction (background jobs).

Enqueue Work Process

The enqueue work process administers a lock table in the shared memory area. The lock table contains the logical database locks for the R/3 System and is an important part of the SAP LUW concept. In an R/3 System, you may only have one lock table. You may therefore also only have one application server with enqueue work processes.

Spool Work Process

The spool work process passes sequential datasets to a printer or to optical archiving. Each application server may contain only one spool work process.

The services offered by an application server are determined by the types of its work processes. One application server may, of course, have more than one function. For example, it may be both a dialog server and the enqueue server, if it has several dialog work processes and an enqueue work process.

You can use the system administration functions to switch a work process between dialog and background modes while the system is still running. This allows you, for example, to switch an R/3 System between day and night operation, where you have more dialog than background work processes during the day, and the other way around during the night.

Overview of the Components of Application Programs in SAP ABAP

2008-07-30T21:58:00.001+05:30

This overview describes application programming in the R/3 System. All application programs, along with parts of the R/3 Basis system, are written in the ABAP Workbench using ABAP, SAP’s programming language. The individual components of application programs are stored in a special section of the database called the R/3 Repository. The R/3 Repository serves as a central store for all of the development objects in the R/3 System. The following sections of this documentation cover the basics and characteristics of application programming.

Structure of an Application Program

Screens

Structure of the Processing Logic

Processing Blocks in ABAP Programs

ABAP Statements

Logical Databases and Contexts

Memory Structures of an ABAP Program

Structure of an Application Program in SAP ABAP

2008-07-30T21:57:00.000+05:30

R/3 application programs run within the R/3 Basis system on the work processes of application servers. This makes them independent of the hardware and operating system that you are using. However, it also means that you cannot run them outside the R/3 System.

As described in the Overview of the R/3 Basis System, a work process contains a screen processor for processing user input, an ABAP processor for processing the program logic, and a database interface for communicating with the database. These components of a work process determine the following structure of an applciation program:

An application program consists of two components, each of which has a different task:

Flow Logic

Interaction between application programs and the user is implemented using screens. Screens are processed by the screen processor of a work process. As well as the input mask, they consist of flow logic. This is coding, written using a special set of keywords called the screen language. The input mask is displayed by the SAPgui, which also transfers the user action on the screen back to the flow logic. In the program flow, screens react to the user actions and call program modules. These program modules form the processing logic.

Processing logic

The components of application programs that are responsible for data processing in the R/3 System are ABAP programs. ABAP stands for ‘Advanced Business Application Programming’. ABAP programs run on the ABAP processor of a work process. They receive screen input from the screen processor and send it to the screen processor. You access the database using the database interface. ABAP contains a special set of commands called OPEN SQL. This allows you to read from and write to the database regardless of the database you are using. The database interface converts the OPEN SQL commands into commands of the relevant database. You can also use native SQL commands, which are passed to the database without first being converted. There is a range of further interfaces such as memory, sequential files and external interfaces. These provide other means of sending data to and from ABAP programs. When working together with screens, ABAP programs play a more passive role, acting as a container for a set of modules that can be called from the flow logic.

Screens in SAP ABAP

2008-07-30T21:56:00.002+05:30

Each screen that a user sees in the R/3 System belongs to an application program. Screens send data to, receive data from, and react to the user’s interaction with the input mask. There are three ways to organize screen input and output. These differ in the way in which they are programmed, and in how the user typically interacts with them.

Screens

In the most general case, you create an entire screen and its flow logic by hand using the Screen Painter in the ABAP Workbench.

Selection Screens and Lists

There are two special kinds of screen in the R/3 System that you will often use - selection screens and lists. These screens and their flow logic are generated from ABAP statements in the processing logic. In this case, you do not have to work with the Screen Painter. Instead, you define the entire screen in the processing logic.

Screens in the R/3 System also contain a menu bar, a standard toolbar, and an application toolbar. Together, these three objects form the status of the screen. Each status is an object of its corresponding application program. It is a standalone part of the screen . Since it does not expressly belong to one screen, it can be reused in any number of screens. You define statuses using the Menu Painter in the ABAP Workbench. You can define your own statuses for screens and lists. Selection screens have a fixed status.

The following sections describe the different types of screen in more detail.

Screens

Each screen contains an input mask that you can use for data input and output. You can design the mask yourself. When the screen mask is displayed by the SAPgui, two events are triggered: Before the screen is displayed, the Process Before Output (PBO) event is processed. When the user interacts with the screen, the Process After Input (PAI) event is processed.

Each screen is linked to a single PBO processing block and a single PAI processing block. The PAI of a screen and the PBO of the subsequent screen together form a dialog step in the application program.

The screen language is a special subset of ABAP, and contains only a few keywords. The statements are syntactically similar to the other ABAP statements, but you may not use screen statements in ABAP programs or ABAP statements in the screen flow logic. The most important screen keywords are MODULE, FIELD, CHAIN, and LOOP. Their only funciton is to link the processing logic to the flow logic, that is, to call modules in the processing logic, and control data transfer between the screen and the ABAP program, for example, by checking fields.

The input/output mask of a screen contains all of the normal graphical user interface elements, such as input/output fields, pushbuttons, and radio buttons. The following diagram shows a typical screen mask:

All of the active elements on a screen have a field name and are linked to screen fields in shared memory. You can link screen fields to the ABAP Dictionary. This provides you with automatic field and value help, as well as consistency checks.

When a user action changes the element, the value of the screen field is changed accordingly. Values are transported between screens and the processing logic in the PAI event, where the contents of the screen fields are transported to program fields with the same name.

Each screen calls modules in its associated ABAP program which prepare the screen (PBO) and process the entries made by the user (PAI). Although there are ABAP statements for changing the attributes of screen elements (such as making them visible or invisible), but there are none for defining them.

Dialog screens enable the user and application programs to communicate with each other. They are used in dialog-oriented programs such as transactions, where the program consists mainly of processing a sequence of screens. Essentially, you use screens when you need more flexibility than is offered by selection screens or lists.

Selection Screens

Selection screens are special screens used to enter values in ABAP programs. Instead of using the Screen Painter, you create them using ABAP statements in the processing logic of your program. The selection screen is then generated according to these statements. The screen flow logic is supplied by the system, and remains invisible to you as the application programmer.

You define selection screens in the declaration part of an ABAP program using the special declaration statements PARAMETERS, SELECT-OPTIONS and SELECTION-SCREEN). These statements declare and format the input fields of each selection screen. The following is a typical selection screen:

The most important elements on a selection screen are input fields for single values and for selection tables. Selection tables allow you to enter more complicated selection criteria. Selection tables are easy to use in ABAP because the system automatically processes them itself. As on other screens, field and possible values help is provided for input fields which refer to an ABAP Dictionary field. Users can use pre-configured sets of input values for selection screens. These are called variants.

You call a selection screen from an ABAP program using the CALL SELECTION-SCREEN statement. If the program is an executable (report) with type 1, the ABAP runtime environment automatically calls the selection screen defined in the declaration part of the program. Selection screens trigger events, and can therefore call event blocks in ABAP programs.

Since selection screens contain principally input fields, selection screen dialogs are more input-oriented than the screens you define using the Screen Painter. Dialog screens can contain both input and output fields. Selection screens, however, are appropriate when the program requires data from the user before it can continue processing. For example, you would use a selection screen before accessing the database, to restrict the amount of data read.

Lists

Lists are output-oriented screens which display formatted, structured data. They are defined, formatted, and filled using ABAP commands. The system displays lists defined in ABAP on a special list screen. As with selection screens, the flow logic is supplied by the system and remains hidden from the application programmer.

The most important task of a list is to display data. However, users can also interact with them. Lists can react to mouse clicks and contain input fields. Despite these similarities with other types of screen, lists are displayed using a completely different technique. Input fields on lists cannot be compared with those on normal screens, since the method of transferring data between the list and the ABAP program is completely different in each case. If input fields on lists are linked to the ABAP Dictionary, the usual automatic field and possible values help is available. The following is a typical list:

You define lists using a special set of statements (the list statements WRITE, SKIP, ULINE, NEW-PAGE and so on) in the processing blocks of ABAP programs. When these statements are executed, a list is composed within the system. An internal system program called the list processor is responsible for displaying lists and for interpreting user actions in the list. Lists are important because only data in list format can be sent to the R/3 spool system for printing.

In an ABAP program, you can use the LEAVE TO LIST-PROCESSING statement to define the next screen as a list. If the ABAP program is an executable (report) with type 1, the ABAP runtime environment automatically calls the list defined in your program. A single program can be responsible for a stack of up to 21 lists. From one basic list, you can create up to 20 details lists. User actions on a list screen trigger events, and can thus call event blocks in the ABAP program.

Lists are output-oriented. When users carry out actions on a list screen, it is normally to use part of the list contents in the next part of the program, and not to input values directly. Using lists is appropriate when you want to work with output data, to print data or when the user’s next action depends on output data.

Structure of ABAP Programs

2008-07-30T21:56:00.001+05:30

ABAP processing logic is responsible for processing data in R/3 application programs. ABAP was designed specifically for dialog-oriented database applications. The following sections deal with how an ABAP program is structured and executed.

Program Structure

ABAP programs are responsible for data processing within the individual dialog steps 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 have a modular structure. Each module is called a processing block. A processing block consists of a set of ABAP statements. When you run a program, you effectively call a series of processing blocks. They cannot be nested.

The following diagram shows the structure of an ABAP program:

Each ABAP program consists of the following two parts:

Declaration Part 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. You define it using declarative statements that appear before the first processing block, in dialog modules, or in event blocks. You cannot declare local data 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.

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:

Dialog modules (no local data area)
Event blocks (no local data area)
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.

Calling Processing Blocks

You can call processing blocks either from outside 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. You only have to define event blocks for the events to which you want the program to react (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.

Program Types and Execution

When you run an ABAP program, you call its processing blocks. 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 you run an ABAP program, 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 you must set it when you create it. The main difference between the different program types is the way in which the runtime environment calls its processing blocks.

When you run an application program, you must call at least 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 you start an ABAP program, the runtime environment starts a processor (dependent on the program type), which calls the first ABAP processing block. An ABAP program can be started either by the user or by the system (for example, in background processing), or through an external interface (for example, Remote Function Call).

There are two ways of allowing users to execute programs - either by entering the program name or by entering a transaction code. You can assign a transaction code to any program. Users can then start that program by entering the code in the command field. Transaction codes are also usually linked to a menu path within the R/3 System.

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.

You can start a type 1 program and the corresponding processor in the runtime environment using the SUBMIT statement in another ABAP program. There are also various ways of starting a type1 program by entering its program name. This is why we refer to type 1 programs as executable programs.

When you run a type 1 program, a series of processors run in a particular order in the runtime environment. The process flow allows the user to enter selection parameters on a selection screen. The data is them selected from the database and processed. Finally, an output list is displayed. At no stage does the programmer have to define his or her own screens. The runtime environment also allows you to work with a logical database. A logical database is a special ABAP program which combines the contents of certain database tables. The flow of a type 1 program is oriented towards reporting, whose main tasks are to read data from the database, process it, and display the results. This is why executable programs (type 1) in the R/3 System are often referred to as reports, and why running an executable program is often called reporting.

Since it is not compulsory to define event blocks, you can yourself determine the events to which your ABAP program should react. Furthermore, you can call your own screens or processing blocks at any time, leaving the prescribed program flow. You can use this, for example, to present data in a table on a dialog screen instead of in a list. The simplest executable program (report) contains only one processing block (START-OF-SELECTION).

Executable programs do not require any user dialog. You can fill the selection screen using a variant and output data directly to the spool system instead of to a list. This makes executable programs (reports) the means of background processing in the R/3 System.

You can also assign a transaction code to an executable program. Users can then start it using the transaction code and not the program name. The reporting-oriented runtime environment is also called when you run a report using a transaction code. This kind of transaction is called a report transaction.

It is appropriate to use executable programs (reports) when the flow of your program corresponds either wholly or in part to the pre-defined flow of the runtime environment. Until Release 4.5A, the only way to use a logical database was to use an executable program. However, from Release 4.5A, it is also possible to call logical databases on their own.

Type M

The most important technical attribute of a type M program is that it can only be controlled using screen flow logic. You must start them using a transaction code, whcih is linked to the program and one of its screens (initial screen). Another feature of these programs is that you must define your own screens in the Screen Painter (although the intial screen can be a selection screen).

When you start a program using a transaction code, the runtime environment starts a processor that calls the initial screen. This then calls a dialog module in the corresponding ABAP program. The remainder of the program flow can take any form. For example, the dialog module can:

return control to the screen, after which, the processing passes to a subsequent screen. Each screen has a following screen, set either statically or dynamically.
call other sequences of screens, selection screens or lists, from which further processing blocks in the ABAP program are started.
call other processing blocks itself, either internally or externally.
call other application programs using CALL TRANSACTION (type M program) or SUBMIT (type 1 program).

ABAP programs with type M contain the dialog modules belonging to the various screens. They are therefore known as module pools. It is appropriate to use module pools when you write dialog-oriented programs using a large number of screens whose flow logic largely determines the program flow.

Type F

Type F programs are containers for function modules, and cannot be started using a transaction code or by entering their name directly. Function modules are special procedures that you can call from other ABAP programs.

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 you can use 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

You cannot start type K programs using a transaction code or by entering the program name. They 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 you can use to create class definitions.

Type J

You cannot start type J programs using a transaction code or by entering the program name. They are containers for global interface in ABAP Objects . Type J programs are known as interface definitions. Like class definitions, you create interface definitions in the Class Builder.

Type S

You cannot start a type S program using a transaction code or by entering the program name. Instead, they are containers for subroutines, which you can call externally from other ABAP programs. Type S programs are known as subroutine pools. They cannot contain screens.

Type I

Type I programs - called includes - are a means of dividing up program code into smaller, more manageable units. You can insert the coding of an include program 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.

Processing Blocks in ABAP Programs

2008-07-30T21:55:00.000+05:30

The following sections explain the different processing blocks in ABAP programs and how they are called.

Dialog Modules

You call dialog modules from the screen flow logic (screen command MODULE). You can write a dialog module in an ABAP program for each state (PBO, PAI; user input) of any of the screens belonging to it. The PAI modules of a screen together with the PBO modules of the subsequent screen form a dialog step. The interaction between the flow logic and the screen is controlled by a dialog processor.

Dialog modules are introduced with the MODULE statement and concluded with the ENDMODULE statement.

Fields on a dialog screen have the same name as a corresponding field in the ABAP program. Data is passed between identically-named fields in the program. You do notdefine dialog screens in the ABAP programs.

Event Blocks for Selection Screens

A selection screen is a special kind of dialog screen that you create using ABAP commands in the declaration part of the program. The different events in a selection screen (PAI, PBO, user input), are controlled by a selection screen processor. You can program processing logic for these events in your program. The selection screen processor controls the flow logic of the selection screen.

You do not have to create the screen flow logic yourself, neither can you create your own dialog modules for the PBO or PAI events . Data is passed between selection screen and ABAP program using the fields (parameters and selection tables) which you create in the selection screen definition in the declaration part of the ABAP program.

Event Blocks for Lists

Lists are special screens which output formatted data. You can create them in any processing block in an ABAP program using a special set of commands (such as WRITE, NEW-PAGE and so on). The list processor displays the list on the screen and handles user actions within lists. The list processor controls the flow logic of the list. You do not have to create the screen flow logic yourself, neither can you create your own dialog modules for the PBO or PAI events .

You can call various event blocks while the list is being created which are used in page formatting. The above illustration contains the event block TOP-OF-PAGE, which is called from the ABAP program itself. When the list is displayed, the user can carry out actions which trigger event blocks for interactive list events (such as AT LINE-SELECTION). You can program processing logic for the interactive list events in your program. Data is transferred from list to ABAP program via system fields or an internal memory area called the HIDE area.

Event Blocks for Executable Programs (Reports)

When you run an executable program (type 1), it is controlled by a predefined process in the runtime environment. A series of processors is called, one after the other. These processors trigger events, for which you can define event blocks. Type 1 programs are event-driven.

The process is as follows:

The runtime environment creates the INITIALIZATION event and calls the corresponding event block (if it has been defined in the ABAP program).

If there is a selection screen defined in the program, control returns to the selection screen processor. This generates the corresponding events and calls their event blocks.

Control then passes to the reporting processor. It creates the START-OF-SELECTION event and calls the corresponding event block (if it has been defined in the ABAP program).

The logical database, if you are using one, calls further event blocks at this point.

The reporting processor creates the END-OF-SELECTION event and calls the corresponding event block (if it has been defined in the ABAP program).

If the program contains a list description, control now passes to the list processor. The list processor displays the list defined in the ABAP program. It converts user actions on the list into events and calls the corresponding event blocks.

Subroutines

You call subroutines from ABAP programs using the PERFORM statement.

Subroutines are introduced with the FORM statement and concluded with the ENDFORM statement.

You can define subroutines in any ABAP program. You can either call a subroutine that is part of the same program or an external subroutine, that is, one that belongs to a different program. If you call an internal subroutine, you can use global data to pass values between the main program and the subroutine. When you call an external subroutine, you must pass actual parameters from the main program to formal parameters in the subroutine.

Function Modules

Function modules are external functions with a defined interface. You call function modules from ABAP programs using the CALL FUNCTION statement.

Function modules are introduced with the FUNCTION statement and concluded with the ENDFUNCTION statement.

You can only create function groups within special ABAP programs called function groups using the Function Builder. This means that you can only call them externally from other ABAP programs. Unlike subroutines, you always pass data to function modules using an explicit parameter interface.

Methods

Methods describe the functions of classes in ABAP Objects. Like function modules, they have a defined interface. You call methods from ABAP programs using the CALL METHOD statement.

Methods are introduced with the METHOD statement and concluded with the ENDMETHOD statement.

Methods can only be defined in the implementation parts of classes. You can either do this globally in the Class Builder, or locally within ABAP programs. Methods can work with the attributes of their class and with data that you pass to them using their explicit parameter interface.

ABAP Statements in SAP ABAP

2008-07-30T21:54:00.000+05:30

The source code of an ABAP program consists of comments and ABAP statements.

Comments are distinguished by the preceding signs * (at the beginning of a line) and " (at any position in a line).

ABAP statements always begin with an ABAP keyword and are always concluded with a period (.) . Statements can be several lines long; conversely, a line may contain more than one statement.

ABAP statements use ABAP data types and objects.

Statements and Keywords

The first element of an ABAP statement is the ABAP keyword. This determines the category of the statements. The different statement categories are as follows:

Declarative Statements

These statements define data types or declare data objects which are used by the other statements in a program or routine. The collected declarative statements in a program or routine make up its declaration part.

Examples of declarative keywords:

TYPES, DATA, TABLES

Modularization Statements

These statements define the processing blocks in an ABAP program.

The modularization keywords can be further divided into:

· Event Keywords

You use statements containing these keywords to define event blocks. There are no special statements to conclude processing blocks - they end when the next processing block is introduced.

Examples of event keywords are:

AT SELECTION SCREEN, START-OF-SELECTION, AT USER-COMMAND

· Defining keywords

You use statements containing these keywords to define subroutines, function modules, dialog modules and methods. You conclude these processing blocks using the END- statements.

Examples of definitive keywords:

FORM ..... ENDFORM, FUNCTION ... ENDFUNCTION,
MODULE ... ENDMODULE.

Control Statements

You use these statements to control the flow of an ABAP program within a processing block according to certain conditions.

Examples of control keywords:

IF, WHILE, CASE

Call Statements

You use these statements to call processing blocks that you have already defined using modularization statements. The blocks you call can either be in the same ABAP program or in a different program.

Examples of call keywords:

PERFORM, CALL, SET USER-COMMAND, SUBMIT, LEAVE TO

Operational Statements

These keywords process the data that you have defined using declarative statements.

Examples of operational keywords:

WRITE, MOVE, ADD

Database Statements

These statements use the database interface to access the tables in the central database system. There are two kinds of database statement in ABAP: Open SQL and Native SQL.

Open SQL

Open SQL is a subset of the standard SQL92 language. It contains only Data Manipulation Language (DML) statements, such as SELECT, IINSERT, and DELETE. It does not contain any Data Definition Language (DDL) statements (such as CREATE TABLE or CREATE INDEX). Functions of this type are contained in the ABAP Dictionary. Open SQL contains all of the DML functions from SQL92 that are common to all of the database systems supported by SAP. It also contains a few SAP-specific functions. ABAP programs that use only Open SQL statements to access the database are fully portable. The database interface converts the OPEN SQL commands into commands of the relevant database.

Native SQL

Native SQL statements are passed directly from the database interface to the database without first being converted. It allows you to take advantage of all of your database’s characteristics in your programs. In particular, it allows you to use DDL operations. The ABAP Dictionary uses Native SQL for tasks such as creating database tables. In ordinary ABAP programs, it is not worth using DDL statements, since you cannot then take advantage of the central administration functions of thie ABAP Dictionary. ABAP programs that use Native SQL statements are database-specific, because there is no standardized programming interface for SQL92.

Data Types and Objects

The physical units with which ABAP statements work at runtime are called internal program data objects. The contents of a data object occupy memory space in the program. ABAP statements access these contents by addressing the name of the data object. For example, statements can write the contents of data objects in lists or in the database, they can pass them to and receive them from routines, they can change them by assigning new values, and they can compare them in logical expressions.

Each ABAP data object has a set of technical attributes, which are fully defined at all times when an ABAP program is running. The technical attributes of a data object are: Data type, field length, and number of decimal places.

The data type determines how the contents of a data object are interpreted by ABAP statements. As well as occurring as attributes of a data object, data types can also be defined independently. You can then use them later on in conjunction with a data object. You can define data types independently either in the declaration part of an ABAP program (using the TYPES statement), or in the ABAP Dictionary.

The data types you will use in a program depend on how you will use your data objects. The task of an ABAP program can range from passing simple input data to the database to processing and outputting a large quantity of structured data from the database. ABAP contains the following data types:

Predefined and User-defined Elementary Types

There are five predefined non-numeric data types:

Character string (C), Numeric character string (N), Date (D), Time (T) and Hexadecimal (X)

and three predefined numeric types:

Integer (I), Floating-point number (F) and Packed number (P).

The field length for data types D, F, I, and T is fixed. The field length determines the number of bytes that the data object occupies in memory. In types C, N ,X and P, the length is not part of the type definition. Instead, you define it when you declare the data object in your program.

Data type P is particularly useful for exact calculations in a business context. When you define an object with type P, you also specify a number of decimal places.

You can also define your own elementary data types in ABAP using the TYPES statement. You base these on the predefined data types. This determines all of the technical attribtues of the new data type. For example, you could define a data type P_2 with two decimal places, based on the predefined data type P. You could then use this new type in your data declarations.

You use elementary data types to define individual elementary data objects. You use these object to transfer input and output values, as auxiliary fields in calculations, to store intermediate results, and so on. The aggregated data types described below are made up of elementary data types.

An aggregated data type can be a structure or an internal table.

Structures

A structure is a user-defined sequence of data types. It fully defines the data object. You can either access the entire data object, or its individual components. ABAP has no predefined structures. You therefore need to define your own structures, either in the ABAP program in which you want to use it, or in the ABAP Dictionary.

You use structures in ABAP programs to group work areas that logically belong together. Since the individual elements within a structure can be of any type, and can also themselves be structures or internal tables, the possible uses of structures are very wide-ranging. For example, you can use a structure with elementary data types to display lines from a database table within a program. You can also use structures containing aggregated elements to include all of the attributes of a screen or control in a single data object.

Internal Tables

Internal tables consists of a series of lines that all have the same data type.

Internal tables are characterized by:

· Their line type.

The line type of an internal table can be any ABAP data type - an elementary type, a structure or an internal table.

· A key

The key of an internal table is used to identify its entries. It is made up of the elementary fields in the line. The key may be unique or non-unique.

· The access type

The access method determines how ABAP will access individual table entries. There are three access types, namely unsorted tables, sorted index tables and hash tables.
For index tables, the system maintains a linear index, so you can access the table either by specifying the index or the key.
Hashed tables have no linear index. You can only access hashed tables by specifying the key. The system has its own hash algorithm for managing the table.

You should use internal tables whenever you need to use structured data within a program. One imprint use is to store data from the database within a program.

Data Types for Reference

You use references to refer to objects in ABAP Objects. References are stored in reference variables. The data type of the reference determines how it is handled in the program. There are different types for class and interface variables.

Reference variables in ABAP are treated like other elementary data objects. This means that a reference variable can occur as a component of a structure or internal table as well as on its own.

Declaring Data Objects

Apart from the interface parameters of routines, you declare all of the data objects in an ABAP program or routine in its declaration part. The declarative statements establish the data type of the object, along with any missing technical attributes, such as its length or the number of decimal places. This all takes place before the program is actually executed. The exception to this are internal tables.

When you declare an internal table, you specify the above details. However, you do not need to specify the overall size of the data object. Only the length of a row in an internal table is fixed. The number of rows (the actual length of the data object in memory) is adapted dynamically at runtime. In short, internal tables can be extended dynamically while retaining a fixed structure.

The interface parameters of routines are generated as local data objects, but not until the routine is called. You can define the technical attributes of the interface parameters in the routine itself. If you do not, they adopt the attributes of the parameters from which they receive their values.

Logical Databases and Contexts in SAP ABAP

2008-07-30T21:53:00.001+05:30

This section introduces logical databases and contexts - two methods that make it easier to read data from database tables. Both of them encapsulate Open SQL statements in separate ABAP programs.

Logical Databases

Logical databases are special ABAP programs that read data from database tables. They are used by executable (type 1) programs. At runtime, you can regard the logical database and the executable program (reports) as a single ABAP program, whose processing blocks are called by the runtime environment in a particular, pre-defined sequence.

You edit logical databases using a tool within the ABAP Workbench, and link them to executable programs (reports) when you enter the program attributes. You can use a logical database with any number of executable programs (reports). From Release 4.5A, it is also possible to call logical databases on their own.

Structure of a Logical Database

The following diagram shows the structure of a logical database, which can be divided into three sections:

Structure

The structure of a logical database determines the database tables which it can access. It adopts the hierarchy of the database tables defined by their foreign key relationships. This also controls the sequence in which the tables are accessed.

Selection Part

The selection part of the logical database defines input fields for selecting data. The runtime environment displays these on the selection screen when you run an executable program linked to the logical database. The corresponding fields are also available in the ABAP program, allowing you, for example, to change their values to insert default values on the selection screen.

Database Program

The database program of a logical database is a container for special subroutines, in which the data is read from the database tables. These subrotuines are called by the reporting processor in the runtime environment in a predefined sequence.

Running Type 1 Programs with a Logical Database

The following diagram shows the principal processing blocks that are called when you run an executable program linked to a logical database:

The runtime environment calls depend both on the structure of the logical database and on the definition of the executable program. The structure of the logical database determines the sequence in which the processing blocks of the logical database are called. These in turn call GET event blocks in the executable program. These GET event blocks determine the read depth in the structure of the logical database. TABLES or NODES statements in the declaration part of the executable program determine which of the input fields defined in the logical database are included in the selection screen. They also define interface work areas for passing data between the logical database and the executable program.

The actual access to the R/3 System database is made using OPEN SQL statements in the PUT_subroutines. The data that is read is passed to the executable program using the interface work areas (defined using the TABLES statement). Once the data has been read in the logical database program, the executable program (report) can process the data in the GET event blocks. This technique separates data reading and data processing.

Uses of Logical Databases

The main use of logical databases is to make the code that accesses data in database tables reusable. SAP supplies logical databases for all applications. These have been configured for optimal performance, and contain further functions such as authorization checks and search helps. It is appropriate to use logical databases whenever the database tables you want to read correspond largely to the structure of the logical database and where the flow of the system program (select - read - process - display) meets the requirements of the application.

Contexts

In application programming, you often use a relatively small set of basic data to derive further data. This basic data might, for example, be the data that the user enters on the screen. The relational links in the database are often used to read further data on the basis of this basic data, or further values are calculated from it using ABAP statements.

It is often the case that certain relationships between data are always used in the same form to get further data, either within a single program or in a whole range of programs. This means that a particular set of database accesses or calculations is repeatedly executed, despite the fact that the result already exists in the system. This causes unnecessary system load, which can be alleviated by using contexts.

You define contexts in the Context Builder, which is part of the ABAP Workbench. They consist of key input fields, the relationships between the fields, and the other fields and values that you can derive from them. Contexts can link these derived fields by foreign key relationships between tables, by function modules, or by other contexts.

In application programs, you work with instances of a context. You can use more than one instance of the same context. The application program supplies input values for the key fields in the context using the SUPPLY statement, and can query the derived fields from the instance using the DEMAND statement.

Each context has a cross-transaction buffer on the application server. When you query an instance for values, the context program searches first of all for a data record containing the corresponding key fields in the appropriate buffer. If one exists, the data is copied to the instance. If one does not exist, the context program derives the data from the key field values supplied and writes the resulting data record to the buffer.

Memory Structures of an ABAP Program

2008-07-30T21:52:00.002+05:30

In the Overview of the R/3 Basis System you have seen that each user can open up to six R/3 windows in a single SAPgui session. Each of these windows corresponds to a session on the application server with its own area of shared memory.

The first application program that you start in a session opens an internal session within the main session. The internal session has a memory area that contains the ABAP program and its associated data. When the program calls external routines (methods, subroutines or function modules) their main program and working data are also loaded into the memory area of the internal session.

Only one internal session is ever active. If the active application program calls a further application program, the system opens another internal session. Here, there are two possible cases: If the second program does not return control to the calling program when it has finished running, the called program replaces the calling program in the internal session. The contents of the memory of the calling program are deleted. If the second program does return control to the calling program when it has finished running, the session of the called program is not deleted. Instead, it becomes inactive, and its memory contents are placed on a stack.

The memory area of each session contains an area called ABAP memory. ABAP memory is available to all internal sessions. ABAP programs can use the EXPORT and IMPORT statements to access it. Data within this area remains intact during a whole sequence of program calls. To pass data to a program which you are calling, the data needs to be placed in ABAP memory before the call is made. The internal session of the called program then replaces that of the calling program. The program called can then read from the ABAP memory. If control is then returned to the program which made the initial call, the same process operates in reverse.

All ABAP programs can also access the SAP memory. This is a memory area to which all sessions within a SAPgui have access. You can use SAP memory either to pass data from one program to another within a session, or to pass data from one session to another. Application programs that use SAP memory must do so using SPA/GPA parameters (also known as SET/GET parameters). These parameters are often used to preassign values to input fields. You can set them individually for users, or globally according to the flow of an application program. SAP memory is the only connection between the different sessions within a SAPgui.

The following diagram shows how an application program accesses the different areas within shared memory:

In the diagram, an ABAP program is active in the second internal session of the first main session. It can access the memory of its own internal session, ABAP memory and SAP memory. The program in the first internal session has called the program which is currently active, and its own data is currently inactive on the stack. If the program currently active calls another program but will itself carry on once that program has finished running, the new program will be activated in a third internal session.

Creating and Changing ABAP Programs in SAP ABAP

2008-07-30T21:52:00.001+05:30

ABAP programs are objects of the R/3 Repository. Like all other Repository objects, you maintain them using an ABAP Workbench tool - in this case, the ABAP Editor.

This section provides a brief description of the ABAP Workbench and an overview of how to create and edit ABAP programs. It describes the different ways of starting the ABAP Editor. In the text below, 'open a program' always means 'start the ABAP Editor and use it to open a program'.

Starting the ABAP Editor

To start the ABAP Editor to create or change ABAP programs, the R/3 system offers three possibilities:

Using the Repository Browser

The Repository Browser in the ABAP Workbench (transaction SE80) offers a hierarchical overview of all R/3 Repository objects, ordered by development class, user name of the programmer, object type, and so on. If you enter a program name, you can directly access all of its components, such as the main program, subroutines, and global data. If you select a program object in the Repository Browser and choose Change, the system automatically opens the appropriate tool; in this case, the ABAP Editor.

This method is suitable for complex programs, since the Repository Browser always provides you with an overview of all of the program components.

Using the ABAP Editor

You can open a program directly by choosing ABAP Editor from the initial screen of the ABAP Workbench (Transaction SE38). If you want to change a program using this method, you must already know its name and environment.

This procedure is suited for maintaining or creating relatively simple or short programs, which have few or no additional components.

Using Forward Navigation

In any of the tools in the ABAP Workbench, you can open a different Repository object by positioning the cursor on it and double-clicking. The system automatically opens the object using the correct tool. This also applies to ABAP programs.

Forward navigation by double-clicking is possible wherever an ABAP program is called from another object, such as screen flow logic or another program.

Naming ABAP Programs

The name of an ABAP program can be between 1 and 30 characters long. It cannot contain any of the following characters: Period (.), comma (,), space (), parentheses (), apostrophe (‘), inverted commas ("), equals sign (=), asterisk (*), accented characters or German umlauts (à, é, ø, ä, ß, and so on), percentage signs (%), or underscores (_).

Program Attributes

Like many other Repository objects, ABAP programs have attributes, which are important in determining the function of the program within the R/3 System. For an overview of program attributes, refer to Maintaining Program Attributes.

Source Code

ABAP source code defines the processing logic of R/3 application programs. For an introduction to writing source code, refer to Editing Programs.

Opening a Program from the Repository Browser in SAP ABAP

2008-07-30T21:51:00.002+05:30

To open ABAP programs from the Repository Browser, choose Repository Browser from the ABAP Workbench screen, or start Transaction SE80.

Here you can enter a program name directly or display a list of all programs of a certain development class.

Opening a Specific Program

Enter a program name in the object list and choose Display.

If the program does not yet exist, a dialog screen appears, asking you whether to create the program. Otherwise, the Repository Browser opens the specified program.

Creating a New Program

The dialog box Create Program appears, which allows you to create a TOP INCL (top include program). A Top include is a special include program in which you write your global data declarations. When you create a module pool, begin the name with ‘SAPM’. This allows the system to propose a default name for the Top include that is automatically included in the ABAP Workbench navigation functions.

The ABAP: Program Attributes screen appears, on which you must enter the program attributes. Maintaining the program attributes is an important procedure when creating a program. Enter the program attributes.

Save the program attributes.

The program now exist in the R/3 Repository. You can now either branch directly to the ABAP Editor by choosing Source code, or open the program using the Repository Browser.

Displaying the Programs in a Development Class

Enter the name of an existing development class in the object list and choose Display. The system displays a hierarchical overview of all R/3 Repository objects belonging to the specified development class.

You now have several possibilities:

If the Programs node does not exist on the screen, you can create a program by positioning the cursor on the Object Types Development Class node and choosing Create.

A dialog box appears (Development Objects).Choose the entry Program objects. In the subsequent dialog box (Program Objects) choose the entry Program. Enter a name and choose Create again.

The Create Program dialog box appears. From here, carry on as described in Creating a New Program above.

If the Programs node already exists on the screen, you can position the cursor on it and choose Create to create a new program.
In this case, you can also expand the node to display all of the programs belonging to the development class.

Position the cursor on a program name and double-click or choose Display or Change. This opens the ABAP Editor for the program.

The Repository Browser displays the program as a tree structure with the program as its root node and the individual program components as subnodes. Note that selecting other components of the program does not open the ABAP Editor to display the source code of the program, but always the appripriate tool for the selected component. In special cases, such as for include programs, this can also be the ABAP Editor. However, you then edit only the component and not the source code of the entire program.

Opening Programs in the ABAP Editor

2008-07-30T21:51:00.001+05:30

To open ABAP programs directly using the ABAP Editor, choose ABAP Editor in the ABAP Workbench screen or start Transaction SE38, and enter a program name.

Creating a New Program

If the program does not exist, choose Create. The ABAP: Program Attributes screen appears, on which you must enter the program attributes.

If you create a program in this way, the system does not offer to create a Top include. This way of creating programs is therefore best suited for reports and short test programs. Once you have entered and saved the program attributes, the new program exists in the R/3 Repository.

Maintaining an Existing Program

To edit an existing program, enter its name on the initial screen of the ABAP Editor (Transaction SE38), select one of the following components, and then choose Display or Change.

Source Code

Starts the ABAP Editor.

Variants

Starts the variant maintenance tool. Variants allow you to define fixed values for the input fields on the selection screen of a report.

Attributes

Allows you to change the program attributes (see below).

Documentation

Allows you to write documentation for a particular executable program (report). The system starts the SAPscript Editor, where you can enter the documentation according to the predefined template. When executing the report, the user can display this documentation by choosing System ® Services ® Reporting (Transaction SA38) and Goto ® Documentation. If the report is stored as node in a reporting tree (Transaction SERP), the user can choose Goto ® Display docu. from the tree display to display the documentation.

Text elements

Allows you to edit the text elements of the program. Text elements are all texts that appear on the selection screen or on the output screen of a report.

You can also access any of these components by using the Goto menu in the ABAP Editor itself.

Opening Programs Using Forward Navigation in SAP ABAP

2008-07-30T21:50:00.001+05:30

If you are already working in the ABAP Workbench, you can open a program by positioning the cursor on the program name and double-clicking.

Other ways of foward navigation are always available in the menus of the workbench tools, usually under Goto or Environment.

The following examples show some of the possibilites of forward navigation.

Suppose, you are editing a program and find the line

SUBMIT ZZHKTST 1.

This statement calls an executable program (report) from within another ABAP program.

If you position the cursor on the name ZZHKTST1 and double-click, there are two possibilities:

If the program ZZHKTST1 already exists:

The system opens ZZHKTST1 in the ABAP Editor, and you can read or edit it.

If the program ZZHKTST1 does not exist:

A dialog box appears, asking you if you want to create the program.

After editing ZZHKTST1, you can choose Back to return to the ABAP Editor session of the original program.

In the Repository Browser, open the hierarchy tree of a program that contains at least one screen. Position the cursor on a screen under the Screen node.

If you choose Display, Change, or double-click the screen name, the system opens the Screen Painter and displays the flow logic of the screen.

This usually contains a series of MODULE statements that call ABAP modules in the program.

Position the cursor on a module name and double-click. The system opens the ABAP Editor for the corresponding include program at the position in the program where the relevant module is programmed. The include program is used to modularize the source code of the main program.

If you position the cursor on the name of an include in an INCLUDE statement in the ABAP Editor and double-click, the system opens the include program in the Editor.

Maintaining Program Attributes in SAP ABAP

2008-07-30T21:49:00.002+05:30

In the program attributes, you set the runtime environment of a program, and thus determine how it runs. The most important attribute is the program type. This specifies how the program can be executed.

The program attributes also tell you the application to which the program belongs, and, in the case of executable programs (reports), the name of any associated logical database.

Take care to enter the correct program attributes, otherwise the system will not be able to run the program properly. You maintain the program attributes on the ABAP: Program Attributes screen.

To create an executable program (report), enter 1 in the Type field. To create a module pool, enter M in the Type field. For a list of other possible types, use the possible entries button.

If you create a report (type = 1), choose Enter .

The system automatically displays the input fields for report-specific attributes. Only now are the additional input fields Logical database, from application, and Selection screen visible.

Overview of all program attributes

The following section provides information about program attributes. Note that some of these attributes only apply to executable programs (reports), and not to other ABAP program types. The field help and possible values help for the fields on the ABAP: Program Attributes screen provide further information.

Version

These fields are used for version administration. The system fills them.

Title

In the required entry field Title enter a program description that describes the function of the program. The system automatically includes the title into the text elements of the program. Thus, you can edit the title when maintaining the text elements.

Maintenance Language

The maintenance language is the logon language of the user who creates the program. The system fills this field automatically. You can change the maintenance language, if you maintain the program or its components in another logon language.

Type

In the Type field, you must specify the execution mode of your program.

Use Type 1 (report) to declare your program as executable.. This means that the program can run on its own, and that you can start it in the R/3 system without a transaction code. You can also run executable programs (reports) in the background.

Use Type M to declare your program as a module pool. This means that your program cannot run on its own, but serves as a frame for program modules used for dialog programming. These program modules contain the application logic of a transaction and are called by a separately programmed screen flow logic (programming screens using the Screen Painter tool). The screen flow logic itself can be called via a transaction code only.

Apart form type 1 (for executable programs (reports)) and type M (for module pools), you should also know Type I for include programs. An inlcude program is an independent program with two main functions: On one hand, it contains program code that can be used by different programs. On the other hand, it modularizes source code, which consists of several different, logically related parts. Each of these parts is stored in a different include program. Include programs make your source code easier to read and maintain.

Status

This entry describes the status of the program development; for example, T for test program.

Application

This field contains the short form of your application, for example, F for Financial accounting. This required entry enables the system to allocate the program to the correct business area.

Authorization Group

In this field, you can enter the name of a program group. This allows you to group different programs together for authorization checks. The group name is a field of the two authorization objects S_DEVELOP (program development and program execution) and S_PROGRAM (program maintenance). Thus, you can assign authorizations to users according to program groups. For more information about creating function modules, refer to the Users and Authorizations documentation.

Development Class

The development class is important for transports between systems. You combine all Workbench objects assigned to one development class in one transportation request.

If you are working in a team, you may have to assign your program to an existing development class, or you may be free to create a new class. All programs assigned to the development class $TMP are private objects and cannot be transported into other systems. You can enter the development class directly into this field. Otherwise, the system prompts for it when you save the attributes.

Choosing Local object is equivalent to entering $TMP in the field Development class. You can change the development class of a program later on by choosing, for example, Program ® Reassign in the ABAP: Program Attributes screen.

Logical Database from Application

Only for Executable Programs (Reports)

These attributes determine the logical database used by the executable program (report) to read data, and the application to which it belongs. Logical databases have unique names within their application. However, systemwide, you can have more than one logical database with the same name. This is why you also need to specify the application.

If you read data directly in your program instead of using a logical database, you should enter an application, but leave the logical database field empty.

Selection Screen Version

Only for Executable Programs (Reports)

If you do not specify a selection screen version, the system automatically creates a selection screen based on the selection criteria of the logical datbase and the parameters and select-options statements in the program.

If you want to use a different selection screen, enter the number here (not 1000, since this is reserved for the standard selection screen). The number must be smaller than 1000 and correspond to an additional selection screen of the logical database. The possible values help displays a list of available selection screens. You can also look in the selection include of the logical database (program DBxxxSEL, where xxx is the name of the logical database).

Upper/Lower Case

If you do not want the ABAP Editor to change the case of your code when you display the program, leave this field empty. If you select it, the program code (apart from literals and comments) is converted to uppercase. The screen display depends on the Editor mode.

Editor Lock

If you set this attribute, other users cannot change, rename, or delete your program. Only you will be able to change the program, its attributes, text elements, and documentation, or release the lock.

Fixed Point Arithmetic

If the attribute Fixed point arithmetic is set for a program, the system rounds type P fields according to the number of decimal places or pads them with zeros. The decimal sign in this case is always the period (.), regardless of the user’s personal settings. We recommend that you always set the fixed point arithmetic attribute.

Start Using Variant

Only for Executable Programs (Reports)

If you set this attribute, other users can only start your program using a variant. You must then create at least one variant before the report can be started.

Editing Programs in SAP ABAP

2008-07-30T21:49:00.001+05:30

You edit programs using the ABAP Editor. For detailed information, refer to the appropriate documentation. Below are a few hints to help you to get started:

Program Structure

The following gives a short overview on how to structure a program. Apart from the first statement, the sequence of statements is not obligatory, but you should keep to it for reasons of clarity and readability.

The first program statement

The first statement of an ABAP program must always be the statement REPORT or PROGRAM, respectively (only exception: FUNCTION-POOL for function modules). Both statements have exactly the same function.

The name specified in the statements REPORT and PROGRAM must not necessarily be the program name, but for documentation reasons, you should use the correct name.

The statements REPORT or PROGRAM can have several options, such as LINE-SIZE, LINE-COUNT, or NO STANDARD PAGE HEADING. You use these options mainly in programs that which evaluate data and display the results in a list. For other options, such as the definition of a message class, see the key word documentation.

Whenever you create a new program, the system automatically inserts the first ABAP statement, for example:

REPORT . for executable programs (reports) or

PROGRAM . for dialog programs

As report or program name, the system enters the name you used to create the program.

Data declaration

Next, insert all of your delclarations. This includes the global data definitions, selection screen definitions, and the definitions of classes and interfaces in ABAP Objects.

Processing logic

After the declarations, write the processing logic. This consists of a series of processing blocks.

Subroutines

At the end of your program, include its internal procedures (subroutines and methods).

Using includes to split up a program into a series of source code modules does not change this basic structure. If, for example, you follow the forward navigation of the ABAP Workbench when creating a dialog program, the system automatically creates a number of include programs, which contain the program parts described above in the correct sequence. The top include program usually contains the PROGRAM statement and the global data declaration. The subsequent include programs contain the individual dialog modules, ordered by PBO and PAI. There may also be further includes, for example, for subroutines. These include programs do not influence the program function, they only serve to make the program order easier to understand.

Program Layout

A high-quality ABAP program observes the following layout standards:

Comment Your Programs

Ensure that your program is correctly commented. For example, at the beginning of a subroutine, explain what it does, and provide any necessary information and references. The ABAP Editor provides predefined comment blocks. Comments within lines of code should be used sparingly, and only where they do not make the program flow more difficult to understand.

Indent Blocks of Statements

You should combine statements that belong together into a single block. Indent each block by at least two columns:

Use Modules

Make your programs easier to understand by using modules. For example, writing a large processing block as a subroutine makes the logical structure of your program easier to recognize. Subroutines may increase the overall length of programs, but you will soon find that this method greatly increases clarity, especially in the case of complex programs.

Use the Pretty Printer

If you use the Pretty Printer in the ABAP Editor, your programs will conform to the layout guidelines. To use the Pretty Printer, choose Program ® Pretty Printer from the Editor screen.

Statement Patterns

In the ABAP Editor, you can use statement patterns to help you write your program. They provide the exact syntax of a statement and follow the ABAP layout guidelines. You can insert two kinds of predefined structures into your program code when using the ABAP Editor: Keyword structures and comment lines. In the ABAP Editor, choose Edit ® Insert statement. To display a list of all predefined keyword structures, place the cursor in the Other pattern. field and click the possible entries button to the right of the input field.

Checking Programs

When you have finished editing, or reach an intermediate stage of the program, choose Check to check the syntax. The system checks the program coding for syntax errors and compatibility problems. If it finds an error, it displays a message describing it and, if possible, offers a solution or correction. The system positions the cursor on the error in the coding. Once you decide that your program is finished, run the extended program check on it by choosing Program ® Check ® Ext. program check from the Editor screen. Ensure that you correct all of the errors and warnings displayed. Although they do not prevent the program from working, they are not examples of good programming. Furthermore, some warnings might be escalated to syntax errors in future releases.

Saving and Activating Programs

Choose Save to save the source code.

The system stores the source code in the program library. Before you can execute the program from outside the ABAP Editor, you must generate an active version using the Activate function.

Testing Programs

You can test executable programs in the ABAP Editor. To do so, choose Program ® Execute. The system then creates a temporary runtime object with a name that differs from the program name. However, the system executes the program as if started outside the ABAP Editor. If you created an ABAP module pool, you cannot test the program in the ABAP Editor. You must create a transaction code and a screen flow logic before you can execute the program.

Testing a program often involves a runtime analysis, which shows you the amount of time your program consumes in the client/server environment of the R/3 system and what this time is used for. For more information, refer to the runtime analysis documentation.

ABAP Syntax

2008-07-30T21:48:00.000+05:30

The syntax of the ABAP programming language consists of the following elements:

Statements

An ABAP program consists of individual ABAP statements. Each statement begins with a keyword and ends with a period.

PROGRAM FIRST_PROGRAM.

WRITE 'My First Program'.

This example contains two statements, one on each line. The keywords are PROGRAM and WRITE. The program displays a list on the screen. In this case, the list consists of the line "My First Program".

The keyword determines the category of the statement. For an overview of the different categories, refer to ABAP Statements.

This diagram shows the structure of an ABAP statement.

Formatting ABAP Statements

ABAP has no format restrictions. You can enter statements in any format, so a statement can be indented, you can write several statements on one line, or spread a single statement over several lines.

You must separate words within a statement with at least one space. The system also interprets the end of line marker as a space.

The program fragment

PROGRAM TEST.
WRITE 'This is a statement'.

could also be written as follows:

PROGRAM TEST. WRITE 'This is a statement'.

or as follows:

PROGRAM
TEST.
WRITE
'This is a statement'.

Use this free formatting to make your programs easier to understand.

Special Case: Text Literals

Text literals are sequences of alphanumeric characters in the program code that are enclosed in quotation marks. If a text literal in an ABAP statement extends across more than one line, the following difficulties can occur:

All spaces between the quotation marks are interpreted as belonging to the text literal.

Letters in text literals in a line that is not concluded with quotation marks are interpreted by the editor as uppercase.

If you want to enter text literals that do not fit into a single line, you can use the ‘&’ character to combine a succession of text literals into a single one.

The program fragment

PROGRAM TEST.
WRITE 'This
is
a statement'.

inserts all spaces between the quotation marks into the literal, and converts the letters to uppercase.

This program fragment

PROGRAM TEST.
WRITE 'This' &
' is ' &
'a statement'.

combines three text literals into one.

Chained Statements

The ABAP programming language allows you to concatenate consecutive statements with an identical first part into a chain statement.

To concatenate a sequence of separate statements, write the identical part only once and place a colon (:) after it. After the colon, write the remaining parts of the individual statements, separating them with commas. Ensure that you place a period (.) after the last part to inform the system where the chain ends.

Statement sequence:

WRITE SPFLI-CITYFROM.
WRITE SPFLI-CITYTO.
WRITE SPFLI-AIRPTO.

Chain statement:

WRITE: SPFLI-CITYFROM, SPFLI-CITYTO, SPFLI-AIRPTO.

In the chain, a colon separates the beginning of the statement from the variable parts. After the colon or commas, you can insert any number of spaces.

You could, for example, write the same statement like this:

WRITE: SPFLI-CITYFROM,
SPFLI-CITYTO,
SPFLI-AIRPTO.

In a chain statement, the first part (before the colon) is not limited to the keyword of the statements.

Statement sequence:

SUM = SUM + 1.

SUM = SUM + 2.

SUM = SUM + 3.

SUM = SUM + 4.

Chain statement:

SUM = SUM + : 1, 2, 3, 4.

Comments

Comments are texts that you can write between the statements of your ABAP program to explain their purpose to a reader. Comments are distinguished by the preceding signs * (at the beginning of a line) and " (at any position in a line). If you want the entire line to be a comment, enter an asterisk (*) at the beginning of the line. The system then ignores the entire line when it generates the program. If you want part of a line to be a comment, enter a double quotation mark (") before the comment. The system interprets comments indicated by double quotation marks as spaces.

************************************************
* PROGRAM SAPMTEST *
* WRITTEN BY KARL BYTE, 06/27/1995 *
* LAST CHANGED BY RITA DIGIT, 10/01/1995 *
* TASK: DEMONSTRATION *
************************************************

PROGRAM SAPMTEST.

************************************************
* DECLARATIONS *
************************************************

DATA: FLAG " GLOBAL FLAG
NUMBER TYPE I " COUNTER

......

************************************************
* PROCESSING BLOCKS *
************************************************

......

Processing Data in SAP ABAP

2008-07-30T21:47:00.000+05:30

This section describes how to work with data objects in ABAP.

It contains the following topics:

Assigning Values

Numeric Operations

Processing Character Strings

Single Bit Processing in Hexadecimal Fields

Type Conversions

Processing Sections of Strings

LESSON 25 CALLING PROGRAM AND PASSING DATA

2008-07-30T21:46:00.001+05:30

CALLING PROGRAM AND PASSING DATA:

There are two ways of starting an ABAP program from another ABAP program that is already running:

By interrupting the current program to run the new one - the called program is executed, and afterwards, processing returns to the program that called it.

By terminating the current program and then running the new one.
Complete ABAP programs within a single user session can only run sequentially. We refer to this technique as using synchronous calls.

If you want to run functions in parallel, you must use function modules. For further information about this technique, refer to course BC415 (Communication Interfaces in ABAP), and the documentation for the CALL FUNCTION … STARTING NEW TASK… statement.
The way in which main memory is organized from the program's point of view can be represented easily in the above model. There is a distinction between internal and external sessions:

Generally, an external session corresponds to an R/3 window. You create new external sessions by choosing System ® Create session or entering /o in the command field. You can have up to six external sessions open simultaneously in one terminal session.

External sessions are subdivided into internal sessions . Each program that you run occupies its own internal session. Each external session can contain up to nine internal sessions.

The data in a program is only visible within that internal session, so it is only visible to the program.

The following pages illustrate how the stack inside an external session changes with various program calls.

When you insert a program, the system creates a new internal session, which contains the new program context.

The new session is placed on the stack The program context of the calling program also remains on the stack.

When the called program finishes, its internal session (the top one in the stack) is deleted.

Processing is resumed in the next-highest internal session in the stack.
When you end a program and start a new one, there is a difference between calling an executable program and calling a transaction.

If you start an executable program using its program name, the internal session of the program you are ending (the top one) is removed.

The system creates a new internal session, which contains the program context of the called program. The new session is placed on the stack. Any program contexts that already existed are retained. The topmost internal session on the stack is replaced.
If you start a program using its transaction code (if one is assigned), all of the existing internal sessions are removed from the stack.

The system creates a new internal session, which contains the program context of the called program.

After the call, the ABAP memory is reset.
When you call a function module, the ABAP runtime system checks whether you have already called a function module from the same function group in the current program.

If this is not the case, the system loads the relevant function group into the internal session of the calling program. Its global data is initialized and the
LOAD-OF-PROGRAM event is triggered.

If your program had already used a function module from the same function group before the call, the function group is already resident in the internal session, and the new call can access the same global data. We say that the function group remains active until the end of the program that called it.

The data is only visible in the corresponding program - each program can only address its own data, even if there are identically-named objects in both programs. The same applies when the stack is extended. If a program is added to the stack that calls a function module from a function group already called by another program, the function group is loaded again into the new internal session.

The system creates new copies of its data objects, initializes them, and, as before, they are only visible within the function group, and only in the internal session in which the function group was loaded.

To start an executable (type 1) program, use the SUBMIT statement.
If you use the VIA SELECTION-SCREEN addition, the system displays the standard selection screen of the program (if one has been defined).

If you use the AND RETURN addition, the system resumes processing with the first statement after the SUBMIT statement once the called program has finished.
For further information, refer to the documentation for the SUBMIT statement.
When you use the LEAVE TO TRANSACTION '' statement, the system terminates the current program and starts the transaction with transaction code . The statement is the equivalent of entering /n in the command field.

CALL TRANSACTION '' allows you to insert an ABAP program with a transaction code into the call chain.

To terminate an ABAP program, use the LEAVE PROGRAM statement. If the statement occurs in a program that you called using CALL TRANSACTION '' or SUBMIT AND RETURN, the system resumes processing at the next statement after the call in the calling program. In all other cases, the user returns to the application menu from which he or she started the program.

If you use the …AND SKIP FIRST SCREEN addition, the system does not display the screen contents of the first screen in the transaction. However, it does process the flow logic.

If you started a transaction using CALL TRANSACTION that uses update techniques, you can use the UPDATE… addition to specify the update technique (asynchronous (default), synchronous, or local) that the program should use.

There are various ways of passing data to programs running in separate internal sessions:

You can use

The interface of the called program (usually a standard selection screen)
ABAP memory
SAP memory
Database tables
Local files on your presentation server

Function modules have an interface that the calling program and the function module use to exchange data. Subroutines also use a similar technique. Certain restrictions apply to the interfaces of remote enabled
function modules.

When you call ABAP programs that have a standard selection screen, you can pass data for the input fields in the call. There are two ways to do this:

By specifying a variant for the selection screen when you call the program.

By specifying values for the input fields when you call the program.
The WITH addition in the SUBMIT statement allows you to assign values to the fields on a standard selection screen. The abbreviations "EQ, NE, … , I, E" have the same meanings as with select options.

If you want to pass several selections to a selection option, you can use the RANGES statement instead of individual WITH additions. The RANGES statement creates a selection table , which you can fill as though it were a selection option. You then pass the whole table to the executable program.

If you want to display the standard selection screen when you call the program, use the VIA SELECTION-SCREEN addition.

When you use the SUBMIT statement, use the Pattern function in the ABAP Editor to insert an appropriate statement pattern for the program you want to call. It automatically suppplies the names of the parameters and selection options that are available on the standard selection screen.

The example shown above is an extract from transaction BC402_CALD_CONN. When the user requests the coordinates of a city, the executable program SAPBC402_TABD_HASHED is called.

The parameters are filled with the city and country code from the transaction. The standard selection screen does not appear.

For further information about working with variants and about other syntax variants of the WITH addition, refer to the documentation for the SUBMIT statement.
To pass data between programs, you can use either the SAP memory or the ABAP memory.

SAP memory is a user-specific memory area that you can use to store field values. It is only of limited value for passing data between internal sessions. Values in SAP memory are retained for the duration of the user's terminal session. The memory can be used between sessions in the same terminal session. You can use the contents of SAP memory as default values for screen fields. All external sessions can use the SAP memory.

ABAP memory is also user-specific. There is a local ABAP memory for each external session. You can use it to exchange any ABAP variables (fields, structures, internal tables, complex objects) between the internal sessions in any one external session.
When the user exits an external session (/i in the command field), the corresponding ABAP memory is automatically initialized or released.

Use the EXPORT … TO MEMORY statement to copy any number of ABAP variables with their current values (data cluster) to ABAP memory. The ID… addition (maximum 32 characters long) enables you to identify different clusters.
If you use a new EXPORT TO MEMORY statement for an existing data cluster, the new one will overwrite the old.

The IMPORT… FROM MEMORY ID… statement allows you to copy data from ABAP memory into the corresponding fields of your ABAP program. In the IMPORT statement, you can also restrict the selection to a part of the data cluster.

The variables into which you want to read data from the cluster in ABAP memory must have the same types in both the exporting and the importing programs.
To release a data cluster, use the FREE MEMORY ID… statement.
Remember when you call programs using transaction codes that you can only use the ABAP memory to pass data to the transaction.

You can define memory areas (parameters) in the SAP memory in various ways:

By creating input/output fields with reference to the ABAP Dictionary. These take the parameter name of the data element to which they refer.
Alternatively, you can enter a name in the attributes of the input/output fields. Then, you can also choose whether the entries from the field should be transferred to the parameter (SET), or whether the input field should be filled with the value from the parameter (GET).
To find out about the names of the parameters assigned to input fields, display the field help for the field (F1), then choose Technical info.

You can also fill a memory area directly using the statement
SET PARAMETER ID '' FIELD .
and read it using the statement GET PARAMETER ID '' FIELD .

You can also define parameters using the Object Navigator and fill them with values.

When you call a transaction using the statement CALL TRANSACTION '' USING … you can run the transaction using the values from in the screen fields. The internal table must have the structure bdcdata.

The MODE addition allows you to specify whether the screen contents should all be displayed ('A' - the default setting), only when an error occurs ('E'), or not at all ('N'). You can use the MESSAGE INTO to specify an internal table into which any system messages should be written. The internal table must have the structure bdcmsgcoll. You can find out if the transaction was executed successfully from the system field sy-subrc.

You might use this technique if

You are processing in the foreground, but the input fields have not been filled using GET parameters.

You want to process the transaction invisibly. In this case, you normally have to pass the function codes in the table as well.

This technique is also one of the possible ways of transferring data from non-SAP systems. When you do this, the internal table with the structure bdcdata must be filled completely.

Filling the internal table in batch input format:

Each screen that you want to process automatically in the transaction must be identified by a line in which only the fields program, dynpro, and dynbegin are filled.

After the record that identifies the screen, use a new bdcdata record for each field you want to fill. These records use the fields fnam and fval. You can fill the following fields:
• Input/output fields (with data)
• The command field bdc_okcode, (with a function code)
• The cursor positioning field, bdc_cursor (with a field name)

The filled internal table in bdcdata format is illustrated above. At runtime, stands for the customer name from the input field, stands for the city.

You use the field BDC_OKCODE to address the command field, into which you enter the function code that would have been triggered by the user choosing a function key, pushbutton, or menu entry in dialog mode (or by entering a code directly in the command field).

LESSON 26 TECHNIQUES FOR LIST CREATION AND SAP QUARY

2008-07-30T21:45:00.000+05:30

TECHNIQUES FOR LIST CREATION AND SAP QUARY:

The QuickViewer is a tool for developing ad hoc reports that is new in Release 4.6A. You can start the QuickViewer using the menu path QUV-1.

The QuickViewer can use a database table or a database view as a data source. Lists can be generated using the fields in the data source specified. Two modes are available for this: basis mode and layout mode The QuickViewer provides interfaces, for example, to the EIS, ABC analysis or the ALV Grid Control. The list can also be processed further in external programs, such as Word.

The generated list can be saved and then displayed again in the QuickViewer. Selection criteria are also saved along with the list, and can be queried again at any time.

Each user defines their own user-specific QuickViews which only they can display. This means that you cannot copy other users' QuickViews. You can, however, compile an SAP Query from a QuickView, if the QuickView uses a functional area from the standard system as a data source (see unit 'SAP Query - Creating Lists'). The query is then visible to the user group.

QuickViews are not connected to the correction and transport system.

You must name a data source in order to generate a QuickView. The data source can be a database table, a database view, a logical database, a table join, or even a functional area of SAP query. The functional area must lie in the (client-specific) standard area.

You can access the specified data, but you cannot extend it with additional fields (also see Local fields under SAP Query).

When you specify a table join as the data source, you have to define the join before you can structure the list in Query Painter.

You define the table join graphically. You have to specify the links between the tables, and you can have the system propose a value. It does this using information from the Dictionary .

You determine the resulting quantity by deciding on either Inner or Left Outer Join logic. For example, if you only want to output airlines from table SCARR in a list when these airlines have flights in table SPFLI, this corresponds to the Inner Join logic. In contrast, if you want to output all the airlines regardless of whether flights exist in table SPFLI, then you would link both tables using Left Outer Join logic. In this case, the left table is SCARR.

Alias tables enable you to use the same (database) table several times when defining the join

In basic mode, the screen is divided into four areas. The available fields (data source) are displayed to the left in tree form. Further information on how to work in the basic mode is displayed in the lower left window. You can maintain the title and comments and control the output (list or Excel) in the upper right area. This is also where you control the list structure, set the sort sequence and define the selection criteria. You can branch to the online documentation from the lower right window.

You can structure your Quick View using two table controls. Select the fields you want in your list in the right table control and use the transfer functions to move them to the left table control ('List fields'). You can also control how many lines the list should have (using the 'Add line' function) in the left table control ('List fields').

Follow the same procedure for the sort and selection fields: select the fields you require in the right table control and copy them to the left control.

You can structure your Quick View using two table controls. Select the fields you want in your list in the right table control and use the transfer functions to move them to the left table control ('List fields'). You can also control how many lines the list should have (using the 'Add line' function) in the left table control ('List fields').

Follow the same procedure for the sort and selection fields: select the fields you require in the right table control and copy them to the left control.

When you create a list with a report, the data is usually retrieved via a logical database, processed by the report and then output as a list.

Queries evaluate data and can be created without any prior programming knowledge using the SAP Query tool.

The query results in a sequence of screen fields which you use to describe the line structure and list layout. Starting in Release 4.6A, you can use the Query Painter to add graphics to query lists.

When the query is started, an internal report generator creates a program that corresponds to the list definition. That program then reads the data, processes it, and outputs the data as a list. The program is named AQmmbbbbbbbbbbbbqqqqqqqqqqqqqq. You can display the report names with the menu path displayed in appendix documentation AQL-1.
mm - encoded client (standard area) or ZZ (global area)
bbbbbbbbbbbb - Name of user group (12 places)
qqqqqqqqqqqqqq - Name of query (14 places)
Spaces in query program names are replaced with '='.

The administrative tasks in the query environment include creating functional areas and user groups, as well as assigning the functional areas to the user groups.

The functional area determines the tables (and the fields of those tables) to which a query can refer.
Functional areas are frequently based on logical databases.

Users may create and start queries only when they belong to at least one user group. A given user can belong to several user groups. Users in a user group all have the same privileges.

Functional areas are allocated to a user group; the members of a group can access the functional area to which the group is allocated.

A functional area can be allocated to several user groups.

Several functional areas can be allocated to a user group.

Queries are always created for a specific user group and a specific functional area. Users in a user group have access to all the queries allocated to that group.

If you have been allocated to several user groups, you can switch within these groups.

A query is always created from a specific functional area. The functional area must be allocated to the user group in which the query was created.

You can access all queries that have been allocated to your user group.

If you are authorized to define a query with a functional area, you can list all the queries for that functional area.

You can only copy a query from a different user group to your user group when the functional area of the query to be copied has also been allocated to your user group.

The query results in a sequence of screen fields in which you use

Selection (checkboxes)
Number assignment (sequence, sort, ...)
Texts (headers, group level texts) to determine the line structure and the list layout.

Starting in Release 4.6A, you can use the Query Painter to add graphics to basic lists.

You can use SAP Query to generate different types of lists (partial lists):

Basic List: Single line or multiline. Multiline basic lists can be compressed.
Statistics, ranked lists: Require a numeric field. Data can be compressed.
You can combine different partial lists in a single query. Starting in 4.6A, you can also print the individual partial lists.

You can also define local fields within a query, which means you can calculate new values from the collected data.

While you cannot generate interactive lists you have defined yourself, some standard interaction functions are available. For example, you can pass on the generated lists for further processing (Excel, EIS, ABC analysis), display them in graphical form (SAP Graphics), save them, or edit them in table form (table control and ALV grid control).

You can use the menu paths displayed in appendix documentation AQL-2 to create, change, and execute queries with the ABAP Workbench.

Queries are created either in the standard area or the global area. A query area covers a set of query objects that are internally complete and consistent - this means objects with the same name but with a different meaning can exist in the various query areas. The global and standard areas have separate namespaces.

The standard area is client-specific and is not linked to the Workbench Organizer (WBO). The query objects in the global area are available in all clients and linked to the WBO. If you create a query in the global area, you have to assign it to a development class.

When creating a query, you must first choose a functional area. The system displays all the functional areas that have been assigned to your user group. Once you have chosen a functional area, you cannot modify your choice: the functional area is the basis for data retrieval.

SET/GET parameters AQW and AQB are available and can be used in your user parameters to define default settings for the query area (global area: AQW = G) and your user group.

When selecting fields, the system leads you through the following screens:

Title, format:

Used to assign the query title You can set the page layout by making entries for the format. You can also set additional characteristics for the query with special attributes.

Functional area

Functional areas are divided into functional groups. These form logical groups of data. You choose the required functional groups here.

Field Selection

Here you choose the required data fields of the previously selected functional groups. If you require local fields, you can also define them here.

Selection fields:

You can define fields to add to the selection screen and further limit the selection criteria.

Depending on which type of list you want to generate, edit the screen fields or use layout mode (Query Painter) for the basic list. You always have to use the Field selection screen field to create local fields.

By defining local fields, you can generate additional information from the fields that are available in a functional area.

If pre-existing fields are required for the definition of a local field, short descriptions must be provided (see the menu path displayed in appendix documentation AQL-3).

A short description can be assigned for each field.

Short descriptions are also used to retrieve values of the corresponding fields in the list headers.

You can define local fields for a query (menu path AQL-4)

Local fields are defined with calculation rules. In the simplest case, calculation rules consist of a single formula formed with normal mathematical rules and consisting of operands and operators.

The calculation of a field's value can be made condition-dependent. In this case, values are calculated according to certain rules only when a particular condition is met. If the condition remains unmet, the field receives a default value. Multiple conditions are allowed.

You can sort the values of key columns of statistics in ascending or descending order.

Numerical fields in statistics are accumulated. Statistics only make sense with numerical fields.

Statistics allow you to display the average value, the percentage breakdown, and the number of records read for each numerical field.

You can define up to 9 statistics individually or as a supplement to a basic list.

If you work with different currency or quantity fie lds within statistics, you must enter a reference currency or a reference unit for each field, so that the system can convert it into that currency or unit.

The list displays the conversions processed by the system. In the event of an error, the system logs any conversions that did not take place. In addition, the system highlights the affected currency or quantity fields within the statistics.

With the appropriate definition, subtotal lines can also appear within statistics. If you compress the statistics, the system displays only the subtotal lines and the grand total.

Ranked lists are special forms of statistics. However, they are always sorted based on one numerical value. This value is referred to as the ranked list criterion. In addition, the system only outputs a certain number of records.

Ranked lists are sorted according to only one fie ld, and the number of output lines is limited.

You can define up to 9 ranked lists individually or as supplements to a basic list.

You can also define each ranked list as statistics.

The rules for conversions of currency and quantity fields also apply to ranked lists.

To create basic lists, use the Query Painter. In the Query Painter, the screen is divided into four areas. The available fields (data source) are displayed to the left in tree form. The list structure is displayed with sample data in the upper right area. Information for the currently active element is displayed in the lower left portion of the window. Links to documentation and any warnings that are output while formatting the list are displayed in the lower right section of the window.

You can edit list characteristics (frame, width) by selecting a field, right-clicking with the mouse and choosing 'List options' from the menu. While editing, you are working in the lower left window. If you have created new characteristics, then you need to confirm the values you have changed using the APPLY function.

You can edit list line characteristics (color, separators, and so on) by selecting a field, right-clicking with the mouse and choosing 'Line options' from the menu. While editing, you are working in the lower left window. If you have created new characteristics, then you need to confirm the values you have changed using the APPLY function.

You can edit field characteristics in the lower left window by selecting the appropriate field. Further field characteristics are available in the menu displayed with the right mouse button.

You can move column and list headers to a mode that is ready for input by double -clicking.

Selecting a field in the upper left window automatically adds that field to the list (is appended at the end of the current line). The individual fields are represented by field values. Sample data records are read from the source. If this is not possible, field values are simulated. The structure of the layout determines the structure of the subsequent list - that is, it contains the order of the fields, the headers, the colors, totals lines, and so on. To display the list structure for multi line hierarchy lists, several sample records are read and displayed.

In addition, tools are available in the Query Painter to design the list. You can change the arrangement of the tools with drag and drop. Select the tool, such as the trash (a frame is displayed), with the left mouse button. You can now drag the selected area to the new position as long as you keep pressing the left mouse button.

You can also use drag and drop to edit the list. Example: You want to change the field sequence. To do this, point the mouse at the field you want to move, click and hold the left mouse button (the cursor changes), drag the field to the desired location, and release the mouse button. To delete a field, just drag it to the trash.

You can also change the output position and output length with entries in the lower left window.

Press Apply to apply your values to the list structure.

You can set up control level lists. To do this, you have to determine the sort fields. The sort sequence can be defined in either ascending or descending order separately for each field. To create a sort field, drag a field from the list to the Sort tool.

You can define control levels with or without a total at the end of the control level (subtotal). You can change the text accompanying the subtotals.

If you total a field, the total is output to the same column as the field, with the same output length. Accordingly, the output length may be too short and result in an overflow (an asterisk appears in the first position of the value). To prevent overflows of totals, you can simply increase the output length of the field you wish to total.

You can output blank lines and/or force a page break before outputting control levels.

You can hide and change introductory and concluding texts for control levels.

The system automatically creates a currency distribution for currency totals.

List overview:

If your list consists of several partial lists, for example a basic list, two statistical lists and a ranked list, the system offers you the ability to display the partial lists individually. The partial lists can also be printed separately.

Report/report interface (RRI): You can use this interface to call query programs (receiver) and other reports (sender). Additional information is available in the online documentation.

Table display: The list is displayed as a table control or using the ALV grid control. Starting in Release 4.6A, you can also display multi line lists. The different lines are summarized in one line. Graphics: The information contained in a list can be displayed with SAP Presentation Graphics.

File storage, private storage: Saves the data as a file on the presentation server or in the private folders.

Word processing and spreadsheets: Transfer data to MS Word or Excel (for example)

Selection: Indicates which selections were input in the selection screen.

Drilldown functions: For expanding and collapsing the list.

Totaling: Totals for numeric fields.

You can save a list generated by a query using the menu path AQL-5 and re-display it later.

Subsequent display of a saved list does not require database access to retrieve data. Such a display is therefore much quicker than restructuring the data running the query again.

Saving a list stores the list itself and supplemental information. Storage of additional information is a special function of saving lists that is supported only by query. This makes it possible to perform interactive functions in the saved list.

When a query is integrated in an area menu (not the AQ... query program), then all the saved lists are automatically passed on to the area menu, and can be displayed there. All interactive functions remain available.

If you save the list 'normally' (using menu path AQL-6), then no interactive functions are available in the saved list.

LESSON 29 SELECTION SCREENS ABAP REPORT

2008-07-30T21:43:00.001+05:30

SELECTION SCREENS:

Selection screens serve as the interface between the program and the user, and allow, for example, limitation of the amount of data to be read from the database.

Logical databases supply selection screens whose concrete appearance is dependent on the specified node name (NODES). Selection screen versions (if supplied by the logical database) offer a subset of default selection screens.

You can use the declarative language elements PARAMETERS and SELECT-OPTIONS to generate a default selection screen (screen 1000) with input-ready fields.

In addition to the default selection screen, you can generate additional selection screens with SELECTION-SCREEN BEGIN .... and call them with CALL SELECTION-SCREEN.

You can create variants of a selection screen. A variant is a user-specific selection variant. You would create a screen variant if you frequently start a program with the same selection variants or start in background processing.

The PARAMETERS statement is a declarative language element. As in the case of the DATA statement, you can declare the fields with TYPE or LIKE. The system generates input-ready fields in the selection screen. The names of PARAMETERS fields can be up to 8 characters long. You can maintain selection texts (parameter names) with the function Text elements/Selection texts.

You can set a default value with the DEFAULT addition. If you assign a MEMORY ID , the system uses SAP Memory and the SET/GET parameter to set the default value. If you declare mandatory fields with the OBLIGATORY addition, users cannot leave the selection screen until values have been entered in these fields.

You can also define parameters as checkboxes (AS CHECKBOX). Doing so creates a one-character field that can contain a " "(SPACE) or an "X". You can evaluate the contents of checkboxes using IF/ENDIF control structures.

You can also define a series of radio buttons for the selection screen with the addition RADIOBUTTON GROUP . The maximum length name for a RADIOBUTTON GROUP is 4 characters. Only one radio button in a group can be active and can be evaluated during program processing. You can evaluate the contents of radio buttons using CASE/ENDCASE control structures.

The SELECT-OPTIONS statement is a declarative language element. In contrast to the PARAMETERS statement, it allows complex selections instead of just one input-ready field.

SELECT-OPTIONS generates an internal table with a standard structure. This consists of 4 fields: seltab-sign, seltab-option, seltab-low, and seltab-high. The name of selection table can contain up to 8 characters. You can maintain selection texts (name of the selections) with the function Text elements/Selection texts.

Use the addition FOR to specify the field against which the system should check the selection entries. This field must be declared in a DATA or TABLES statement. The fields seltab-low and seltab-high possess the same field characteristics as the check field.

Each line of the selection table formulates a condition using one of the following relational operators. The following values are possible:

SIGN: I (Include), E (Exclude)

OPTION: EQ, NE, LE, LT, GE, GT, BT(Between), NB (Not Between),
CP (Contains Pattern), NP (Contains Pattern not)

The selection set is the union of all includes (I1,..., In) minus the union of all excludes (E1, ..., Em). If the table remains empty, selection is performed using the total selection set, if you are working in the SELECT statement with WHERE IN .

When you make entries on a selection screen, the system populates the internal table . Standard entries for the fields seltab-sign and seltab-option are I and EQ for individual selections, and I and BT for ranges.

To change the default entries for seltab-sign and seltab-option, choose Selection options (double click on the appropriate entry field or activate the pushbutton). The system offers all the alternatives for fields seltab-sign and seltab-option that are appropriate for the selection. If the traffic signal icon is green during Select, there is an I in seltab-sign; a red light indicates E.

To delete a table entry, use the appropriate pushbutton (Delete selection).

Every selection criterion can be used to make multiple selections unless defined otherwise. If multiple selections are present, the color of the arrow changes from white to green.

Additions to the SELECT-OPTIONS statement:
DEFAULT enables you to set default values for seltab-low (single value) or seltab-low and seltab-high (interval). You can use OPTION and SIGN to set default values for seltab-option and seltab-sign that differ from the normal defaults.
MEMORY ID allocates a SPA/GPA parameter. The value stored in SAP Memory with the ID is placed in seltab-low (lower interval limit) when you call the selection screen.

LOWER CASE suppresses conversion of the entry into upper-case. This addition is
not permitted for Dictionary fields, since the attribute set in the Dictionary takes
precedence.

OBLIGATORY generates a mandatory field. A question mark appears in the entry field in the selection screen, and the user must enter a value.

NO-EXTENSION suppresses multiple single or multiple range selections.
NO INTERVALS suppresses the seltab-high (upper interval limit) entry on the selection screen. You can use the additional screen, Multiple selection, to enter ranges.

If you entered a logical database in the attributes of the type 1 program, the selection screen of the logical database is processed. If you have programmed additional SELECTION-OPTIONS or PARAMETERS statements, the system displays them after the selections of the logical database.

You can use the SELECTION-SCREEN statement to design the layout of the selection screen. You can group selections that belong together logically with the supplemental BEGIN OF BLOCK and place a frame around them using WITH FRAME. You can assign a title to the block, but you can only use the addition TITLE together with a frame.

You can nest framed blocks to a maximum of 5 frames.

Before de signing a selection screen, you should orient yourself to the screen design guidelines found in the sample transaction BIBS.

You can display multiple parameters and comments in one output line. To do so, you must enclose them between the SELECTION-SCREEN BEGIN OF LINE and SELECTION-SCREEN END OF LINE statements. The COMMENT parameter enables you to include text in the line.

Comment texts must always have a format (position and output length). The position can be set with a data field, pos_low or pos_high. These are the positions for fields seltab-low and seltab-high on the selection screen.

Adding COMMENT ... FOR FIELD ensures that the F1 Help for field is displayed for the comment text and for the parameter itself. If you hide the parameter (selection variant: attribute invisible) the comment text is also hidden.

You can use POSITION to set the cursor for the next output position (only within ... BEGIN OF LINE ... END OF LINE).

The INITIALIZATION event is processed exactly once in an executable program. You can supply default values to the selection screen fields of the logical database during this event.
You can use F1 Help (Technical help) to determine the names of the selection fields.

You can use the addition DEFAULT to supply additional report-specific default values to selection screen fields in a selection-option statement. The value sets are entered in the internal table during this event.

The selection screen can generally be initialized during event AT SELECTION-SCREEN OUTPUT. This event corresponds to event Process Before Output (PBO) of the selection screen, and therefore may be passed several times. A typical task for the selection screen's PBO event is dynamic screen modification (LOOP AT SCREEN), that is, showing or hiding fields, enabling or preventing input, and so on.

You can perform an error dialog check of the selection screen fields within the AT SELECTIONSCREEN processing block. The event belongs to the PAI (Process After Input) processing of the selection screen. In case of errors (MESSAGE Exxx or MESSAGE Wxxx), all fields are made ready for input again.

You can refer to individual selections with the parameters ON or ON . In case of errors, only these selections are made input-ready again.

To check the entry combinations of a logical group, you can use the event AT SELECTIONSCREEN ON BLOCK . Fields in this block are made ready for input when an error message is issued.

The event AT SELECTION-SCREEN ON END OF belongs to the PAI processing of the selection screen for Multiple selections.

You can perform entry checks for selection criteria of the logical database and for your own program-specific selections.

You can work with several selection screens in one program. The default selection screen always has the screen number 1000.

You can also define a selection screen with SELECTION-SCREEN BEGIN OF SCREEN ... END OF SCREEN . Between the BEGIN ... END ... statements, you declare the required selections with SELECT-OPTIONS and PARAMETERS. The selection screen is assigned the screen number and is called with CALL SELECTION-SCREEN .

The system takes care of the return from the selection screen, which means you do
not have to program it yourself with LEAVE SCREEN (as is the case with CALL SCREEN).
The program is continued immediately after the call. However, you must use system field sy-subrc to query whether the user chose Execute (F8) or Cancel (green and yellow arrows, red X). Execute (F8) returns sy-subrc = 0; Cancel returns sy-subrc = 4.

You can supply the selection screen with default values at INITIALIZATION.

You can determine which selection screen is currently processing with the AT
SELECTION-SCREEN event. You can do so with a CASE control structure and evaluate the system field sy-dynnr.

You can create any number of selection sets (variants) for a program. The variants are allocated to the program uniquely.

Creating variants makes sense when you frequently start a program with the same selection default values.

You can mark Start with variants in the program attributes. Users (system, services, reporting) can then start the program only with a variant.

If the program uses several selection screens, you can choose to create a variant for all the selection screens or individually for each selection screen.

Naming conventions and transporting variants

"SAP&xxx" are supplied by SAP
"CUS&xxx" are created by customers (in client 000)

Variants that follow these naming conventions are client-independent and will automatically be transported along with the report. If these naming conventions are not followed, an entry for a request (task) must be added to the object list: LIMU VARI .

You have to assign a name and a description to each variant. By default, variants are available for both online and background processing. You can also define a variant exclusively for use with background processing.

You can protect the variant itself and the individual selection criteria and parameters against unauthorized changes. If you select Display only in catalog, this variant will not be displayed in the general value help (F4).

The type of a selection is determined in its declaration: Type s for SELECT-OPTIONS, type p for PARAMETERS. If you select Selections protected, then the field(s) will not be ready for input. You can use the hide attribute to suppress selection criteria and parameters on the screen, if required, resulting in a less cluttered selection screen.

When you use selection variables, there are three basic ways of supplying your selections with values at runtime:
From table TVARV (type T)
Date fields using dynamic date calculation (type D), such as today's date
User-specific variables (type B); Prerequisite: The selection must be declared with the MEMORY ID addition.

ABAP Interview Questions -SQL , Tables , Basic

2008-07-25T19:38:00.001+05:30

Basic Question :

(1)Choose the menu path Tools->Administration, Monitoring->System monitoring->User overview. What is the transaction code for this transaction?
(2) What is the transaction code for the R/3 main menu? (The main menu is the first menu displayed after logon.)
(3)What is the transaction code for the menu path Tools->Development Workbench?
(4)If there are three R/3 systems in your current system landscape, how many databases are there?
(5)If an R/3 system has two application servers, how many instances does it have?
(6)What is Open SQL?
(7)What advantages does Open SQL offer over native SQL?
(8)Which part of the work process is used to implement Open SQL?
(9)When is a roll area allocated, when is it de-allocated, and what does it contain?
(10)When is a user context allocated, when is it de-allocated, and what does it contain?
(11)When does the roll-out occur, and why does it occur?
(12)What two things does the tables statement do?
(13)To what does the term default table work area refer?
(14)If the select statement is missing an into clause, where do the rows go?
(15)If a write statement does not contain a slash, is the output written to the same line as the output for the previous write statement or is it written to a new line?
(16)What is the name of the system variable that indicates whether any rows were found by the select statement?
(17)What is the name of the system variable that indicates how many rows were found by the select statement?
(18)What is the purpose of the domain?
(19)What does the data element contain?
(20)To what does the term application data refer?
(21)For fields of type DEC, is the decimal point stored with the value of the field?
(22)What are the transaction codes of the four data browsers. Which one is most commonly used, and which one cannot be used to update data?
(23)What is the difference between a transparent table and a pooled or cluster table?

Dialog Programming Interview Questions(FAQ's)

2008-07-25T19:37:00.002+05:30

1) Why do I need to do dialog programming?
Ans: to have your own customized screens and processing

2) What does dialog programming consist of ?
Ans: Screens with their corresponding processing code, Menu , module pool program

3) Difference between the normal report / program and Module pool program?
Ans: Normal report can be run straight away by executing it and useually has a selection criteria – Attributes : 1 online program
Module pool program cannot be run straight away. It first needs to display a screen – attributes : M module pool program

4) What is PBO and PAI?
Ans: Process before output. Code that is executed prior to the display of a screen.
Process after input. Code that is executed after a button on the screen has been pressed.

5) How can I identify which button is pressed?
Ans: “ fcode” attributes of the button. Define the okcode value of the screen (type sy-ucomm)

6) What is the GUI interface to the program?
Ans: The menu bar where you define the ok-codes of the buttons and function keys for the screen. You typically code SAVE, BACK, CANC, EXIT and then more specific codes. CANC (leave to screen 0) allows you to get out of the current screen.

7) What does PAI and Pbo contain by default?
Ans: PBO - MODULE STATUS_0100 - Key / button definitions
PAI - * MODULE USER_COMMAND_0100 - How do you handle thecode behind the button that was pressed

8) If we do not have / give menu bar than what will menu bar have by default?
Ans: Not much -> system , help

9) How many PBO and PAI modules are allowed for a screen?
Ans: one PBO and one PAI

10) In the menu bar can you associate a function key to a button?
Ans: yes

Performance Tuning Faqs in abap

2008-07-25T19:37:00.001+05:30

What is performance tuning?

What are steps you follow to improve the performance of
a report ?

what is the role of secondary index in performance?

what is the role of ST05 in performance tuning?

what is the role of extended syntax check in
performance tuning?

will join conditions in sql queries affect perfomance? how?

will sorted internal tables help in performance?

will where conditions in a sql query help improve
performance?

does select single *.. / select * .. affect performance ?
how?

SAP BASIS LAYER Interview Questions

2008-07-25T19:36:00.000+05:30

What are the central interfaces of the R/3 system ?
- Presentation interface
Database interface
Operating system interface

Which interface controls what is shown on the p.c. ?
- Presentation interface

Which interface converts SQL requirements in the SAP development system to those of the database ?- Database interface

What is SAP dispatcher ?
- SAP dispatcher is the control agent which manages the resources for the R/3 applications.

What are the functions of dispatcher ?
- Equal distribution of transaction load to the work processes
Management of buffer areas in main memory Integration of the presentation levels
Organization of communication activies

What is a work process ?
- A work process is where individual dialog steps are actually processed and the work is done. Each work process handles one type of request.

Name various work processes of R/3 system ?
1) Dialog or Online ( processes only one request at a time )
2) Background ( started at a specified time ) 3) Update ( primary or secondary ) 4) Enque( lock mechanism ) 5) Spool ( generated online or during back ground processing For printing )

What are the types of Update requests ?
- An update request can be divided into one primary (V1) and several Secondary update components (V2). Time-critical operations are placed in V1 component and those whose timing are less critical are placed in V2 components. If a V1 update fails, V2 components will not be processed.

What are the roll and page areas ?
- Roll and page areas are SAP R/3 buffers used to store user contexts ( process requests ) . The SAP dispatcher assigns process requests to work processes as they are received. If the work process is unavailable the process requests are queued in the roll and page areas. Paging area holds data from the application programs. Roll area holds data from previous dialog steps and data that characterizes user.

What is a Spool request ?
- Spool requests are generated during dialog or background processing and placed in the spool database with information about the printer and print format. The actual data is placed in the Tem Se (Temporary Sequential objects).

What are the different database integrities ?
- Semantic integrity
- Relational integrity
- Primary key integrity
- Value set integrity
- Foreign key integrity and
- Operational integrity.

SAP ABAPDATA DICTIONARY Interview Questions

2008-07-25T19:35:00.000+05:30

Type of a table or structure
The table type determines how the logical table description defined in the ABAP/4 Dictionary is reproduced on the database. There are the following table types:
transparent table
structure
append structure

For internal purposes, such as storing control data or update texts, there are in addition the following table types:

pooled table
cluster table
generated view structure

Transparent table There is a physical table on the database for each transparent table. The names of the physical tables and the logical table definition in the ABAP/4 Dictionary correspond. All business data and application data are stored in transparent tables.

Structure No data records exist in the database for a structure. Structures are used for the interface definition between programs or between screens and programs.

Append structure An append structure defines a set of fields which belong to another table or structure but which are treated in the correction administration as its own object. Append structures are used to support modifications.

Pooled table Pooled tables can be used to store control data (e.g. screen sequences, program parameters or temporary data). Several pooled tables can be combined to form a table pool. The table pool corresponds to a physical table on the database in which all the records of the allocated pooled tables are stored.

Cluster table Cluster tables contain continuous text, for example, documentation. Several cluster tables can be combined to form a table cluster. Several logical lines of different tables are combined to form a physical record in this table type. This permits object-by-object storage or object-by-object access. In order to combine tables in clusters, at least parts of the keys must agree. Several cluster tables are stored in one corresponding table on the database.

Generated view structure In activation a structure is generated for a view. This structure serves as interface for the runtime environment. It does not generally appear in the ABAP/4 Dictionary.

What is a Data Class?

The Data class determines in which tablespace the table is stored when it is created in the database. What is a Size Category? The Size category describes the probable space requirement of the table in the database. How Many types of size categories and data classes are there? There are five size categories (0-4) and 11 data classes, only three of which are appropriate for application tables:
- APPL0 - Master data (data frequently accessed but rarely updated)
- APPL1 - Transaction data (data that is changed frequnetly)
- APPL2 - Organisational data (customizing data that is entered when system is
configured and then rarely changed)

What are control tables?

The values specified for the size category and data class are mapped to database-specific values via control tables.

What is the function of the transport system and workbench organiser?

The function of the transport system and the Workbench Organizer is to manage any changes made to objects of the ABAP/4 Development Workbench and to transport these changes between different SAP systems.

What is a table pool?
A table pool (or pool) is used to combine several logical tables in the ABAP/4 Dictionary. The definition of a pool consists of at least two key fields and a long argument field (VARDATA).

What are pooled tables?
These are logical tables which must be assigned to a table pool when they are defined. Pooled tables can be used to store control data (such as screen sequences or program parameters).

What is a table cluster?
A table cluster combines several logical tables in the ABAP/4 Dictionary. Several logical rows from different cluster tables are brought together in a single physical record. The records from the cluster tables assigned to a cluster are thus stored in a single common table in the database.

Which objects are independent transport objects?
Domains, Data elements, Tables, Technical settings for tables, Secondary indexes for transparent tables,
Structures, Views,
Matchcode objects, Matchcode IDs, Lock objects.

What are the Data types of the external layer?
ACCP, CHAR, CLNT, CUKY,CURR, DATS, DEC, FLTP, INT1,INT2, INT4, LANG, LCHR,LRAW, NUMC, PREC, QUAN,RAW ,TIMS, UNIT, VARC.

What are the Data types of the ABAP/4 layer?

Possible ABAP/4 data types: C: Character. D: Date, format YYYYMMDD. F: Floating-point number in DOUBLE PRECISION (8 bytes). I: Integer. N: Numerical character string of arbitrary length. P: Amount or counter field (packed; implementation depends on hardware platform). S: Time stamp YYYYMMDDHHMMSS. T: Time of day HHMMSS. V: Character string of variable length, length is given in the first two bytes. X: Hexadecimal (binary) storage.

How can we set the tablespaces and extent sizes ?
You can specify the extent sizes and the tablespace (physical storage
area in the database) in which a transparent table is to be stored by setting the size category and data class.

What is a data dictionary ?
Data dictionary is a central source of data in a data management system. Its main function is to support the .It has details about

- What data is contained ?
- What are the attributes of the data ?
- What is the relationship existing between the various data elements ?

What functions does a data dictionary perform ?
In a data management system, the principal functions performed by the data dictionary are
- Management of data definitions
- Provision of information for evaluation
- Support for software development
- Support form documentation
- Ensuring that the data definitions are flexible and up-to-date.

A field containing currency amounts (data type CURR) must be assigned to a reference table and a reference field. Explain.

As a reference table, a system table containing all the valid currencies is assigned or any other table which contains a field with the currency key format. This field is called as reference field. The assignment of the field containing currency amounts to the reference field is made at runtime. The value in the reference field determines the currency of the amount.

What is the significance of Technical settings (specified while creating a table in the data dictionary) ?

By specifying technical settings we can control how database tables are created in the database. The technical settings allows us to - optimize storage space requiremnets
- table access behaviour
- buffering required
- changes to entries logged

What is the significance of Delivery Class ?
- The delivery class controls the degree to which the SAP or the customer is responsible for table maintenance
- whether SAP provides the table with or without contents.
- determines the table type. - determines how the table behaves when it is first installed, at upgrade, when it is transported, and when a client copy is performed.

What is the maximum number of structures that can be included in a table or structure
- Nine.

What are the two methods of modifying Sap standard tables ?
- Append Structures and
- Customizing Includes.

What is the difference between a Substructure and an Append Structure ?
- In case of a substructure, the reference originates in the table itself, in the forma of a statement .include... . - In case of an append structure, the table itself remains unchanged and the refrence originates in the append structure.
What are the two ways for restricting the value range for a domain ? - By specifying fixed values.
- By stipulating a value table.

What is a Match Code ?

Match Code is a tool to help us to search for data records in the system. Match codes are an efficient and user-friendly search aid where key of a record is unknown. What are the two levels in defining a Match Code ?
- Match Code object
- Match Code Id.

What is the maximum number of match code Id's that can be defined for one Match code object ?
- 36. A match code Id is a one character ID which can be a letter or a number.

Can we define our own Match Code ID's for SAP Matchcodes ?
Yes, the numbers 0 to 9 are reserved for us to create our own Match Code IDs for a SAP defined Matchcode object.

What is an Update type with reference to a Match code ID?
If the data in one of the base tables of a matchcode ID changes, the matchcode data has to be updated. The update type stipulates when the matchcode is to be updated and how it is to be done. The update type also specifies which method is to be used for Building matchcodes . You must specify the update type when you define a matchcode ID.

What are conversion routines ?
- Non standard conversions from display format to sap internal format and vice-versa are implemented with so called conversion routines.
Aggregated Objects Views, matchcodes, and lock objects are also called aggregate objects because they are formed from several related tables.

What is a View ?
- A view is a logical view on one or more tables. A view on one or more tables i.e, the data from a view is not actually physically stored instead being derived from one or more tables. A view can be used to summarize data which is distributed among several tables

How many types of Views are there ? - Database View (SE11)
Database views are implement an inner join, that is, only records of the primary table (selected via the join operation) for which the corresponding records of the secondary tables also exist are fetched. Inconsistencies between primary and secondary table could, therefore, lead to a reduced selection set. In database views, the join conditions can be formulated using equality relationships between any base fields. In the other types of view, they must be taken from existing foreign keys. That is, tables can only be collected in a maintenance or help view if they are linked to one another via foreign keys.

- Help View ( SE54)
Help views are used to output additional information when the online help system is called. When the F4 button is pressed for a screen field, a check is first made on whether a matchcode is defined for this field. If this is not the case, the help view is displayed in which the check table of the field is the primary table. Thus, for each table no more than one help view can be created, that is, a table can only be primary table in at most one help view.

- Projection View

Projection views are used to suppress or mask certain fields in a table (projection), thus minimizing the number of interfaces. This means that only the data that is actually required is exchanged when the database is accessed. A projection view can draw upon only one table. Selection conditions cannot be specified for projection views.

- Maintenance View ( SE54 )

Maintenance views enable a business-oriented approach to looking at data, while at the same time, making it possible to maintain the data involved. Data from several tables can be summarized in a maintenance view and maintained collectively via this view. That is, the data is entered via the view and then distributed to the underlying tables by the system.

What is Locking ?
- When two users simultaneously attempt to access the same data record, this is synchronised by a lock mechanism.
When dialog transactions are programmed, locks are set and released by calling certain function modules. These function modules are generated automatically from the definition of so-called lock objects in the ABAP/4 Dictionary. To synchronize the access to a table by setting and removing locks, a Lock object has to be defined in the ABAP/4 Dictionary. Activating the lock object automatically creates #function modules for setting and removing locks. These function modules must be included when programming interactive transactions.

Lock Mechanism : To set locks, a lock object must be defined in the ABAP/4 Dictionary. In this lock object, those tables in which data records are to be locked by calling a lock are determined. All tables included in a lock object must be connected to each other via foreign keys. The key fields of the tables in a lock object form the Lock arguments for the tables. The lock arguments are the basis for formulating the logical condition for identifying the records to be locked. When activating this lock object, two function modulesB with the names ENQUEUE_ and DEQUEUE_ are generated.

Example :
Problem : You wish to prevent a user from being able to change the name of a course or the name of the professor with responsibility for the course at a time when another user is editing the course description (which contains this information).

Solution : The problem described above can be solved by defining a lock object E_UKURS. This is done by defining primary and secondary tables in the lock object. Table UKURS is check table of table UKRSB, so UKURS should be selected as primary table and UKRSB as secondary table of the lock object. The Lock argument in this case is the field combination FABNR, KRSNR, and SPRAS (i.e Primary Key Combination). The Lock mode Shared is to be selected here. This allows several users to access the data simultaneously in display mode. The lock mode in the generated function modules for setting (ENQUEUE_E_UKURS) and releasing (DEQUEUE_E_UKURS) locks is therefore set to shared as default, but can be overridden by calling the function modules. If the function module ENQUEUE_E_UKURS is called with FABNR = '1' and KRSNR = '3', the record for course 3 in faculty 1 is locked in table UKURS. Furthermore, all the course descriptions for this course are locked in table UKRSB since field SPRAS was not specified when the function module was called. In such cases, the lock is made generically for a field which is not defined. If the function module DEQUEUE_E_UKURS is now called with FABNR = '1', KRSNR = '3' and SPRAS = 'D', the German course description is unlocked. All other course descriptions remain locked.

What is database utility ?
-
Database utility is the interface between the ABAP/4 Dictionary and the underlying the SAP system.
The database utility is the interface between the ABAP/4 Dictionary and the relational database underlying the SAP system. You can call the database utility from the initial screen of the ABAP/4 Dictionary with Utilities ® Database utility. The database utility allows you to create, delete and convert objects from the ABAP/4 Dictionary in the database. MODULARIZATION What is Modularization and its benefits? If the program contains the same or similar blocks of statements or it is required to process the same function several times, we can avoid redundancy by using modularization techniques. By modularizing the ABAP/4 programs we make them easy to read and improve their structure. Modularized programs are also easier to maintain and to update.

How can we create callable modules of program code within one ABAP/4 Program?
A. By defining macros. B. By creating include programs in the library.

What are subroutines?
Subroutines are program modules which can be called from other ABAP/4 programs or within the same program.

What are the types of Subroutines?
A. Internal Subroutines: The source code of the internal subroutines will be in the
same ABAP/4 program as the calling procedure (internal call).
B. External Subroutines: The source code of the external subroutines will be in an
ABAP/4 program other than the calling procedure.

What are the different types of parameters?
Formal parameters: Parameters which are defined during the definition of subroutine with the FORM statement. Actual parameters: Parameters which are specified during the call of a subroutine with the PERFORM statement.

How can one distinguish between different kinds of parameters?
A. Input parameters are used to pass data to subroutines. B. Output parameters are used to pass data from subroutines.

What are the different methods of passing data?
A. Calling by reference: During a subroutine call, only the address of the actual
parameter is transferred to the formal parameters. The formal parameter has no memory of its own, and we work with the field of the calling program within the subroutine. If we change the formal parameter, the field contents in the calling program also change.
B. Calling by value: During a subroutine call, the formal parameters are created as
copies of the actual parameters. The formal parameters have memory of their own. Changes to the formal parameters have no effect on the actual parameters.
C. Calling by value and result: During a subroutine call, the formal parameters are
created as copies of the actual parameters. The formal parameters have their own memory space. Changes to the formal parameters are copied to the actual parameters at the end of the subroutine.
The method by which internal tables are passed is By Reference.

What is the difference between the function module and a normal ABAP/4 subroutine?

In contrast to normal subroutines function modules have uniquely defined interface. Sub routines do not return values.
Sub routines do not return exceptions. Sub routines cannot be tested independently. Declaring data as common parts is not possible for function modules. Function modules are stored in a central library. What is a function group? A function group is a collection of logically related modules that share global data with each other. All the modules in the group are included in the same main program. When an ABAP/4 program contains a CALL FUNCTION statement, the system loads the entire function group in with the program code at runtime. Every function module belongs to a function group.

What is the difference between internal tables and extract datasets?

A. The lines of an internal table always have the same structure. By using extract
datasets, you can handle groups of data with different structure and get statistical figures from the grouped data.
B. You have to define the structure of the internal table at the begining. You need
not define the structure of the extract dataset.
C. In contrast to internal tables, the system partly compresses extract datasets
when storing them. This reduces the storage space required.
D. Internal tables require special work area for interface whereas extract datasets
do not need a special work area for interface.

SAP ABAP LOGICAL DATABASE Interview Questions

2008-07-25T19:34:00.003+05:30

What are logical databases?
What are the advantages/disadvantages of logical databases? Ans :- A Logical Database is a hierarchical structure of tables. Use the GET statement to process Logical Databases. - LDB consists of logically related tables grouped together used for reading and processing data.
- Advantages = 1. No need of programming for retrieval , meaning for data selection
- 2. Easy to use standard user interface, have check completeness of user input.
Disadvantages = 1. Fast in case of lesser no. of tables But if the table is in the lowest level of hierarchy, all upper level tables should be read so performance is slower.

Preparation of the data records by the L.D.B and reading of the data records in the actual report are accomplished with the command pair.
- Put and Get.

The three main elements of LDB are - Structure, Selections, Database Program.

What sort of tables one can use in designing the hierarchy of a LDB ?
- Tables which are having Foreign key relations.

The structure of Logical Databases relfects the ________________ dependencies of hierarchical tables in the SAP System.
- Foreign key

If you want to improve the response time ( time to access data ) Logical DataBases permits you to achieve this using ______________
- VIEWS.

What are the advantages of Logical DataBases ?
- It offers an easy-to-use selection screen.
You can modify the pre-generated selection screen to your needs. It offers check functions to check whether user input is complete, correct, and plausible.
It offers reasonable data selections.
It contains central authorization checks for database accesses.
Enhancements such as improved performance immediately apply to all report programs that use the logical database.
Report FORMATTING In order to suppress the leading zeros of a number field the keywords used are : NO-ZERO. The Command that allows for vertical alignment of fields one below the other. UNDER. In order to concatenate strings only for output purposes the command _________ can be used in conjunction with the 'Write' statement. NO-GAP. Data can be moved from one field to another using a 'Write:' Statement and stored in the desired format. TRUE. Write : Date_1 to Date_2 format DD/MM/YY. In order to have boldfaced text as output the command used is Write : INTENSIFIED. Background and foreground colors can be interchanged using the command Format inverse. Which datatype cannot be used to define parameters. Type F. For each new event, the system resets all formatting options to their default values. TRUE.

The processing block following END-OF-PAGE is processed only if you reserve lines for the footer in the LINE-COUNT option of the REPORT statement.
To execute a page break under the condition that less than a certain number of lines is left on a page is acheived by ________________________. RESERVE n lines. What is the limit for the length of a page if the page length is not specified in the report statement. 60,000 Lines. How can Symbols or R/3 icons be output on the screen? WRITE AS SYMBOL. WRITE AS ICON.

REPORTING - GENERAL What are reports? and how do you set up reports? A report program reads and analyzes data from one or more database tables without modifying the database. Usually, the result of such a report program is in the form of a list which is output to the screen or sent to a printer. What are the different types of programs?
I Include Program
M Module Pool
F Function Modules
S External Subroutines
1 Online program

Events in Reporting ? Explain ?
The following events occur at runtime of a typical report program which uses logical databases: Event keyword
Event

-- INITIALIZATION
Point before the selection screen
is displayed
When you start a program in which a selection screen is defined (either in the program itself or in the linked logical database program), the system normally processes this selection screen first. If you want to execute a processing block before the selection screen is processed, you can assign it to the event keyword INITIALIZATION.

AT SELECTION-SCREEN
Point after processing user input on the selection screen while the selection screen is still active
The event keyword AT SELECTION-SCREEN provides you with several possibilities to carry out processing blocks while the system is processing the selection screen.

START-OF-SELECTION
Point after processing the selection screen
The event START-OF-SELECTION gives you the possibility of creating a processing block after processing the selection screen and before accessing database tables using a logical database. You can use this processing block, for example, to set the values of internal fields or to write informational statements onto the output screen. At the START-OF-SELECTION event, also all statements are processed that are not attached to an event keyword except those that are written behind a FORM-ENDFORM block .

GET

Point at which the logical database offers a line of the database table
The most important event for report programs with an attached logical database is the moment at which the logical database program has read a line from a database table (see Accessing Data Using Logical Databases ). To start a processing block at this event, use the GET statement as follows:

Syntax

GET

[FIELDS ].

[FIELDS ]. After this statement, you can work with the current line of the database table

. The data is provided in the table work area

GET LATE

Point after processing all tables which are hierarchically subordinate to the database table

in the structure of the logical database.
To start a processing block at the moment after the system has processed all database tables of a logical database that are hierarchically inferior to a specific database table, use the event keyword GET as follows:

Syntax :

GET

LATE [FIELDS ]

In analogy to report programs that use only SELECT statements (see table in Comparison of Access Methods ), the processing block of a GET LATE

statement would appear directly before the ENDSELECT statement in the SELECT loop for the database table

.
END-OF-SELECTION

Point after processing all lines offered by the logical database.
To define a processing block after the system has read and processed all database tables of a logical database, use the keyword END-OF-SELECTION. The following events occur during the processing of the output list of a report program: Event keyword

Event

-----------------------------------------------------------------------------------------------

TOP-OF-PAGE
Point during list processing when a new page is started
END-OF-PAGE

Point during list processing when a page is ended
The following events occur during the display of the output list of a report program: Event keyword

Event

--AT LINE-SELECTION
Point at which the user selects a line

AT USER-COMMAND
Point at which the user presses a function key or enters a command in the
command field.

AT PF
Point at which the user presses the function key with the function code
PF

With the selection screen, ABAP/4 offers an interactive element also for report programs. You can define a selection screen without having to bother about all the details required in dialog programming. The selection screen is always processed directly after a report program is started. The user can enter field values and selection criteria on this screen. The main purpose of the selection screen is to enable the user to control the database selections of the report program. If a report program is started from another ABAP/4 program with the SUBMIT statement (see Calling Reports), the selection screen objects also serve as a data interface, With a selection screen defined in the report program, you can enable the user to ·
assign values to variables with the PARAMETERS statement
·
determine selection criteria with the SELECT-OPTIONS statement

How do you read selected lines of database table into an internal table in packages of predefined size?.

SELECT * FROM INTO TABLE PACKAGE SIZE .
where 'n' is variable.
Name the WILDCARD characters which are used for comparisions with character strings & numeric strings.
'%' and '_'.

How to specify a client for database table processing.

TABLES SPFLI.
SELECT * FROM SPFLI CLIENT SPECIFIED
WHERE MANDT BETWEEN '001' AND '003'.
...
ENDSELECT.

Activation During activation, the runtime object of aggregate object or tables is created. The runtime object is buffered so that the application program can access it quickly. Runtime object has information about the following objects of table - domain data elements field definition table definition

Lock Mechanism prevents a new database operation being started an existing one has been correctly completed. When conversion is done, lock is created automatically and released only when conversion is successful. Clearing of locks restart adjustment attempt is made to continue conversion at the point of
termination
Cancel adjustment lock entry is simply deleted from table

Version Management functions

- Canceling changes reset revised version to active version
- Storing changes active version will be temporarily stored in version
Switching changes switch between active and revised versions

Version catalog list of all existing versions of an object

- Revised version produced when we edit an existing object
- Active version produced when we activate an object
- Temporary version produced when we copy the active version temporarily to the database with store version functions
- Historical versions created when 1. Correction is created 2 correction is
released

Table Buffering : Possible buffering types

- full buffering either, whole table or none of the table is located in the buffer (Tables up to 30 kb done in client dependent fully buffered tables)
- Generic buffering generic areas of the table are fully buffered.
- Generic key left justified section of primary key of a table.
Single record buffering records actually being accessed are loaded to buffers, large records where few records are accessed.

Internal Tables ? Types ?

STANDARD table Key access to a standard table uses a linear search. This means that the time required for a search is in linear relation to the number of table entries. You should use index operations to access standard tables.

SORTED table Defines the table as one that is always saved correctly sorted. Key access to a sorted table uses a binary key. If the key is not unique, the system takes the entry with the lowest index. The runtime required for key access is logarithmically related to the number of table entries.

HASHED table Defines the table as one that is managed with an internal hash procedure You can only access a hashed table using the generic key operations or other generic operations ( SORT, LOOP, and so on). Explicit or implicit index operations (such as LOOP ... FROM oe INSERT itab within a LOOP) are not allowed.

INDEX table A table that can be accessed using an index. Index table is only used to specify the type of generic parameters in a FORM or FUNCTION. That means that you can't create a table of type INDEX. Standard tables and sorted tables are index tables.

Syntax : DATA itab TYPE table type of line type [WITH UNIQUE/NON-UNIQUE KEY ] [Iinitial size n] [WITH HEADER LINE]

What are DATA CLUSTERS ?

You can group any complex internal data objects of an ABAP/4 program together in data clusters and store them temporarily in ABAP/4 memory or for longer periods in databases. You can store data clusters in special databases of the ABAP/4 Dictionary. These databases are known as ABAP/4 cluster databases and have a predefined structure.Storing a data cluster is specific to ABAP/4. Although you can also access
cluster databases using SQL statements, only ABAP/4 statements are able to decode the structure of the stored data cluster.

Describe the functions of the debugger screen.

- Single step(F5) - Use this option to step through the program statement by statement. This allows you to branch into subroutines and function modules, and to execute these routines step by step as well. Once a subroutine or function module has been processed, control returns to the statement following the CALL FUNCTION or PERFORM statement.

- Execute(F6)- Use this option to process a program line by line. All of the statements on the current line are processed in a single step. If you are positioned on a line that calls a subroutine and you choose Execute, the Debugger processes the whole subroutine and then moves on to the line following the subroutine call. This allows you to jump through the statements within the subroutine.

- Return(F7) - The Debugger returns from a routine to the point at which control returns to the main program. Use this option to return from a subroutine, function module, or called program to the calling program.

- Continue(F8)- Use this option to process the program up to the next dynamic or static breakpoint or up to the cursor position. If there are no more breakpoints in the program and no cursor has been set, the system exits debugging mode and executes the rest of the program normally.

- Tables - Display the contents of internal tables.

Problem:How to run a program in background?

Solution :Execute the Report In the selection screen :After filling the screen fields press F9. A screen appears requesting U to print the Background Parameters *Enter the output device(Eg HPLJ /SAP2 etc) *In the spool options Uncheck Print immedietly,Uncheck delete after output,and new spool request. Press enter. Another screen appears with heading start time .U can press start immly ,then save Now the Background job is scheduled for the given program .
To View the status of background Job,The transaction code is SM37. Execute from the resulting screen . Job overview -->From the Job list select U'r program and select Spool from the application toolbar Output Controller :List of Spool Requests Select U'r Spool request and click Display icon from the overview screen . U will be displayed with the List. Caution :See to that the list with does not exceed 255 columns ,If it exceeds the extra columns will be truncated in Background

What are presentation and application servers in SAP?

A presentation server is actually a program named Sapgui.exe. It is usually installed on a user's workstation. Application server is a set of executables that collectively interpret the ABAP/4 programs and manage the input & output for them.

In an ABAP/4 program how do you access data that exists on a presentation server v/s on an application server?

For presentation server use UPLOAD or WS_UPLOAD function modules. For application server use OPEN DATASET, READ DATASET and CLOSE DATASET commands.

Describe the syntax and function of the AUTHORITY CHECK command?

Ans :- AUTHORITY CHECK OBJECT

ID FIELD ID FIELD ... IF SY-SUBRC NE 0. The AUTHORITY-CHECK checks whether a user has the appropriate authorization to execute a particular activity.

SAP ABAP Dialog Programming FAQ

2008-07-25T19:34:00.001+05:30

More than 100 ABAP Interview Faq's

2008-07-25T19:33:00.002+05:30

1. What is the typical structure of an ABAP/4 program?
ANS:-
HEADER ,BODY,FOOTER.

2. What are field symbols and field groups.?
Have you used "component idx of structure" clause with field groups?

ANS:-
Field symbols:-

Field groups :-

Can any body explain me what is field group?

Field groups are groups similar fields together into one name. Field group works in conjuction with

INSERT f1 f2 INTO fg
EXTRACT fg
SORT BY fg
LOOP ... ENDLOOP

INSERT f1 f2 INTO fg
---------------------

The insert statement is used to create a field group dynamically by inserting the field into it. Only global data fields can be inserted and not local data fields eg : in form modules.

EXTRACT fg
----------

This will combine all the fields in the fieldgroup and write them to a sequential dataset as a single record.

SORT BY fg
----------

Sorting of sequential dataset by field group.

LOOP AND ENDLOOP
---------------

LOOP.
AT ***
......
....
ENDAT.
AT ***
.....
....
ENDAT.
ENDLOOP. *-- Chinmaya

3. What should be the approach for writing a BDC program?
ANS:-
STEP 1: CONVERTING THE LEGACY SYSTEM DATA TO A FLAT FILE to internal table CALLED "CONVERSION".
STEP 2: TRANSFERING THE FLAT FILE INTO SAP SYSTEM CALLED "SAP DATA TRANSFER".
STEP 3: DEPENDING UPON THE BDC TYPE i)call transaction(Write the program explicity)
ii) create sessions (sessions are created and processed.if success data will transfer).

4. What is a batch input session?
ANS:-
BATCH INPUT SESSION is an intermediate step between internal table and database table.
Data along with the action is stored in session ie data for screen fields, to which screen it is passed,program name behind it, and how next screen is processed.

5. What is the alternative to batch input session?
ANS:-
Call transaction.

6. A situation: An ABAP program creates a batch input session.
We need to submit the program and the batch session in back ground. How to do it?
ANS:-
go to SM36 and create background job by giving
job name,job class and job steps (JOB SCHEDULING)

8. What are the problems in processing batch input sessions?
How is batch input process different from processing online?
ANS:-
PROBLEMS:-
i) If the user forgets to opt for keep session then the session will be automatically removed from the session queue(log remains). However if session is processed we may delete it manually.
ii)if session processing fails data will not be transferred to SAP database table.

10. What are the different types of data dictionary objects?
ans:-
tables, structures, views, domains, data elements, lock objects, Matchcode objects.

11. How many types of tables exists and what are they in data dictionary?
ans :-
4 types of tables
i)Transparent tables - Exists with the same structure both in dictionary as well as in database exactly with the same data and fields. Both Opensql and Nativesql can be used.

ii)Pool tables & iii)Cluster tables -
These are logical tables that are arranged as records of transparent tables.one cannot use native sql on these tables
(only opensql).They are not managable directly using database system tools.

iv)Internal tables - .

12. What is the step by step process to create a table in data dictionary?
ans:-
step 1: creating domains(data type,field length,range).
step 2: creating data elements(properties and type for a table
field).
step 3: creating tables(SE11).

13. Can a transparent table exist in data dictionary but not in the data base physically?
ANS:- NO.
TRANSPARENT TABLE DO EXIST WITH THE SAME STRUCTURE BOTH IN THE DICTIONARY AS WELL AS IN THE DATABASE,EXACTLY WITH THE SAME DATA AND FIELDS.

14. What are the domains and data elements?
ANS:-
DOMAINS : FORMAL DEFINITION OF THE DATA TYPES.THEY SET ATTRIBUTES SUCH AS DATA TYPE,LENGTH,RANGE.
DATA ELEMENT : A FIELD IN R/3 SYSTEM IS A DATA ELEMENT.

15. Can you create a table with fields not referring to data elements?
ANS:-
YES. eg:- ITAB LIKE SPFLI.here we are referening to a data object(SPFLI) not data element.

16. What is the advantage of structures? How do you use them in the ABAP programs?
ANS:-
Adv:- GLOBAL EXISTANCE(these could be used by any other program without creating it again).

17. What does an extract statement do in the ABAP program?
ANS:-
Once you have declared the possible record types as field groups and defined their structure, you can fill the extract dataset using the following statements:
EXTRACT .

When the first EXTRACT statement occurs in a program, the system creates the extract dataset and adds the first extract record to it. In each subsequent EXTRACT statement, the new extract record is added to the dataset

EXTRACT HEADER.

When you extract the data, the record is filled with the current values of the corresponding fields.

As soon as the system has processed the first EXTRACT statement for a field group , the structure of the corresponding extract record in the extract dataset is fixed. You can no longer insert new fields into the field groups and HEADER. If you try to modify one of the field groups afterwards and use it in another EXTRACT statement, a runtime error occurs.

By processing EXTRACT statements several times using different field groups, you fill the extract dataset with records of different length and structure. Since you can modify field groups dynamically up to their first usage in an EXTRACT statement, extract datasets provide the advantage that you need not determine the structure at the beginning of the program.

18. What is a collect statement? How is it different from append?
ANS:-
If an entry with the same key already exists, the COLLECT statement does not append a new line, but adds the contents of the numeric fields in the work area to the contents of the numeric fields in the existing entry.

19. What is open sql vs native sql?
ANS:- by Madhukar
Open SQL , native SQL are the interfaces to create the database applicatons.
Open SQL is consistant across different types of existing Databases.
Native SQL is the database language specific to database.Its API is specific to the databse.
Open SQL API is consistent across all vendors

20. What does an EXEC SQL stmt do in ABAP? What is the disadvantage of using it?
ANS:-

21. What is the meaning of ABAP/4 editor integrated with ABAP/4 data dictionary?
ANS:-

22. What are the events in ABAP/4 language?
ANS:-
Initialization, At selection-screen,Start-of-selection,end-of-selection,top-of-page,end-of-page, At line-selection,At user-command,At PF,Get,At New,At LAST,AT END, AT FIRST.

23. What is an interactive report?
What is the obvious diff of such report compared with classical type reports?
ANS:-
An Interactive report is a dynamic drill down report that produces the list on users choice.
diff:-
a) THE LIST PRODUCED BY CLASSICAL REPORT DOESN'T allow user to interact with the system
the list produced by interactive report allows the user to interact with the system.
b) ONCE A CLASSICAL REPORT EXECUTED USER LOOSES CONTROL.IR USER HAS CONTROL.
c) IN CLASSICAL REPORT DRILLING IS NOT POSSIBLE.IN INTERACTIVE DRILLING IS POSSIBLE.

24. What is a drill down report?
ANS:-
Its an Interactive report where in the user can get more relavent data by selecting explicitly.

25. How do you write a function module in SAP? describe.
ANS:-
creating function module:-
called program - se37-creating funcgrp,funcmodule by assigning attributes,importing,exporting,tables,exceptions.
calling program - SE38-in pgm click pattern and write function name- provide export,import,tables,exception values.

26. What are the exceptions in function module?
ANS:-
COMMUNICATION_FAILURE
SYSTEM_FAILURE

27. What is a function group?
ANS:-
GROUP OF ALL RELATED FUNCTIONS.

28. How are the date and time field values stored in SAP?
ANS:-
DD.MM.YYYY. HH:MM:SS

30. Name a few data dictionary objects? //rep//
ANS:-
TABLES,VIEWS,STRUCTURES,LOCK OBJECTS,MATCHCODE OBJECTS.

31. What happens when a table is activated in DD?
ANS:-
It is available for any insertion,modification and updation of records by any user.

32. What is a check table and what is a value table?
Check table will be at field level checking.
Value table will be at domain level checking ex: scarr table is check table for carrid.

33. What are match codes? describe?
ans:-
It is a similar to table index that gives list of possible values for either primary keys or non-primary keys.

34. What transactions do you use for data analysis?
ANS:-

35. What is table maintenance generator?
ANS:-

36. What are ranges? What are number ranges?
ANS:-
max,min values provided in selection screens.

37. What are select options and what is the diff from parameters?
ANS:-
select options provide ranges where as parameters do not.

SELECT-OPTIONS declares an internal table which is automatically filled with values or ranges
of values entered by the end user. For each SELECT-OPTIONS , the system creates a selection table.

SELECT-OPTIONS FOR .

A selection table is an internal table with fields SIGN, OPTION, LOW and HIGH.
The type of LOW and HIGH is the same as that of .
The SIGN field can take the following values: I Inclusive (should apply) E Exclusive (should not apply)
The OPTION field can take the following values: EQ Equal GT Greater than NE Not equal BT Between LE Less
than or equal NB Not between LT Less than CP Contains pattern GE Greater than or equal NP No pattern.
diff:-
PARAMETERS allow users to enter a single value into an internal field within a report.
SELECT-OPTIONS allow users to fill an internal table with a range of values.

For each PARAMETERS or SELECT-OPTIONS statement you should define text elements by choosing
Goto - Text elements - Selection texts - Change.

Eg:- Parameters name(30).
when the user executes the ABAP/4 program,an input field for 'name' will appear on the selection screen.You can change the comments on the left side of the input fields by using text elements as described in Selection Texts.

38. How do you validate the selection criteria of a report?
And how do you display initial values in a selection screen?
ANS:-
validate :- by using match code objects.
display :- Parameters default 'xxx'.
select-options for spfli-carrid.

39. What are selection texts?
ANS:-

40. What is CTS and what do you know about it?
ANS:-

The Change and Transport System (CTS) is a tool that helps you to organize development projects in the ABAP Workbench and in Customizing, and then transport the changes between the SAP Systems and clients in your system landscape.
This documentation provides you with an overview of how to manage changes with the CTS and essential information on setting up your system and client landscape and deciding on a transport strategy. Read and follow this documentation when planning your development project.
For practical information on working with the Change and Transport System, see Change and Transport Organizer and Transport Management System.

41. When a program is created and need to be transported to prodn does selection texts always go with it? if not how do you make sure? Can you change the CTS entries? How do you do it?
ANS:-

42. What is the client concept in SAP? What is the meaning of client independent?
ANS:-

43. Are programs client dependent?
ANS:-
Yes.Group of users can access these programs with a client no.

44. Name a few system global variables you can use in ABAP programs?
ANS:-
SY-SUBRC,SY-DBCNT,SY-LILLI,SY-DATUM,SY-UZEIT,SY-UCOMM,SY-TABIX.....
SY-LILLI IS ABSOLUTE NO OF LINES FROM WHICH THE EVENT WAS TRIGGERED.

45. What are internal tables? How do you get the number of lines in an internal table?
How to use a specific number occurs statement?
ANS:-
i)It is a standard data type object which exists only during the runtime of the program.
They are used to perform table calculations on subsets of database tables and for re-organising the contents of database tables according to users need.
ii)using SY-DBCNT.
iii)The number of memory allocations the system need to allocate for the next record population.

46. How do you take care of performance issues in your ABAP programs?
Performance of ABAPs can be improved by minimizing the amount of data to be transferred.
The data set must be transferred through the network to the applications, so reducing the amount OF time and also reduces the network traffic.

Some measures that can be taken are:

- Use views defined in the ABAP/4 DDIC (also has the advantage of better reusability).
- Use field list (SELECT clause) rather than SELECT *.
- Range tables should be avoided (IN operator)
- Avoid nested SELECTS.

i)system tools

ii)field symbols and field groups.
ans:-
Field Symbols : Field symbols are placeholders for existing fields. A Field Symbol does not physically reserve space for a field,but points to a field which is not known until runtime of the program.
eg:- FIELD-SYMBOL [].

Field groups : A field group combines several fields under one name.At runtime,the INSERT command is used to define which data fields are assigned to which field group.
There should always be a HEADER field group that defines how the extracted data will be sorted,the data is sorted by the fields grouped under the HEADER field group.

47. What are datasets?
ANS:-
The sequential files(ON APPLICATION SERVER) are called datasets. They are used for file handling in SAP.

48. How to find the return code of a statement in ABAP programs?
ANS:-
Using function modules.

49. What are interface/conversion programs in SAP?
ANS :
CONVERSION : LEGACY SYSTEM TO FLAT FILE.
INTERFACE : FLAT FILE TO SAP SYSTEM.

50. Have you used SAP supplied programs to load master data?

51. What are the techniques involved in using SAP supplied programs?
Do you prefer to write your own programs to load master data? Why?

52. What are logical databases? What are the advantages/disadvantages of logical databases?
ANS:-
To read data from a database tables we use logical database.
A logical database provides read-only access to a group of related tables to an ABAP/4 program.

adv:-
The programmer need not worry about the primary key for each table.Because Logical database knows how the different tables relate to each other,and can issue the SELECT command with proper where clause to retrieve the data.
i)An easy-to-use standard user interface.
ii)check functions which check that user input is complete,correct,and plausible.
iii)meaningful data selection.
iv)central authorization checks for database accesses.
v)good read access performance while retaining the hierarchical data view determined by the application logic.

disadv:-
i)If you donot specify a logical database in the program attributes,the GET events never occur.
ii)There is no ENDGET command,so the code block associated with an event ends with the next event
statement (such as another GET or an END-OF-SELECTION).

53. What specific statements do you using when writing a drill down report?
ans:-
AT LINE-SELECTION,AT USER-COMMAND,AT PF.

54. What are different tools to report data in SAP? What all have you used?
ans:-

55. What are the advantages and disadvantages of ABAP/4 query tool?

56. What are the functional areas? User groups? and how does ABAP/4 query work in relation to these?

57. Is a logical database a requirement/must to write an ABAP/4 query?

59. What are Change header/detail tables? Have you used them?

60. What do you do when the system crashes in the middle of a BDC batch session?
ans:-
we will look into the error log file (SM35).

61. What do you do with errors in BDC batch sessions?
ANS:-
We look into the list of incorrect session and process it again. To correct incorrect session we analyize the session to determine which screen and value produced the error.For small errors in data we correct them interactively otherwise
modify batch input program that has generated the session or many times even the datafile.

62. How do you set up background jobs in SAP? What are the steps? What are the event driven batch jobs?
ans:-
go to SM36 and create background job by giving job name,job class and job steps(JOB SCHEDULING)

63. Is it possible to run host command from SAP environment? How do you run?

64. What kind of financial periods exist in SAP? What is the relavent table for that?

65. Does SAP handle multiple currencies? Multiple languages?
ans:-
Yes.

66. What is a currency factoring technique?

67. How do you document ABAP/4 programs? Do you use program documentation menu option?

68. What is SAPscript and layout set?
ans:-
The tool which is used to create layout set is called SAPscript. Layout set is a design document.

69. What are the ABAP/4 commands that link to a layout set?
ans:-
control commands,system commands,

70. What is output determination?

71. What are IDOCs?
ans:-
IDOCs are intermediate documents to hold the messages as a container.

72. What are screen painter? menu painter? Gui status? ..etc.
ans:-
dynpro - flow logic + screens.
menu painter -
GUI Status - It is subset of the interface elements(title bar,menu bar,standard tool bar,push buttons) used for a certain screen.
The status comprises those elements that are currently needed by the transaction.

73. What is screen flow logic? What are the sections in it? Explain PAI and PBO.
ans:-
The control statements that control the screen flow.
PBO - This event is triggered before the screen is displayed.
PAI - This event is responsible for processing of screen after the user enters the data and clicks the pushbutton.

74. Overall how do you write transaction programs in SAP?
ans:-
Create program-SE93-create transcode-Run it from command field.

75. Does SAP has a GUI screen painter or not? If yes what operating systems is it available on? What is the other type of screen painter called?

76. What are step loops? How do you program pagedown pageup in step loops?
ans:-
step loops are repeated blocks of field in a screen.

77. Is ABAP a GUI language?
ANS:-
Yes.
ABAP IS AN EVENT DRIVEN LANGUAGE.

78. Normally how many and what files get created when a transaction program is written?
What is the XXXXXTOP program?
ans:-
ABAP/4 program.
DYNPRO

79. What are the include programs?
ANS:-
When the same sequence of statements in several programs are to be written repeadly they are coded in include programs (External programs) and are included in ABAP/4 programs.

80. Can you call a subroutine of one program from another program?
ans:- Yes- only external subroutines Using 'SUBMIT' statement.

81. What are user exits? What is involved in writing them? What precations are needed?

82. What are RFCs? How do you write RFCs on SAP side?

83. What are the general naming conventions of ABAP programs?
ANS:-
Should start with Y or Z.

84. How do you find if a logical database exists for your program requrements?
ans:-
SLDB-F4.

85. How do you find the tables to report from when the user just tell you the transaction he uses? And all the underlying data is from SAP structures?
ans:-
Transcode is entered in command field to open the table.Utilities-Table contents-display.

86. How do you find the menu path for a given transaction in SAP?
ans:-

87. What are the different modules of SAP?
ans:-
FI,CO,SD,MM,PP,HR.

89. How do you get help in ABAP?
ans:-
HELP-SAP LIBRARY,by pressing F1 on a keyword.

90. What are different ABAP/4 editors? What are the differences?
ans:-

91. What are the different elements in layout sets?
ans:-
PAGES,Page windows,Header,Paragraph,Character String,Windows.

92. Can you use if then else, perform ..etc statements in sap script?
ans:-
yes.

93. What type of variables normally used in sap script to output data?

94. How do you number pages in sapscript layout outputs?

95. What takes most time in SAP script programming?
ANS:-
LAYOUT DESIGN AND LOGO INSERTION.

96. How do you use tab sets in layout sets?

97. How do you backup sapscript layout sets? Can you download and upload? How?

98. What are presentation and application servers in SAP?
ANS:-
The application layer of an R/3 System is made up of the application servers and the message server. Application programs in an R/3 System are run on application servers. The application servers communicate with the presentation components, the database, and also with each other, using the message server.

99. In an ABAP/4 program how do you access data that exists on a presentation server vs on an application server?
ans:-
i)using loop statements.
ii)flat

100. What are different data types in ABAP/4?
ans:-
Elementary -
predefined C,D,F,I,N,P,T,X.
userdefined TYPES.
ex: see in intel book page no 35/65

Structured -
predefined TABLES.
userdefined Field Strings and internal tables.

101. What is difference between session method and Call Transaction?
ans:-

102. Setting up a BDC program where you find information from?
ans:-

103. What has to be done to the packed fields before submitting to a BDC session.
ans:-
fields converted into character type.

104. What is the structure of a BDC sessions.
ans:-
BDCDATA (standard structure).

105. What are the fields in a BDC_Tab Table.
ans:-
program,dynpro,dynbegin,fnam,fval.

106. What do you define in the domain and data element.
Technical details like

107. What is the difference between a pool table and a transparent table and how they are stored at the database level.
ans:-
ii)Pool tables is a logical representation of transparent tables .Hence no existence at database level. Where as transparent tables are physical tables and exist at database level.

108. What is cardinality?
For cardinality one out of two (domain or data element) should be the same for Ztest1 and Ztest2 tables. M:N
Cardinality specifies the number of dependent(Target) and independent (source) entities which can be in a relationship.

SAP Workflow Items Sent To Everyone If Agent Not Determined

2008-07-25T19:33:00.001+05:30

We have this problem,whenever a workitem does not determine a agent, it send the workitem to everyone.
This is causing lot of problems.

This is generally a two part issue:

1. At design time, you have defined the task as a 'general task' under the agent assignment.
2. At runtime, when the agent determination routine tries to identify the agent, it cannot. So, because it is a general task, the task is sent to everyone.

To resolve:
1. Instead of making it a general task, try to identify an actual list of 'possible' agents. This could be by positions, userIDs, Org Units, etc. Make this list your possible agents instead of defining it as a general task.

2. Make sure your logic for determining the agent always return an agent. If you are using a custom rule, then at the end of the logic check to see if an agent was determined and if not, identify a default agent (like a WF admin or business analyst) that can receive the item and investigate who to properly route it to.

FYI... if you go with option 1 and at runtime the logic fails to determine an agent, then an error message is sent to the WF admin instead of the task being sent to everyone.

Which Agent did execute the task in the Inbox?

Which FW system field does contain the agent, whom has executed a task in her inbox ?
If one of the agents executes task number 1 in her inbox, which system field do I have to use in task number 2 to find which agents did the thing ?

Make a workflow container for Actual Agent of type WFSYST-ACT_AGENT

and then in task 1 do the binding from task container to workflow container for actual agent.

This container then you can use in your next task to see who was the previous agent

How to delete an editor lock in sap?

2008-07-25T19:32:00.002+05:30

A user created the ABAP program and set the "editor lock" checked-ON (in Program Attributes screen); which makes that user the only person to make any changes to the program.

The same user left the project a year ago, and now there is a need to change the program. How can we do that? Because if someone else tries to modify it, the system doesn't allow him/her saying that "the program is locked from any changes. Only original user can change it".

How do we resolve it? I know the checked-ON indicator is stored in TRDIR table, but that table cann't be maintained manually. Please suggest what to do?

The lock in an ABAP program is defined in table TRDIR, field EDTX. You must change the value 'X' by ' '.

Use the following example program to unlock your program editor lock:

REPORT sy-repid.
TABLES: TRDIR.

PARAMETERS: P_PROG LIKE TRDIR-NAME OBLIGATORY.

START-OF-SELECTION.
SELECT SINGLE * FROM TRDIR WHERE NAME = P_PROG.
IF SY-SUBRC = 0.
 IF TRDIR-EDTX = 'X'.
   MOVE ' ' TO TRDIR-EDTX.
   MODIFY TRDIR.
   WRITE: /'Editor Lock was removed from', P_PROG.
 ELSE.
   WRITE: /'Program', P_PROG, 'does not have an Editor Lock'.
 ENDIF.
ELSE.
 WRITE: /'No match found for program', P_PROG.
ENDIF.

How can I insert my company logo in the sap abap standard report?

2008-07-25T19:32:00.001+05:30

It is not possible to print logo in the ordinary report, but it can done through ALV.

Write the code in Top-of-page event in ALV.

The following is the code for inserting the logo in ALV.

FORM TOP_OF_PAGE.

CALL FUNCTION 'REUSE_ALV_COMMENTARY_WRITE'
EXPORTING
I_LOGO = 'ENJOYSAP_LOGO'
IT_LIST_COMMENTARY = GT_LIST_TOP_OF_PAGE.

ENDFORM.

sap abap program for Issuing an Unix Command from ABAP

2008-07-25T19:31:00.002+05:30

* Issuing an Unix Command from ABAP
*
REPORT ZUNIX.

DATA UNIXCMD(50) TYPE C.
DATA: BEGIN OF ITAB occurs 0,
LINE(200),
end of ITAB.

PARAMETERS UNIXCOMM LIKE UNIXCMD
DEFAULT 'ls -ls /usr/sap/trans/data' LOWER CASE.

* Executing the system commands witin ABAP.

call 'SYSTEM' id 'COMMAND' field UNIXCOMM
id 'TAB' field ITAB-*SYS*.

EDITOR-CALL FOR ITAB DISPLAY-MODE.

Difference for Stock Transfer and Transfer Posting in sap

2008-07-25T19:31:00.001+05:30

Questions: Tell me the difference between transfer postings and stock transfers. What are the material documents that are generated and what are the accounts hits.

Stock Transfer = physically stock transfer of goods,
Trasfer posting = may physical (or) logical (not physical) stock transfer of goods.

Transfer posting and stock transfer:
Transfer posting : plant to plant/ Storage location to Storage Location.
In which if the valuation area is same. i.e.
- Sloc to Sloc within one plant then there will be no accounting entry occurs.
- However if the its Sloc to Sloc but with two different plant. and valuation area+valuation price is diff then there will accounting doc and material doc created for the same.

Stock Transfer:
There are unrestricted stock, quality inspection stock, blocked stock. Also you can have GR Blocked stock, special stock too. It will update the quantity. *-- Madhura k

Stock Tranfer and Transfer Posting - Importances are same up to Plant to Plant . However Customer ( Client ) Prefer Stock Transfer than Transfer Posting.

See the Below Advantages of Stock Transfer more than Transfer Postings :
The transfer of stock using a stock transport order has the following advantages over the transfer of stock without a stock transport order:
- A goods receipt can be planned in the receiving plant.
- You can enter a vendor (transport vendor) in the stock transport order.
- Delivery costs can be entered in the stock transport order.
- The stock transfer order is part of MRP: Purchase requisitions that were created in MRP can be converted into stock transport orders.
- The goods issue can be entered using a delivery via Shipping (LE-SHP
- The goods receipt can be posted directly to consumption.
- The entire process can be monitored via the purchase order history.
However we need to do some times Plant to Plant Trasfer Postings only in some industires. This is based on Customer Requirement. *-- Pavan G Kulkarni

How many stock transfer process are avaikable in SAP?
Like 1)Two step stock transfer (MM/SD) .
2)Two steap stock transfer ( MM only) Move type 303& 305.
3) One step stock transfer Move type 301.

Stock Transport Order (STO)

Without STO
One step stock transfer Move type 301.
Two step stock transfer ( MM only) Move type 303& 305.

Using STO without delivery:
doc.type: UB
GI:351, GR:101

STO with delivery:
GI:641, GR:101
delivery type:NL

STO with delivery and billing:
GI:643, GR:101
delivery type:NLCC , billing type:IV

Add a Field To New Condition Table in Pricing in SAP

2008-07-25T19:30:00.000+05:30

Add a field to a new condition table in Pricing (Condition Technique):-

I will explain you the process with below example...Please follow steps in below sequence-

Try to add the filed from the field catalog. In case the required combination field is not there, you can add the field through the following process to filed catalog and create the condition table. It is most common that one or other time we need to use this function while configuring multi tasking & complex Pricing Architecture.

Here I'm giving a simple guide to add fields to the Pricing Field Catalogues:

For example you want to use field PSTYV ('Sales document item category') that is included in structure KOMP ('Pricing Communication Item') as a key for a condition table.

When you create a condition table (Transaction V/03), however, the system does not propose the field in the field catalog.

Condition access, field catalog, allowed fields, KOMG, KOMK, KOMP, KOMPAZ, KOMKAZ, PSTYV are the other terms which we need to know about, to add Fields.

Reason and Prerequisites:
For technical reasons, field PSTYV was included in structure KOMP, however, not in structure KOMG ('Allowed Fields for Condition Structures').

Proceed as follows:
1. Call up the ABAP Dictionary (Transaction SE11) and create data type ZZPSTYV. Choose PSTYV as a domain.As a short text, you can use, for example, 'ZZ - sales document item category' and as a field label, you can use the field labels of PSTYV.Save, check and activate your entries.

2. Call up structure KOMPAZ in the ABAP Dictionary (Transaction SE11) in the change mode and make the following entry:
Component Component type:
ZZPSTYV ZZPSTYV
Save, check and activate the change you made.

3. Note:Because of the change in structure KOMPAZ, field ZZPSTYV is now known in structures KOMG and KOMP because structure KOMPAZ is included in both structures.

4. Call up Transaction SPRO. Navigate to 'Sales and Distribution -> Basic Functions -> Pricing -> Pricing Control' and execute 'Define Condition Tables'.
Choose 'Conditions: Allowed fields' and include ZZPSTYV as a new entry.

5. Note:Now you can use field ZZPSTYV as a key field when you create a condition table Axxx.

6. Supply the new field you defined by including the following source code line in USEREXIT_PRICING_PREPARE_TKOMP:
MOVE xxxx-PSTYV TO TKOMP-ZZPSTYV.
In order processing you find the user exit in Include MV45AFZZ, and in billing document processing you find it in Include RV60AFZZ.

Consider that you can also use this note as a help if you want to use other customer-specific fields as key fields in a condition table.

For header fields, use structure KOMKAZ instead of structure KOMPAZ and
USEREXIT_PRICING_PREPARE_TKOMK instead of
USEREXIT_PRICING_PREPARE_TKOMP.

For more information, see Transaction SPRO via the path 'Sales and Distribution -> System Modifications -> Create New Fields (Using Condition Technique) -> New Fields for Pricing' and OSS Note 21040.

Unified Access to All SAP ABAP HR Infotypes

2008-07-25T19:29:00.002+05:30

The code snippet shows how to access any HR infotype using unified class-based methods.
The SAP standard class CL_PT_EMPLOYEE provides us with two methods for reading either a default set of infotypes or any other required infotype(s).

The infotypes are returned either in transparent form (default infotypes) or in semi-transparent form (structure PRELP "HR Master Data Buffer") which can be easily converted into their corresponding transparent form (table PAnnnn).

*&---------------------------------------------------------------------*
*& Report Z_SDN_CL_PT_EMPLOYEE
*&
*&---------------------------------------------------------------------*
*&
*&
*&---------------------------------------------------------------------*

REPORT z_sdn_cl_pt_employee.

TABLES: pa0000.

DATA:
go_employee TYPE REF TO cl_pt_employee,
* generic variables for retrieving infotype data
gd_infty TYPE infty,
gt_infty TYPE tim_tmw_itlist_tab,
gt_result TYPE tim_blp_request_tab,
gd_result LIKE LINE OF gt_result,
go_data TYPE REF TO cl_pt_td_itnnnn,
* specific infotype variables
gs_prelp TYPE prelp, " HR Master Data Buffer
gs_p0009 TYPE pa0009. " HR Master Record: Infotype 0009 (Bank
" Details)

FIELD-SYMBOLS:
TYPE ANY.

PARAMETERS:
p_pernr TYPE pa0000-pernr DEFAULT '00900222',
p_begda TYPE begda DEFAULT syst-datum,
p_endda TYPE endda DEFAULT syst-datum.

START-OF-SELECTION.

* Create an instance of the employee
go_employee ?= cl_pt_employee=>get_employee( p_pernr ).

* The class has a method GET_MASTER_DATA which returns several
* basic infotypes of the employee in a transparent form.
CALL METHOD go_employee->get_master_data
EXPORTING
im_begda = p_begda
im_endda = p_endda
* IMPORTING
* EX_I0000 = " infotype 0000 = Actions
* EX_I0001 = " infotype 0001 = Organizational Assignment
* EX_I0002 = " infotype 0002 = Personal Data
* EX_I0007 = " infotype 0007 = Planned Working Time
* EX_I0008 = " infotype 0008 = Basic Pay
.

* Using this method you can access any infotype(s)
APPEND '0009' TO gt_infty. " Bank Details
* APPEND '0010' TO gt_infty. " Capital Formation
CALL METHOD go_employee->if_pt_employee~get_infotypes
EXPORTING
i_itlist = gt_infty
i_fromdate = '20000101'
i_todate = syst-datum
* I_FILTER =
i_noauthcheck = ' ' " do authority check (if required)
IMPORTING
e_result = gt_result.
* E_RETCD =
.

* Method GET_INFOTYPES returns a list of infotype objects
* containing the infotype data in semi-transparent form
LOOP AT gt_result INTO gd_result.
go_data ?= gd_result->data.

* Get infotype in semi-transparent form
gs_prelp = go_data->if_pt_td_infotype~get_prelp( ).

* Convert: semi-transparent -> transparent infotype
CALL METHOD cl_hr_pnnnn_type_cast=>prelp_to_pnnnn
EXPORTING
prelp = gs_prelp
IMPORTING
pnnnn = gs_p0009.
ENDLOOP.

* Print-Out infotype data
DO.
ASSIGN COMPONENT syst-index OF STRUCTURE gs_p0009 TO .
IF ( syst-subrc NE 0 ).
EXIT.
ELSE.
WRITE: / .
ENDIF.
ENDDO.

END-OF-SELECTION.

SAP HR ABAP Logical Database

2008-07-25T19:29:00.001+05:30

Logical database
A logical database is a special ABAP/4 program which combines the contents of certain database tables. Using logical databases facilitates the process of reading database tables.

HR Logical Database is PNP

Main Functions of the logical database PNP:

Standard Selection screen
Data Retrieval
Authorization check

To use logical database PNP in your program, specify in your program attributes.

Standard Selection Screen

Date selection
Date selection delimits the time period for which data is evaluated. GET PERNR retrieves all records of the relevant infotypes from the database. When you enter a date selection period, the PROVIDE loop retrieves the infotype records whose validity period overlaps with at least one day of this period.
Person selection
Person selection is the 'true' selection of choosing a group of employees for whom the report is to run.
Sorting Data
· The standard sort sequence lists personnel numbers in ascending order.
· SORT function allows you to sort the report data otherwise. All the sorting fields are from infotype 0001.
Report Class
· You can suppress input fields which are not used on the selection screen by assigning a report class to your program.
· If SAP standard delivered report classes do not satisfy your requirements, you can create your own report class through the IMG.

Data Retrieval from LDB

1. Create data structures for infotypes.

INFOTYPES: 0001, "ORG ASSIGNMENT
0002, "PERSONAL DATA
0008. "BASIC PAY

2. Fill data structures with the infotype records.

Start-of-selection.
GET PERNR.
End-0f-selection.

Read Master Data

Infotype structures (after GET PERNR) are internal tables loaded with data.
The infotype records (selected within the period) are processed sequentially by the PROVIDE - ENDPROVIDE loop.
GET PERNR.
PROVIDE * FROM Pnnnn BETWEEN PN/BEGDA AND PN/ENDDA
If Pnnnn-XXXX = ' '. write:/ Pnnnn-XXXX. endif.
ENDPROVIDE.

Period-Related Data
All infotype records are time stamped.

IT0006 (Address infotype)
01/01/1990 12/31/9999 present
Which record to be read depends on the date selection period specified on the
selection screen. PN/BEGDA PN/ENDDA.

Current Data
IT0006 Address - 01/01/1990 12/31/9999 present
RP-PROVIDE-FROM-LAST retrieves the record which is valid in the data selection period.

For example, pn/begda = '19990931' pn/endda = '99991231'
IT0006 subtype 1 is resident address
RP-PROVIDE-FROM-LAST P0006 1 PN/BEGDA PN/ENDDA.

Processing Payroll infotypes/Cluster in SAP HR ABAP

2008-07-25T19:28:00.001+05:30

Database Tables in HR

1. Personnel Administration (PA) - master and time data infotype tables (transparent tables). PAnnnn: e.g. PA0001 for infotype 0001

2. Personnel Development (PD) - Org Unit, Job, Position, etc. (transparent tables). HRPnnnn: e.g. HRP1000 for infotype 1000

3. Time/Travel expense/Payroll/Applicant Tracking data/HR work areas/Documents (cluster PCLn: e.g. PCL2 for time/payroll results.

Cluster Table
· Cluster tables combine the data from several tables with identical (or almost identical) keys
into one physical record on the database.
. Data is written to a database in compressed form.
· Retrieval of data is very fast if the primary key is known.
· Cluster tables are defined in the data dictionary as transparent tables.
· External programs can NOT interpret the data in a cluster table.
· Special language elements EXPORT TO DATABASE, IMPORT TO DATABASE and DELETE
FROM DATABASE are used to process data in the cluster tables.

PCL1 - Database for HR work area;
PCL2 - Accounting Results (time, travel expense and payroll);
PCL3 - Applicant tracking data;
PCL4 - Documents, Payroll year-end Tax data

Database Tables PCLn
· PCLn database tables are divided into subareas known as data clusters.
· Data Clusters are identified by a two-character code. e.g RU for US payroll result, B2 for
time evaluation result...
· Each HR subarea has its own cluster.
· Each subarea has its own key.

Database Table PCL1
· The database table PCL1 contains the following data areas:
B1 time events/PDC
G1 group incentive wages
L1 individual incentive wages
PC personal calendar
TE travel expenses/payroll results
TS travel expenses/master data
TX infotype texts
ZI PDC interface -> cost account

Database Table PCL2
· The database table PCL2 contains the following data areas:
B2 time accounting results
CD cluster directory of the CD manager
PS generated schemas
PT texts for generated schemas
RX payroll accounting results/international
Rn payroll accounting results/country-specific ( n = HR country indicator )
ZL personal work schedule

Database Table PCL3
· The database table PCL3 contains the following data areas:
AP action log / time schedule
TY texts for applicant data infotypes

Data Management of PCLn
· The ABAP commands IMPORT and EXPORT are used for management of read/write to
database tables PCLn.
· A unique key has to be used when reading data from or writing data to the PCLn.
Field Name KEY Length Text
MANDT X 3 Client
RELID X 2 Relation ID (RU,B2..)
SRTFD X 40 Work Area Key
SRTF2 X 4 Sort key for dup. key

Cluster Definition
· The data definition of a work area for PCLn is specified in separate programs which comply
with fixed naming conventions.
· They are defined as INCLUDE programs (RPCnxxy0). The following naming convention applies:
n = 1 or 2 (PCL1 or PCL2)
xx = Relation ID (e.g. RX)
y = 0 for international clusters or country indicator (T500L) for different country cluster

Exporting Data (I)
· The EXPORT command causes one or more 'xy' KEY data objects to be written to cluster xy.
· The cluster definition is integrated with the INCLUDE statement.

REPORT ZHREXPRT.
TABLES: PCLn.
INCLUDE: RPCnxxy0. "Cluster definition
* Fill cluster KEY
xy-key-field = .
* Fill data object
....
* Export record
EXPORT TABLE1 TO DATABASE PCLn(xy) ID xy-KEY.
IF SY-SUBRC EQ 0.
WRITE: / 'Update successful'.
ENDIF.

Exporting Data (II)
. Export data using macro RP-EXP-Cn-xy.
· When data records are exported using macro, they are not written to the database but to a
main memory buffer.
· To save data, use the PREPARE_UPDATE routine with the USING parameter 'V'.

REPORT ZHREXPRT.
*Buffer definition
INCLUDE RPPPXD00. INCLUDE RPPPXM00. "Buffer management
DATA: BEGIN OF COMMON PART 'BUFFER'.
INCLUDE RPPPXD10.
DATA: END OF COMMON PART 'BUFFER'.
...
RP-EXP-Cn-xy.
IF SY-SUBRC EQ 0.
PERFORM PREPARE_UPDATE USING 'V'..
ENDIF.

Importing Data (I)
· The IMPORT command causes data objects with the specified key values to be read from
PCLn.
· If the import is successful, SY-SUBRC is 0; if not, it is 4.

REPORT RPIMPORT.
TABLES: PCLn.
INCLUDE RPCnxxy0. "Cluster definition

* Fill cluster Key

* Import record
IMPORT TABLE1 FROM DATABASE PCLn(xy) ID xy-KEY.
IF SY-SUBRC EQ 0.
* Display data object
ENDIF.

Importing data (II)
· Import data using macro RP-IMP-Cn-xy.
· Check return code SY-SUBRC. If 0, it is successful. If 4, error.
· Need include buffer management routines RPPPXM00

REPORT RPIMPORT.
*Buffer definition
INCLUDE RPPPXD00.
DATA: BEGIN OF COMMON PART 'BUFFER'.
INCLUDE RPPPXD10.
DATA: END OF COMMON PART 'BUFFER'.
*import data to buffer
RP-IMP-Cn-xy.
....
*Buffer management routines
INCLUDE RPPPXM00.

Cluster Authorization
· Simple EXPORT/IMPORT statement does not check for cluster authorization.
· Use EXPORT/IMPORT via buffer, the buffer management routines check for cluster
authorization.

Payroll Results (I)
· Payroll results are stored in cluster Rn of PCL2 as field string and internal tables.
n - country identifier.
· Standard reports read the results from cluster Rn. Report RPCLSTRn lists all payroll results;
report RPCEDTn0 lists the results on a payroll form.

Payroll Results (II)
· The cluster definition of payroll results is stored in two INLCUDE reports:
include: rpc2rx09. "Definition Cluster Ru (I)
include: rpc2ruu0. "Definition Cluster Ru (II)

The first INCLUDE defines the country-independent part; The second INCLUDE defines the country-specific part (US).

· The cluster key is stored in the field string RX-KEY.

Payroll Results (III)
· All the field string and internal tables stored in PCL2 are defined in the ABAP/4 dictionary. This
allows you to use the same structures in different definitions and nonetheless maintain data
consistency.
· The structures for cluster definition comply with the name convention PCnnn. Unfortunately,
'nnn' can be any set of alphanumeric characters.

*Key definition
DATA: BEGIN OF RX-KEY.
INCLUDE STRUCTURE PC200.
DATA: END OF RX-KEY.

*Payroll directory
DATA: BEGIN OF RGDIR OCCURS 100.
INCLUDE STRUCTURE PC261.
DATA: END OF RGDIR.

Payroll Cluster Directory
· To read payroll results, you need two keys: pernr and seqno
. You can get SEQNO by importing the cluster directory (CD) first.

REPORT ZHRIMPRT.
TABLES: PERNR, PCL1, PCL2.
INLCUDE: rpc2cd09. "definition cluster CD
PARAMETERS: PERSON LIKE PERNR-PERNR.
...
RP-INIT-BUFFER.
*Import cluster Directory
CD-KEY-PERNR = PERNR-PERNR.
RP-IMP-C2-CU.
CHECK SY-SUBRC = 0.
LOOP AT RGDIR.
RX-KEY-PERNR = PERSON.
UNPACK RGDIR-SEQNR TO RX-KEY-SEQNO.
*Import data from PCL2
RP-IMP-C2-RU.
INLCUDE: RPPPXM00. "PCL1/PCL2 BUFFER HANDLING

Function Module (I)
CD_EVALUATION_PERIODS
· After importing the payroll directory, which record to read is up to the programmer.
· Each payroll result has a status.
'P' - previous result
'A' - current (actual) result
'O' - old result

· Function module CD_EVALUATION_PERIODS will restore the payroll result status for a period
when that payroll is initially run. It also will select all the relevant periods to be evaluated.

Function Module (II)
CD_EVALUATION_PERIODS

call function 'CD_EVALUATION_PERIODS'
exporting
bonus_date = ref_periods-bondt
inper_modif = pn-permo
inper = ref_periods-inper
pay_type = ref_periods-payty
pay_ident = ref_periods-payid
tables
rgdir = rgdir
evpdir = evp
iabkrs = pnpabkrs
exceptions
no_record_found = 1.

Authorization Check
Authorization for Persons
· In the authorization check for persons, the system determines whether the user has the
authorizations required for the organizational features of the employees selected with
GET PERNR.
· Employees for which the user has no authorization are skipped and appear in a list at the end
of the report.
· Authorization object: 'HR: Master data'

Authorization for Data
· In the authorization check for data, the system determines whether the user is authorized to
read the infotypes specified in the report.
· If the authorization for a particular infotype is missing, the evaluation is terminated and an error
message is displayed.

Deactivating the Authorization Check
· In certain reports, it may be useful to deactivate the authorization check in order to improve
performance. (e.g. when running payroll)
· You can store this information in the object 'HR: Reporting'.

FAQ ON SCRIPTS 1

2008-07-25T19:26:00.003+05:30

SAP Scripts

What is sap script and layout set?

Ans - SAPscript is the integrated text management system of the SAP R/3 System. SAPscript is tightly integrated into the SAP System. It is used for many different word-processing tasks all over the SAP System.

What is layout set?

A layout set in SAPscript is used for page layout. The layout set contains various elements, which are used for layout control of the individual pages and also contain layout information for texts which are to be output on the individual pages.
The layot of a document is defined in a layot set.

A layout set specified the appearance and structure of a document.
Layout sets contain predefined text modules with space reserved for variable data. You can use these text modules for different application.

Every SAPscript document uses a layout set.
To make changes to your documents, such as moving a piece of text, or changing fonts, paragraph formats, and tabs, you only need to change the layout set.

There are two ways of formatting texts using layout sets:
The text is entered and output in standard text maintenance. You can assign any layout set.

Text can also be entered via the layout set a letter header, for example.

The text is formatted via an ABAP/4 program using a layout set. The program can either dynamically output individual predefined text modules, text elements or transfer entire texts, which are to be output in the layout set.

You can use Styles to define the formatting of the text in your documents. A style determines text formatting by setting the paragraph and character formats used in a document.

You can, for example, use a style to highlight character strings or whole paragraphs. You can assign a style to any text. Typically, however, you’ll use styles
primarily in the main windows of layout sets, where users type or enter text directly in documents.

Header data is found in both style and layout set maintenance.
In style maintenance, it is used primarily to present important information - designed to make it easier for the end user to select a style. The header data in layout set maintenance, on the other hand, is used for information and control purposes.

Windows are defined in layout set maintenance. They represent areas which are positioned on pages as page windows and in which text is later output. At least one window must be defined for each layout set. If not, a text cannot be formatted by SAP script.

The following window types can be used:
MAIN - Main window in which continuous text is output. This is the window used by dialog users of a print program and layout set. For example the body text of a letter would be entered in MAIN.

VAR - Window with variable contents. The text can vary on each page in which the window is positioned. Variable windows are formatted for each page.
CONST - Window with constant contents which is only formatted once.

A layout set has the following elements:

Header data - Data related to development (created by, development class, etc.) and layout set information (which elements are used) are both stored in the header data. A start page must be entered here.

Paragraph formats - Paragraph formats are required in layout sets - as in styles - in order to format texts. However, they are also used for word processing in layout sets, for example, to format text elements.

Character formats - You can also use character formats to format texts or paragraphs. Unlike paragraph formats, however, they are used to format text within a paragraph.
Windows - Windows are names and window types, which are not physically positioned until they are allocated to pages and units of measurement are specified.
Pages - Pages are defined to provide the system with a start and end point in text formatting.

Page windows - Page windows are the combination of windows and pages, where the dimensions of a window and its position on a page are specified.
The purpose of SAP script control commands is to allow control of the output formatting. These commands are not interpreted by the SAPscript editor, but are passed through to the SAPscript Composer for processing. The composer is the program that converts text from the form displayed in the editor to the form used for printing.

What is SAPscript and explain its purpose?
SAP Script is the SAP system’s own text-proessing system. You’ll find that it looks and feels a lot like other leading text-processing system that you may use on your personal computer.

Every company needs to output documents with a uniformly defined layout (eg. Invoices, delivery notes, etc..) all the time.

The basic layout of the document is pre-defined , but in many cases, other data has to be merged with it, such as address data or purchase order items. This data might be entered manually by a employee, or retrieved from a database table.
Large quantities of these documents have to be produced.

From printing is usually a mattter of large print runs of documents such as payslips, checks, order confirmation, reminders etc.
SAPscript has been developed to meet the above requirements. IT is an integrated tool for text entry and form printing in R/3 applications.

These documents are normally provided by SAP but every organization have their unique waqys of these documents so to customize these and for creating newer ones if required; SAP script is used.

What are components of SAPscript?
Layout set, SAPscript Text, ABAP Print program , symbols, function modules like open_form, close_From, Read_text etc,.
What are the ABAP/4 Commands that link to a layout set?
Call function OPEN-form. Call function WRITE-from. Call function CLOSE-from
Importing Graphics (Logos) into SAPScript
The program RSTXLDMC can be used to upload graphics (file extension .tif on PC files) into individual standard text.
Other useful programs for SAPScript
RSTXFCON - Converts page format
RSTXSCRP - Upload/Download layout sets
RSTXDBUG - SAPScript debugger
Debug SAPScript

You can debug a SAPScript: Use Tools - Word Processing - Layout Set.
Enter name of layout set and then Utilities - Activate Debugger.
It is of no consequence which layout set you enter when selecting the SAPscript debugger. (Menu path: Tools-Word-processing - Forms, Utilities - Activate Debugger) The next layoutset called will invoke the debugger.

This is quite handy when verifying which layoutset is being called (Verifying customizing settings).
Another way to set the SAPScript debugger is to run program RSTXDBUG.
When a Form is copied from one client to another .And If U try to display or change the form in the copied client

.The possible error message cud be :
1.Form not found
Try coping again specifing the language .
2.IF IT dispalys an error message saying That the text file is inconsistent .
Then go to SE38 and Run “RSTXCHKO” .
It will ask for the form name ,then check all the checkboxes and then run the program.
Note : all Script related problems can be solved using Program ‘RSTX*’.
How to take a back up of script layout into U’r hard disk and load it later
Use Program RSTXSCRP.

Use EXPORT mode, when downloading and IMPORT when uploading a script. Don’t forget to give the form name in the object field. This will create a script with the same name as that of the original script .

If a script with the same name exists in the same client ,then it will give an error ‘Object cannot be overwritten ’ .
I want to copy table across clients
Use Program RSCLTCOP

To transfer script files across systems (Not Clients) - RSTXSCRP
To compare the contents of a table across clients: RSTBSERV
To change the development class of any object - RSWBO052
What type of variables normally used in sap script to output data?
&Tables name- fields&.
How do you number pages in sap script layout outputs?
& page &
&next Page &
What takes most time in SAP script programming?
Defining layout set up / sets.
How do you use tab sets in layout sets?
Define paragraph with defined tabs.
How do you backup sap script layout sets? Can you download and upload? How?
SAP script backup :- In transaction SE71 goto Utilities -> Copy from client -> Give source form name, source client (000 default), Target form name.
Download :- SE71, type form name -> Display -> Utilities -> form info -> List -> Save to PC file.
Upload :- Create form with page, window, pagewindow with the help of downloaded PC file. Text elements for Page windows to be copied from PC file.
What is Compare Tool in SAP Script ?
SAP Script offers tools for comparing objects across clients. We can compare or copy the following kinds of objects.
Styles
Layout sets
Documents
With the Compare tool we can do the following :
Check whether an object exists in both clients
Display the differences between the versions of an object
Layout Sets are used to control page layout and text formatting in documents .
SAP Standard styles and layout sets are always held in Client 000.

In what format does SAP Script store text ?
SAPscript texts are stored in Interchange Text Format (ITF). SAPscript offers conversion programs for the text file formats Rich Text Format (RTF) and ASCII as an interface to other word processors.
The various window types in SAP Script are
Main, Variable and Constant.

The New-Page command is used to force a Page break in the text at any point.
Protect ... Endprotect command pairs can be nested (True / False).
False.

Delimiter & must be used immediately before and after the symbol.
What does the composer do?
The final appearance of your documednt depends on interaction between the print program and the layout set.

The SAPscript print program initializes the printing process. Every command entered using the SAPscript programming interfaces is transferred to the composer.
The composer received layout information from the layout set specified by the print program. The documents are formatted according to this layout information.

If the documents contain variables, the compoer replaces these variables with data from the R/3 system, such as the current date, or with the userdata selected by the print program.
The print program controls the completion of thelayout set. Once this is done, the composer places the completed document in the spool.

Where do we define Tab space for data in SAPScript?
When defining the paragraph for the text element we can define the TABS then. There is parameter called TABS to be defined in paragraph definition.
what is difference between Window & a Page Window?

Window: An area that is predefined in the layout set. Windows are text modules, which are positioned on a document page.
We define the window type, Default Paragraph, specify the text elements or a SAPscript text to be included etc in the Windcow Component.
PageWindow: we define the parameters of the earlier defined Window, appearance on the document like left or right margins, Width & Height.
What are symboles & state their different types with E.g.

A Symbol is a constant, which can be inserted in a document. It saves the user unnecessary work when replacing sections of text, phrases, etc. Each symbol has a name which is encloses by &.
Eg. &variable name &
System symbols eg &Date&, &time& etc.
Standard symbols :Standard symbols are user-defined. They are maintained centrally in table TTDTG. Eg. &SGDH& for the opening salutation : “dear sir/madam”.
&MFG& for the closing salutation :”yours Faithfully”.

Program Symbols : Program symbols display data from the ABAP/4 program which has called the word processing function Eg. Itab-connid.

Text symbols: You can define a text symbol for any text module. This symbol is valid only in the text module for which you have defined it. Eg. Define &Symbol& = ‘value’.
How do we define Text symbols?
Using the control command DEFINE &x1& = ‘56’.
State few control commands?.
Protect .. endprotect, define, new-page, include.. if… endif.
what is the purpose of “Protect and EndProtect”?.

You can specify either in the style or in the layout set that a particular paragraph should not be slit in two by a page beak. If the page protect attribute is set then the complete paragraph is always output ona single page. This property applies only to that particular paragraph. SAPScript provides the PROTECT… ENDPROTECT command pair to allow you to define the areas to be protected against a page beak on an individual basis.

Thus the PROTECT/ENDPROTECT commands may be regarded as a kind of conditional NEW-PAGE command, the condition being whether or not the lines enclosed between the two commands fit in the space remaining in the current main window.
How do we set the date, time format?
SET TIME MASK : CONROLS THE TIME FIELD FORMAT.
SET DATE MASK : CONTRLS THE DATE FIELD FORMAT.
EG. Set Time Mask = “ HH:MM:SS”.
what is the role of an ABAP progrm in SAPScript?
Retrieves R/3 application data from the database.

Defines the layout set processing logic ( The order and repetition of text elements).
Chooses a layout set for printing.
Selects the output device, such as printer,monitor, or fax.
Sets print attributes such as immediate output, number of copies ,and pages to beprinted.

How to reuse some components of the script layout to other program?
Is this script layout is standard for all the printer? If not then y we are going for script layout?

Give me couple of methods that I will take standard script layout printout for different printer.

How u will analysis script program? ( which goes to main and how many windows etc….)
Can V inserted logo on your program?. Give me the program name which uploads my logo and syntax for logo inserting in sap script.
Yes u can insert a logo on your script layout.
Use this Report “RSTXLDMC” which will uploads the logo.
Use the following statement which includes the logo on your script prog.
/: INCLUDE 'ZHEX-MACRO-XXX' OBJECT TEXT ID ST LANGUAGE 'E'.
XXX - object name, u will gives @ runtime in rstxldmc program.
Give me syntax for box command.
BOX XPOS 2 MM WIDTH 0 CM HEIGHT '9.5' CM FRAME 10 TW
Script Commands.
Defining a variable

DEFINE &CUST& = '00000021'.
Define and insert a standard text:
Standard texts is predifined textst that can be used in more than one form. Standard texts are can be created, changed and displayed using transaction SO10.
The text ID is used to callsify texts.
To include a stadard text in a form, use the INCLUDE command:
/: INCLUDE Z_BC460_EX4_HF OBJECT TEXT ID SDVD
When formatting the standard text the PARAGRAPH parameter is used. To center the text use:
/: INCLUDE Z_BC460_EX4_HF OBJECT TEXT ID SDVD LANGUAGE EN PARAGRAPH C.
Formatting addresses
The ADDRESS-ENDADDRESS command formats addresses according to the postal norms of the recipient's country, as defined in the
country parameter.
ADDRESS DELIVERY PARAGRAPH AD
NAME &KNA1-NAME&
STREET &KNA1-STRAS&
POSTCODE &KNA1-PSTLZ&
CITY &KNA1-ORT01&'
COUNTRY &KNA1-LAND1&
FROMCOUNTRY 'DE'
ENDADDRESS
Avoiding pagebreaks in a paragraph
/: PROTECT
:
:
/: ENDPROTECT

The text lines to be protected are enclosed between the two commands
Conditonal text ouput IF - ENDIF
You can use IF/ENDIF like in a normal ABAP program
/: IF condition
:
:
/: ENDIF
and
/: IF condition
:
/: ELSE
:
/: ENDIF
Example:
/: IF &SPFLI-CITYTO& = "BERLIN"
..... put some text here
/: ENDIF

FAQ ON SCRIPTS 2

2008-07-25T19:26:00.001+05:30

Symbols and Control commands

Symbols are placeholders for values that are inserted during print formatting.
Symbols are indentified by name surrounded by "&" and are not case sensitive

Types of symbols
System symbols
DATE Date
DAY Day
NAME_OF_DAY Name of day
MONTH Month
YEAR Year
TIME Time
HOURS Hours
MINUTES Minutes
SECONDS Seconds
PAGE Page number
NEXTPAGE Number of next pagre
DEVICE Output device
SPACE Blank space
ULINE Underline
VLINE Vertical line
Standard symbols

Standard symbols are user defined and are maintained in table TTDG(table is not available???)

. You use transaction SM30 to change or display standard symbols.
An examples of standard symbols is &MFG& fot "Yours faithfully"
Standard text
standard texts is predifined texts that can be used in more than one form. Standard texts are can be created, changed and displayed using transaction SO10.
The text ID is used to classify texts.

To include a standard text in a form, use the INCLUDE command:
INCLUDE Z_BC460_EX4_HF OBJECT TEXT ID SDVD
When formatting the standard text the PARAGRAPH parameter is used. To center the text use:

Example:
INCLUDE Z_BC460_EX4_HF OBJECT TEXT ID SDVD LANGUAGE EN PARAGRAPH C.
Name: Z_BC460_EX4_HF
Object: Text
Text id: SDVD (Text id from SO10)
Language: EN
Paragraph: C (Centered)
Tip: You can use menu Insert->Text->Standard to make it easier to insert the text
Program symbols
Program symbols are for contents of database fields or global program symbols. When you print the form, data from the database tables are printed isntead of the symbols.
In the print program:

TABLES: kna1.
In the form:
&KNA1-NAME1&
Formatting
&SYMBOL& No formatting
&SYMBOL+4& Offset - Output begins here. Offset refers to formatted value
&SYMBOL(5)& Length - Output data in the specified length
&SYMBOL(I)& Suppress initial value - If the field has been initialized, nothing is output
&SYMBOL(Z)& Suppress leading zeros
&SYMBOL(C)& Compress blank spaces - Consecutice spaces are compressed into a single space. Leading spacesare suppressed.
&SYMBOL(R)& Right align output
&SYMBOL(S)& Operators are suppressed
&SYMBOL(*)& Dictionary length - The data length is defined by the ABAP dictionary
&SYMBOL(8.2)& Decimal format. Length 8 decimals 2
&'text1'SYMBOL'text2'& Text can be inserted before and after the symbol
Control commands
Control command are used to modify text output. Use format key /: in the format column.

The intensity is the grey scale of the box as %. The frame parameters is the thickness of the frame. Default is 0.

Each of the paramteters ypos, xpos, width, height and frame muts be followed of the measurement unit:

TW (twip)
PT (point)
IN (inch)
MM (millimeter)
CM (centimeter)
LN (line)
CH (character).
Examples:
BOX XPOS '11.21' MM YPOS '5.31' MM HEIGHT '10' MM WIDTH '20' MM INTENSITY 10 FRAME 0 TW

Draws two rectangles and two lines to construct a table of three columns with a highlighted heading section.

POSITION and SIZE

You can use the POSITION and SIZE commands to set default parmeters for a box. This can be usefull if you have several boxes that share the same parameters.

If you want to set the position realtively to the window use POSITION WINDOW to set the position to the top/left start of the window. Then use POSITION to set the current position relatively to the start of the Window. Note that
you uses "+" or "-" in the ORIGIN position to the set the position relatively.

the position is now 5 MM from the left and 10 MM from the top of the window.
NOTE: After using the position command you can move the current position realtively to the last used position

FAQ ON SCRIPTS 3

2008-07-25T19:25:00.001+05:30

Styles

Styles are used to predefine paragraph and character formats for forms. SAP provides several standard styles e.g. for Address includes, on-line documentation and so on. You can define your own styles.

To find styles, create styles and maintaine styles, use transaction SE72.
You assign style to a text by using menu Format -> Style
You can make temporary style changes using the control command /: STYLE

Using graphics in SapScript
Use transaction SE78 to inmport graphics to SAP.
In the form painter, you can either include directly to the form using menu Edit->Graphic->Create or using the INCLUDE statement in a window.

To use an INCLUDE stanment, goto into the woindow script editor and use menu Include->Graphic. The include can look like this for a bitmap:
/: BITMAP MYLOGO OBJECT GRAPHICS ID BMAP TYPE BMON

Modifications

Considerations in connection with modifications

The standard SAP print program should only be changed when it is absolutely necessary. If additional data is needed, these can in many cases be retrieved using a a PERFORM statement in the form instead of changing the print program..

There can be the following reasons to change the print program:
Structureal changes
New text eloements are needed

Print program to be used to print additional forms
Determine/change which forms and printprograms that are used for printing
The forms and print programs for a given output type and application can be found in table TNAPR Processing programs for output

Use view V_TNAPR in (Transaction SE30) to change entries.
Import/Export SapScript form from PC file
Use ABAP program: RSTXSCRP
SD - Finding the name of the print program
For SD dopcuments you can use table TNAPR top find the name of the a
printprogram

General - Reporting Tree in ABAP

2008-07-25T19:21:00.001+05:30

*
* An ABAP reporting tree program that allows the user to press enter or double click on
* any line. The report is updated with new internal table data and re-written. The cursor
* and paging returns to the exact same line the user was on, even though the report was
* re-written from the internal table. Input fields are filled with data based on ENTER of
* DOUBLE CLICK. [+] and [-] is displayed on each line and changes if user selects to
* expand/collapse.
*
* Create a gui status (8000) with Functions Keys
*                                 ENTER        = ENTE
*                                 BACK         = BACK
*                                 EXIT         = %EX
*                                 CANCEL       = RW
*                                 PICK         = F2
*                                 EXPAND ALL   = EXPA
*                                 COLLAPSE ALL = COLA
*
* Written by : SAP Basis, ABAP Programming and Other IMG Stuff
*             http://www.sap-img.com
*
REPORT ZTREE NO STANDARD PAGE HEADING
            LINE-COUNT 65
            LINE-SIZE 80.

DATA: BEGIN OF IT_DATA OCCURS 0,
       EXP(1) TYPE C,
       WERKS LIKE T001W-WERKS,
       MATNR LIKE MARA-MATNR,
       VALUE1(13) TYPE C,
       VALUE2(13) TYPE C,
     END OF IT_DATA.

DATA: W_MATNR LIKE MARA-MATNR,
     W_COUNT TYPE I,
     G_FIELD(40) TYPE C.

DATA: BEGIN OF PAGE,
       SCRLLINE LIKE SYST-LILLI,      "scroll line to top of screen
       CURSLINE LIKE SYST-LILLI,      "line to put cursor on
       HDRLINES TYPE I,               "lines in header + 1
       TWOHDRS TYPE I,                "two headers on screen
       CPOSTOP TYPE I,                "position of cursor from top
       CPOSBOT TYPE I,                "position of cursor from bottom
       CPOSIT TYPE I,                 "position on the screen
       PAGNO TYPE I,                  "pageno of line
       PGELINES TYPE I,               "lines used so far
     END OF PAGE.

START-OF-SELECTION.
 PERFORM BUILD_IT_DATA.

END-OF-SELECTION.
 PERFORM WRITE_REPORT.

TOP-OF-PAGE.
 PERFORM TOP_OF_PAGE.

TOP-OF-PAGE DURING LINE-SELECTION.
 PERFORM TOP_OF_PAGE.

AT LINE-SELECTION.
 G_FIELD = SPACE.
 GET CURSOR FIELD G_FIELD.
 PERFORM LINE_SELECTION.

AT USER-COMMAND.
 G_FIELD = SPACE.
 GET CURSOR FIELD G_FIELD.
 PERFORM USER_COMMAND.

*---------------------------------------------------------------------*
*       FORM BUILD_IT_DATA                                            *
*---------------------------------------------------------------------*
FORM BUILD_IT_DATA.
 IT_DATA-WERKS = '0000'.
 WHILE IT_DATA-WERKS < '0100'.
   ADD '10' TO IT_DATA-WERKS.
   W_MATNR = 0.
   WHILE W_MATNR < 10.
     ADD 1 TO W_MATNR.
     IT_DATA-EXP = '+'.
     WRITE W_MATNR TO IT_DATA-MATNR.
     IF IT_DATA-WERKS = 10 AND W_MATNR = 1.
           WRITE 'ZTEST2' TO IT_DATA-VALUE1.
           WRITE 'Testing program 2' TO IT_DATA-VALUE2.
     ELSE.
           CLEAR: IT_DATA-VALUE1, IT_DATA-VALUE2.
     ENDIF.
     APPEND IT_DATA.
   ENDWHILE.
 ENDWHILE.
ENDFORM.
*---------------------------------------------------------------------*
*       FORM WRITE_REPORT                                             *
*---------------------------------------------------------------------*
FORM WRITE_REPORT.
 SET PF-STATUS '8000'.
 SYST-LSIND = '0'.
 LOOP AT IT_DATA.
   AT NEW WERKS.
     FORMAT COLOR COL_HEADING INTENSIFIED OFF.
     WRITE: /1 SYST-VLINE NO-GAP,
               '[' NO-GAP,
               IT_DATA-EXP NO-GAP HOTSPOT ON,
               ']'.
     FORMAT COLOR COL_NORMAL INTENSIFIED ON.
     WRITE:     IT_DATA-WERKS,
             AT SYST-LINSZ SYST-VLINE.
     PAGE-PAGNO = SYST-PAGNO.
     HIDE: IT_DATA-WERKS, PAGE-PAGNO.
   ENDAT.
   IF IT_DATA-EXP = '-'.
     FORMAT COLOR COL_NORMAL INTENSIFIED OFF.
     WRITE: /1 SYST-VLINE,
             8 IT_DATA-MATNR,
               IT_DATA-VALUE1 INPUT ON,
               IT_DATA-VALUE2 INPUT ON,
            AT SYST-LINSZ SYST-VLINE.
     HIDE: IT_DATA, PAGE-PAGNO.
   ENDIF.
 ENDLOOP.
 ULINE.
ENDFORM.
*---------------------------------------------------------------------*
*       FORM USER_COMMAND                                             *
*---------------------------------------------------------------------*
FORM USER_COMMAND.
 PERFORM SET_SCROLL_LINE.
 CASE SY-UCOMM.
   WHEN 'ENTE'.
     READ TABLE IT_DATA WITH KEY WERKS = IT_DATA-WERKS
                                 MATNR = IT_DATA-MATNR.
     IF SYST-SUBRC = 0.
       CASE G_FIELD.
         WHEN 'IT_DATA-VALUE1'.
           IF IT_DATA-VALUE1 <> SPACE.
              SUBMIT (IT_DATA-VALUE1) VIA SELECTION-SCREEN AND RETURN.
           ELSE.
              IT_DATA-VALUE1 = 'Enter 1 Press'(001).
           ENDIF.
         WHEN 'IT_DATA-VALUE2'.
           IT_DATA-VALUE2 = 'Enter 2 Press'(001).
       ENDCASE.
       MODIFY IT_DATA INDEX SYST-TABIX.
     ENDIF.
     PERFORM WRITE_REPORT.
     PERFORM POSITION_LIST.
     CASE G_FIELD.
       WHEN 'IT_DATA-EXP'.
         ADD 1 TO PAGE-CURSLINE.
         SET CURSOR FIELD 'IT_DATA-VALUE1' LINE PAGE-CURSLINE.
       WHEN 'IT_DATA-VALUE1'.
         SET CURSOR FIELD 'IT_DATA-VALUE1' LINE PAGE-CURSLINE.
       WHEN 'IT_DATA-VALUE2'.
         SET CURSOR FIELD 'IT_DATA-VALUE2' LINE PAGE-CURSLINE.
     ENDCASE.
   WHEN 'EXPA'.
     PERFORM SET_EXPAND USING '-'.
     PERFORM WRITE_REPORT.
   WHEN 'COLA'.
     PERFORM SET_EXPAND USING '+'.
     PERFORM WRITE_REPORT.
 ENDCASE.
ENDFORM.
*---------------------------------------------------------------------*
*       FORM SET_EXPAND                                               *
*---------------------------------------------------------------------*
FORM SET_EXPAND USING W_EXP.
 LOOP AT IT_DATA.
   IT_DATA-EXP = W_EXP.
   MODIFY IT_DATA INDEX SYST-TABIX.
 ENDLOOP.
ENDFORM.
*---------------------------------------------------------------------*
*       FORM LINE_SELECTION                                           *
*---------------------------------------------------------------------*
FORM LINE_SELECTION.
 PERFORM SET_SCROLL_LINE.
 READ TABLE IT_DATA WITH KEY WERKS = IT_DATA-WERKS
                             MATNR = IT_DATA-MATNR.
 CASE G_FIELD.
   WHEN 'IT_DATA-EXP'.
     LOOP AT IT_DATA WHERE WERKS = IT_DATA-WERKS.
       IF IT_DATA-EXP = '-'.
         IT_DATA-EXP = '+'.
       ELSE.
         IT_DATA-EXP = '-'.
       ENDIF.
       MODIFY IT_DATA INDEX SYST-TABIX.
     ENDLOOP.
   WHEN 'IT_DATA-VALUE1'.
     IT_DATA-VALUE1 = 'Double Click'(004).
     MODIFY IT_DATA INDEX SYST-TABIX.
   WHEN 'IT_DATA-VALUE2'.
     IT_DATA-VALUE2 = 'Double Click'(004).
     MODIFY IT_DATA INDEX SYST-TABIX.
 ENDCASE.
 PERFORM WRITE_REPORT.
 PERFORM POSITION_LIST.
 CASE G_FIELD.
   WHEN 'IT_DATA-EXP'.
     ADD 1 TO PAGE-CURSLINE.
     SET CURSOR FIELD 'IT_DATA-VALUE1' LINE PAGE-CURSLINE.
   WHEN 'IT_DATA-VALUE1'.
     SET CURSOR FIELD 'IT_DATA-VALUE1' LINE PAGE-CURSLINE.
   WHEN 'IT_DATA-VALUE2'.
     SET CURSOR FIELD 'IT_DATA-VALUE2' LINE PAGE-CURSLINE.
 ENDCASE.
ENDFORM.
*---------------------------------------------------------------------*
*       FORM SET_SCROLL_LINE                                          *
* determine the correct line to scroll the re-written report to, so   *
* that the user is returned to the same spot on the screen            *
* if user is mid way between pages, ie two headers are visable on the *
* screen, check if they are on the secondary page and adjust the      *
* scroll variable accordingly so as not to jump up lines because the  *
* scroll variable will be out by the number of lines in the extra hdr *
*---------------------------------------------------------------------*
FORM SET_SCROLL_LINE.
 PAGE-CURSLINE = SYST-LILLI.
 PAGE-SCRLLINE = SYST-LILLI - ( SYST-CUROW - PAGE-HDRLINES ).
 PAGE-PGELINES = ( PAGE-PAGNO - 1 ) * SYST-LINCT.
 PAGE-CPOSTOP = ( PAGE-SCRLLINE + SYST-CUROW ) - PAGE-PGELINES.
 PAGE-CPOSBOT = ( PAGE-SCRLLINE - SYST-CUROW ) - PAGE-PGELINES.
 PAGE-CPOSIT = PAGE-CPOSTOP + PAGE-CPOSBOT.
 PAGE-TWOHDRS = PAGE-HDRLINES * 2.
 IF PAGE-CPOSIT LT PAGE-TWOHDRS.
   PAGE-SCRLLINE = PAGE-SCRLLINE + 1.
 ENDIF.
ENDFORM.
*---------------------------------------------------------------------*
*       FORM POSITION_LIST                                            *
*---------------------------------------------------------------------*
FORM POSITION_LIST.
 CALL FUNCTION 'LIST_SCROLL_LINE_TOPMOST'
      EXPORTING
           LIST_INDEX = 1
           LIST_LINE  = PAGE-SCRLLINE
      EXCEPTIONS
           OTHERS     = 1.
 CHECK SYST-SUBRC = 0.
ENDFORM.
*---------------------------------------------------------------------*
*       FORM TOP_OF_PAGE                                              *
*---------------------------------------------------------------------*
FORM TOP_OF_PAGE.
* set page-hdrlines = lines in header + 1 system generated blank line
 PAGE-HDRLINES = 5.
 ULINE.
 WRITE : /1 SYST-VLINE, 'Header'(002), AT SYST-LINSZ SYST-VLINE.
 WRITE : /1 SYST-VLINE, 'Lines'(003), AT SYST-LINSZ SYST-VLINE.
 ULINE.
ENDFORM.

List Box in ABAP Report

2008-07-25T19:20:00.002+05:30

*
REPORT ZLIST.

TYPE-POOLS: VRM.

DATA: NAME  TYPE VRM_ID,
     LIST  TYPE VRM_VALUES,
     VALUE LIKE LINE OF LIST.

PARAMETERS: PS_PARM(10) AS LISTBOX VISIBLE LENGTH 10.

AT SELECTION-SCREEN OUTPUT.

NAME = 'PS_PARM'.
VALUE-KEY = '1'.

VALUE-TEXT = 'LINE 1'.
APPEND VALUE TO LIST. VALUE-KEY = '2'.

VALUE-TEXT = 'LINE 2'.
APPEND VALUE TO LIST.

CALL FUNCTION 'VRM_SET_VALUES' EXPORTING ID = NAME VALUES = LIST.

START-OF-SELECTION.
WRITE: / 'PARAMETER:', PS_PARM.

Example Code For Drill Down Report in SAP ABAP

2008-07-25T19:20:00.001+05:30

REPORT  zmm_rept_purchorderkkb01 LINE-SIZE 80
                                LINE-COUNT 65(3)
                                MESSAGE-ID z_msg_class
                                NO STANDARD PAGE HEADING.

*------------------DECLARING THE STANDARD TABLES---------------------*
TABLES : ekko, "PURCHASE ORDER : HEADER
        ekpo. "PURCHASE ORDER : ITEM

*------------------DECLARING THE INTERNAL TABLE----------------------*
DATA  : BEGIN OF it_ekko OCCURS 2,
         ebeln LIKE ekko-ebeln, "PURCHASE ORDER NUMBER
         bukrs LIKE ekko-bukrs, "COMPANY CODE
         bsart LIKE ekko-bsart, "PURCHASING DOCUMENT TYPE
         lifnr LIKE ekko-lifnr, "VENDOR
         spras LIKE ekko-spras, "LANGUAGE KEY
         zterm LIKE ekko-zterm, "PAYMENT TERMS KEY
       end of it_ekko.

DATA  : BEGIN OF it_ekpo OCCURS 2,
         ebeln LIKE ekpo-ebeln, "PURCHASE ORDER NUMBER
         ebelp LIKE ekpo-ebelp, "PURCHASE ORDER NUMBER
         werks LIKE ekpo-werks, "PLANT
         matnr LIKE ekpo-matnr, "MATERIAL NUMBER
         matkl LIKE ekpo-matkl, "MATERIAL GROUP
       END OF it_ekpo.

DATA: it_ebeln LIKE ekko-ebeln OCCURS 0 WITH HEADER LINE.

*DATA: it_ebeln_high LIKE ekko-ebeln OCCURS 0 WITH HEADER LINE.

DATA: p_ebeln       TYPE i.

*------------------Declaring the selection screen--------------------*

SELECTION-SCREEN BEGIN OF BLOCK blk1 WITH FRAME TITLE text-001.

SELECT-OPTIONS : s_ebeln FOR ekko-ebeln.

PARAMETER      : p_limit TYPE i.

SELECTION-SCREEN END OF BLOCK blk1.


*INCLUDE z_incl_purorderkkb01_sub_f01.


*--------------------------------------------------------------------*
*  Validation for  number of records to be printed                   *
*--------------------------------------------------------------------*

*AT SELECTION-SCREEN ON p_limit.
*  IF p_limit IS INITIAL.
*    MESSAGE e011.
*  ENDIF.


*  IF p_limit GT sy-linct.
*    MESSAGE e010.
*  ENDIF.


*----------------------------------------------------------------------*
*        Search help for purchase document number (s_ebeln-low)        *
*----------------------------------------------------------------------*

AT SELECTION-SCREEN ON VALUE-REQUEST FOR s_ebeln-low.
 CALL FUNCTION 'CONVERSION_EXIT_ALPHA_INPUT'
   EXPORTING
     input  = s_ebeln-low
   IMPORTING
     output = s_ebeln-low.

 perform form_search_help.

 IF sy-subrc <> 0.
   CASE sy-subrc.
     WHEN 2.
       LEAVE TO SCREEN 1000.
   ENDCASE.
 ELSE.
   LOOP AT it_ebeln.
     IF sy-tabix = p_ebeln.
       s_ebeln-low = it_ebeln.
       EXIT.
     ENDIF.
   ENDLOOP.
 ENDIF.

*----------------------------------------------------------------------*
*        Search help for purchase document number (s_ebeln-high)       *
*----------------------------------------------------------------------*

AT SELECTION-SCREEN ON VALUE-REQUEST FOR s_ebeln-high.
 CALL FUNCTION 'CONVERSION_EXIT_ALPHA_INPUT'
   EXPORTING
     input  = s_ebeln-high
   IMPORTING
     output = s_ebeln-high.

 perform form_search_help.

 IF sy-subrc <> 0.
   CASE sy-subrc.
     WHEN 2.
       LEAVE TO SCREEN 1000.
   ENDCASE.
 ELSE.
   LOOP AT it_ebeln.
     IF sy-tabix = p_ebeln.
       s_ebeln-high = it_ebeln.
       EXIT.
     ENDIF.
   ENDLOOP.
 ENDIF.

*----------------------------------------------------------------------*
*                   Start-of-selection event                           *
*----------------------------------------------------------------------*

START-OF-SELECTION.

*----------------------To attach a user interface----------------------*
SET PF-STATUS '0010'.

*---------To fetch the data for the basic list-------------------------*
   SELECT ebeln                   "PURCHASE ORDER NUMBER
          bukrs                   "COMPANY CODE
          bsart                   "PURCHASING DOCUMENT TYPE
          lifnr                   "VENDOR
          spras                   "LANGUAGE KEY
          zterm                   "PAYMENT TERMS KEY
    up to p_limit rows
    into table it_ekko from ekko
    where ebeln in s_ebeln.

    REFRESH it_ekpo.

*---------To fetch the data for the secondary list-----------------------*

if it_ekpo is initial.

   SELECT ebeln "PURCHASE ORDER NUMBER
          ebelp "PURCHASING DOCUMENT TYPE
          werks "PLANT
          matnr "MATERIAL NUMBER
          matkl "MATERIAL GROUP
   FROM ekpo  INTO TABLE it_ekpo for all entries in it_ekko
   WHERE ebeln EQ it_ekko-ebeln.

endif.

*----------------------------------------------------------------------*
*                   End-of-selection event                             *
*----------------------------------------------------------------------*

END-OF-SELECTION.


*---------To display the data for the basic list-----------------------*
  format color 4 intensified off.
 LOOP AT it_ekko.
   WRITE :/ sy-vline, it_ekko-ebeln UNDER text-002, 18 sy-vline,
                                                   "PURCHASE ORDER NUMBER
                      it_ekko-bukrs UNDER text-003, 27 sy-vline,
                                                   "COMPANY CODE
                      it_ekko-bsart UNDER text-004, 38 sy-vline,
                                                   "PURCHASING DOCUMENT TYPE
                      it_ekko-lifnr UNDER text-005, 50 sy-vline,
                                                   "VENDOR
                      it_ekko-spras UNDER text-006, 62 sy-vline,
                                                   "LANGUAGE KEY
                      it_ekko-zterm UNDER text-007, 80 sy-vline.
                                                   "PAYMENT TERMS KEY

 hide : it_ekko-ebeln.
 ENDLOOP.
 WRITE :/ sy-uline(80).

*----------------------------------------------------------------------*
*                To generate the detailed lists                        *
*----------------------------------------------------------------------*

AT LINE-SELECTION.
 CASE sy-lsind.
   WHEN 1.
     SET PF-STATUS '0011'.

*---------To display the data for the secondary list-----------------------*
WINDOW STARTING AT 10 10
      ENDING   AT 90 30.
   format color 5 intensified off.
 LOOP AT it_ekpo where ebeln = it_ekko-ebeln .
   WRITE :/ sy-vline, it_ekpo-ebeln UNDER text-002, 15 sy-vline,
                                                    "PURCHASE ORDER NUMBER
                      it_ekpo-ebelp UNDER text-008, 30 sy-vline,
                                                    "PO ITEM NUMBER
                      it_ekpo-werks UNDER text-009, 45 sy-vline,
                                                    "PLANT
                      it_ekpo-matnr UNDER text-010, 60 sy-vline,
                                                    "MATERIAL NUMBER
                      it_ekpo-matkl UNDER text-011, 80 sy-vline.
                                                    "MATERIAL GROUP
 ENDLOOP.

 WRITE :/ sy-uline(80).

 ENDCASE.

 CASE sy-ucomm.
   WHEN 'EXIT' OR 'CANC' OR 'BACK'.
      LEAVE TO SCREEN 0.
 ENDCASE.

*----------------------------------------------------------------------*
*                    At user-command event                             *
*----------------------------------------------------------------------*

AT USER-COMMAND.
 CASE sy-ucomm.
   WHEN 'SELE' OR 'LIST1'.
     IF sy-lsind = 1.
     SET PF-STATUS '0011'.

*---------To display the data for the secondary list-----------------------*

WINDOW STARTING AT 10 10
      ENDING   AT 90 30.
      format color 5 intensified off.

 LOOP AT it_ekpo where ebeln = it_ekko-ebeln .
   WRITE :/ sy-vline, it_ekpo-ebeln UNDER text-002, 15 sy-vline, "PURCHASE ORDER NUMBER
                      it_ekpo-ebelp UNDER text-008, 30 sy-vline, "PO ITEM NUMBER
                      it_ekpo-werks UNDER text-009, 45 sy-vline, "PLANT
                      it_ekpo-matnr UNDER text-010, 60 sy-vline, "MATERIAL NUMBER
                      it_ekpo-matkl UNDER text-011, 80 sy-vline. "MATERIAL GROUP

 ENDLOOP.

 WRITE :/ sy-uline(80).
 endif.

 ENDCASE.

 CASE sy-ucomm.
   WHEN 'EXIT' OR 'CANC' OR 'BACK'.
      LEAVE TO SCREEN 0.

 ENDCASE.

*----------------------------------------------------------------------*
*                    Top-of-page for basic list                        *
*----------------------------------------------------------------------*

TOP-OF-PAGE.

format color 3 intensified off.

 WRITE :/ sy-uline(80).
 WRITE :/    sy-vline,
          03 sy-repid,
          60 text-015,
             sy-uname,
          80 sy-vline.
 WRITE :/ sy-vline, 03 sy-datum,
          35 text-012,
          60 text-014,
             sy-pagno,
          80 sy-vline.
 WRITE :/ sy-uline(80).
 WRITE :/ sy-vline, text-002, 18 sy-vline, "PURCHASE ORDER NUMBER
                    text-003, 27 sy-vline, "COMPANY CODE
                    text-004, 38 sy-vline, "PURCHASING DOCUMENT TYPE
                    text-005, 50 sy-vline, "VENDOR
                    text-006, 62 sy-vline, "LANGUAGE KEY
                    text-007, 80 sy-vline. "PAYMENT TERMS KEY
 WRITE :/ sy-uline(80).

*----------------------------------------------------------------------*
*              Top-of-page for secondary list                          *
*----------------------------------------------------------------------*

TOP-OF-PAGE DURING LINE-SELECTION.
format color 2 intensified off.
WINDOW STARTING AT 10 10
      ENDING   AT 90 30.
 WRITE :/ sy-uline(80).
 WRITE :/   sy-vline,
         03 sy-repid,
         60 text-015,
            sy-uname,
         80 sy-vline.

 WRITE :/   sy-vline,
         03 sy-datum,
         35 text-013,
         60 text-014,
            sy-pagno,
         80 sy-vline.

 WRITE :/ sy-uline(80).

 WRITE :/ sy-vline, text-014, 15 sy-vline, "PURCHASE ORDER NUMBER
                    text-008, 30 sy-vline, "PO ITEM NUMBER
                    text-009, 45 sy-vline, "PLANT
                    text-010, 60 sy-vline, "MATERIAL NUMBER
                    text-011, 80 sy-vline. "MATERIAL GROUP

 WRITE :/ sy-uline(80).

*----------------------------------------------------------------------*
*                    End-of-page event                                 *
*----------------------------------------------------------------------*

END-OF-PAGE.
 WRITE :/    sy-vline,
          03 text-016,
             p_limit,
          60 text-014,
             sy-pagno,
          80 sy-vline.
 write:/ sy-uline(80).

INCLUDE Z_INCLUDE_PURCHORDERKKB01.
form form_search_help .

REFRESH it_ebeln.
 CLEAR it_ebeln.
 CLEAR P_ebeln.

 SELECT ebeln FROM ekko INTO TABLE it_ebeln.

 CALL FUNCTION 'POPUP_WITH_TABLE_DISPLAY'
   EXPORTING
     endpos_col   = 21
     endpos_row   = 35
     startpos_col = 12
     startpos_row = 1
     titletext    = text-012

   IMPORTING
     choise       = P_ebeln

   TABLES
     valuetab     = it_ebeln

   EXCEPTIONS
     break_off    = 1
     OTHERS       = 2.

TABStrips in ABAP

2008-07-25T19:19:00.002+05:30

*
* Different Selection Options separated by Tabstrips 1,2 and 3
*

*
REPORT  ZTABSTRIPS  LINE-SIZE 120
       NO STANDARD PAGE HEADING.

TABLES: ekko, ekpo, eket, marc, t134h.

*---------------------------------------------------------------------*
*   Tab Strips 1
*---------------------------------------------------------------------*
SELECTION-SCREEN BEGIN OF SCREEN 101 AS SUBSCREEN.
SELECTION-SCREEN BEGIN OF BLOCK vendor WITH FRAME TITLE text-t00.
SELECT-OPTIONS vendor FOR ekko-lifnr.
SELECTION-SCREEN SKIP.
SELECTION-SCREEN BEGIN OF LINE.
SELECTION-SCREEN COMMENT (10) text-m01.
SELECTION-SCREEN END OF LINE.
SELECTION-SCREEN SKIP.
SELECT-OPTIONS vplant FOR ekko-reswk.
SELECTION-SCREEN END OF BLOCK vendor.
SELECTION-SCREEN END OF SCREEN 101.
*---------------------------------------------------------------------*
*   Tab Strips 2
*---------------------------------------------------------------------*
SELECTION-SCREEN BEGIN OF SCREEN 102 AS SUBSCREEN.
SELECTION-SCREEN BEGIN OF BLOCK data1 WITH FRAME TITLE text-t02.
SELECT-OPTIONS: busarea FOR t134h-gsber,
               plant   FOR ekpo-werks,
               puorg   FOR ekko-ekorg.
SELECTION-SCREEN END OF BLOCK data1.
SELECTION-SCREEN SKIP.
SELECTION-SCREEN BEGIN OF BLOCK data2 WITH FRAME TITLE text-t03.
SELECT-OPTIONS  sched   FOR ekko-ebeln.
SELECT-OPTIONS  matl    FOR ekpo-matnr.
SELECTION-SCREEN END OF BLOCK data2.
SELECTION-SCREEN END OF SCREEN 102.
*---------------------------------------------------------------------*
*   Tab Strips 3
*---------------------------------------------------------------------*
SELECTION-SCREEN BEGIN OF SCREEN 103 AS SUBSCREEN.
SELECTION-SCREEN BEGIN OF BLOCK rype WITH FRAME TITLE text-t04.
SELECTION-SCREEN BEGIN OF LINE.
PARAMETERS del RADIOBUTTON GROUP one.
SELECTION-SCREEN COMMENT 4(35) text-c05 FOR FIELD del.
SELECTION-SCREEN END OF LINE.
SELECTION-SCREEN BEGIN OF LINE.
PARAMETERS fix RADIOBUTTON GROUP one.
SELECTION-SCREEN COMMENT 4(35) text-c06 FOR FIELD fix.
SELECTION-SCREEN END OF LINE.
SELECTION-SCREEN END OF BLOCK rype.
SELECTION-SCREEN SKIP.
SELECTION-SCREEN BEGIN OF BLOCK interval WITH FRAME TITLE text-t05.
SELECTION-SCREEN BEGIN OF LINE.
PARAMETERS mon RADIOBUTTON GROUP two.
SELECTION-SCREEN COMMENT 4(15) text-c01 FOR FIELD mon.
PARAMETERS evalmon TYPE spbup.
SELECTION-SCREEN END OF LINE.
SELECTION-SCREEN BEGIN OF LINE.
PARAMETERS wek RADIOBUTTON GROUP two.
SELECTION-SCREEN COMMENT 4(15) text-c02 FOR FIELD wek.
PARAMETERS evalweek TYPE sptag.
SELECTION-SCREEN COMMENT 35(30) text-i01.
SELECTION-SCREEN END OF LINE.
SELECTION-SCREEN END OF BLOCK interval.
SELECTION-SCREEN SKIP.
SELECTION-SCREEN BEGIN OF BLOCK type WITH FRAME TITLE text-t01.
SELECTION-SCREEN BEGIN OF LINE.
PARAMETERS ext RADIOBUTTON GROUP thr.
SELECTION-SCREEN COMMENT 4(15) text-c08 FOR FIELD int.
SELECTION-SCREEN END OF LINE.
SELECTION-SCREEN BEGIN OF LINE.
PARAMETERS int RADIOBUTTON GROUP thr.
SELECTION-SCREEN COMMENT 4(15) text-c07 FOR FIELD ext.
SELECTION-SCREEN END OF LINE.
SELECTION-SCREEN END OF BLOCK type.
SELECTION-SCREEN BEGIN OF BLOCK pre WITH FRAME TITLE text-t06.
SELECTION-SCREEN BEGIN OF LINE.
PARAMETERS vn RADIOBUTTON GROUP slv.
SELECTION-SCREEN COMMENT 4(15) text-c09 FOR FIELD vn.
SELECTION-SCREEN END OF LINE.
SELECTION-SCREEN BEGIN OF LINE.
PARAMETERS bp RADIOBUTTON GROUP slv.
SELECTION-SCREEN COMMENT 4(17) text-c10 FOR FIELD bp.
SELECTION-SCREEN END OF LINE.
SELECTION-SCREEN END OF BLOCK pre.
SELECTION-SCREEN END OF SCREEN 103.

SELECTION-SCREEN BEGIN OF TABBED BLOCK uno FOR 20 LINES.
SELECTION-SCREEN TAB (15) name1 USER-COMMAND ucomm1
DEFAULT SCREEN 101.
SELECTION-SCREEN TAB (17) name2 USER-COMMAND ucomm2
DEFAULT SCREEN 102.
SELECTION-SCREEN TAB (23) name3 USER-COMMAND ucomm3
DEFAULT SCREEN 103.
SELECTION-SCREEN END OF BLOCK uno.

INITIALIZATION.
 name1 = text-n01.
 name2 = text-n02.
 name3 = text-n03.