SAP Library - BC - ABAP Programming

BC - ABAP Programming

Introduction to ABAP

The R/3 Basis System: Overview

Position of the Basis System Within the R/3 System

Application Servers

Work Processes

Overview of the Components of Application Programs

Structure of an Application Program

Screens

Structure of ABAP Programs

Processing Blocks in ABAP Programs

ABAP Statements

Logical Databases and Contexts

Memory Structures of an ABAP Program

Creating and Changing ABAP Programs

Opening a Program from the Repository Browser

Opening Programs in the ABAP Editor

Opening Programs Using Forward Navigation

Maintaining Program Attributes

Editing Programs

The ABAP Programming Language

ABAP Syntax

Types and Objects

Basic Statements

Data Types and Data Objects

Data Types

Defining Data Types

Predefined ABAP Types

Local Data Types in Programs

Data Types in the ABAP Dictionary

The TYPE Addition

The LIKE Addition

Data Objects

Literals

Text Symbols

Variables

Constants

Interface Work Areas

Predefined Data Objects

Compatibility

Determining the Attributes of Data Objects

Examples of Data Types and Objects

Processing Data

Assigning Values

Assigning Values with MOVE

Assigning Values with WRITE TO

Resetting Values to Their Initial Value

Numerical Operations

Arithmetic Calculations

Mathematical Functions

Business Calculations

Date and Time Calculations

Processing Character Strings

Shifting Field Contents

Replacing Field Contents

Converting to Upper or Lower Case or Replacing Characters

Converting into a Sortable Format

Overlaying Character Fields

Finding Character Strings

Finding the Length of a Character String

Condensing Field Contents

Concatenating Character Strings

Splitting Character Strings

Assigning Parts of Character Strings

Single Bit Processing in Hexadecimal Fields

Setting and Reading Bits

Bit Operations

Set Operations Using Bit Sequences

Type Conversions

Conversion Rules for Elementary Data Types

Conversion Rules for References

Conversion Rules for Structures

Conversion Rules for Internal Tables

Alignment of Data Objects

Processing Sections of Strings

Field Symbols and Data References

Field Symbols

Defining Field Symbols

Assigning Data Objects to Field Symbols

Basic Form of the ASSIGN Statement

Assigning Components of Structures to a Field Symbol

Defining the Data Type of a Field Symbol

Data Areas for Field Symbols

Data References

Reference Variables

Creating Data Objects Dynamically

Getting References to Data Objects

Dereferencing Data References

Data References: Example

Logical Expressions

Comparisons Between Different Data Types

Comparing Strings

Comparing Bit Sequences

Checking Whether a Field Belongs to a Range

Checking for the Initial Value

Checking Selection Criteria

Checking Whether a Field Symbol is Assigned

Combining Several Logical Expressions

Controlling the Program Flow

Branching Conditionally

Loops

Processing Large Volumes of Data

Internal tables

Creating Internal Tables

Internal table types

Internal table objects

Special Features of Standard Tables

Processing Internal Tables

Operations on Entire Internal Tables

Assigning Internal Tables

Initializing Internal Tables

Comparing Internal Tables

Sorting Internal Tables

Internal Tables as Interface Parameters

Determining the Attributes of Internal Tables

Operations on Individual Lines

Operations for all Table Types

Inserting Lines into Tables

Appending Summarized Lines

Reading Lines of Tables

Changing Lines

Deleting Lines

Processing Table Entries in Loops

Operations for Index Tables

Appending Table Lines

Inserting Lines Using the Index

Reading Lines Using the Index

Binary Search in Standard Tables

Finding Character Strings in Internal Tables

Changing Table Lines Using the Index

Deleting Lines Using the Index

Specifying the Index in Loops

Access Using Field Symbols

Using Header Lines as Work Areas

Extracts

Defining an Extract

Filling an Extract with Data

Processing Extracts

Reading an Extract

Sorting an Extract

Processing Control Levels

Calculating Numbers and Totals

Formatting Data

Example of Formatted Data

Formatting Data During Reading

Refining Data Using Internal Tables

Formatting Data Using Extracts

Saving Data Externally

Saving Data Objects as Clusters

Data Clusters in ABAP Memory

Saving Data Objects in Memory

Reading Data Objects from Memory

Deleting Data Clusters from Memory

Data Clusters in the Database

Cluster Databases

Structure of a Cluster Database

Example of a Cluster Database

Saving Data Objects in Cluster Databases

Creating a Directory of a Data Cluster

Reading Data Objects From Cluster Databases

Deleting Data Clusters from Cluster Databases

Open SQL Statements and Cluster Databases

Working with Files

Working with Files on the Application Server

File Handling in ABAP

Opening a File

Basic Form of the OPEN DATASET Statement

Opening a File for Read Access

Opening a File for Write Access

Opening a File for Appending Data

Using Binary Mode

Using Text Mode

Opening a File at a Given Position

Executing Operating System Commands

Receiving Operating System Messages

Closing a File

Deleting a File

Writing Data to Files

Reading Data from Files

Automatic Checks in File Operations

Authorization Checks for Programs and Files

General Checks for File Access

Working with Files on the Presentation Server

Writing Data to Presentation Server (Dialog)

Writing Data to Presentation Server (no Dialog)

Reading Data from Presentation Server (Dialog)

Reading Data from Presentation Server (no Dialog)

Checking Files on the Presentation Server

Using Platform-Independent Filenames

Maintaining Syntax Groups

Assigning Operating Systems to Syntax Groups

Creating and Defining Logical Paths

Creating and Defining Logical Filenames

Using Logical Files in ABAP Programs

Modularization Techniques

Source Code Modules

Macros

Include Programs

Procedures

Subroutines

Defining Subroutines

Global Data from the Main Program

Local Data in the Subroutine

The Parameter Interface

Terminating Subroutines

Calling Subroutines

Naming Subroutines

Passing Parameters to Subroutines

Examples of Subroutines

Shared Data Areas

Function Modules

Function Groups

Calling Function Modules

Creating Function Modules

Organization of External Procedure Calls

Special Techniques

Catchable Runtime Errors

Program Checks

Catching Runtime Errors

Checking Authorizations

Checking User Authorizations

Defining an Authorization Check

Checking the Runtime of Program Segments

GET RUN TIME FIELD

Runtime Measurement of Database Accesses

Generating and Running Programs Dynamically

Creating a New Program Dynamically

Changing Existing Programs Dynamically

Running Programs Created Dynamically

Creating and Starting Temporary Subroutines

ABAP User Dialogs

Screens

Screen Elements

Screen Attributes

Screen Elements

Screen Fields

Screen Flow Logic

Processing Screens

User Actions on Screens

Processing Input/Output Fields

Pushbuttons on the Screen

Checkboxes and Radio Buttons with Function Codes

Using GUI Statuses

Reading Function Codes

Finding Out the Cursor Position

Calling ABAP Dialog Modules

Simple Module Calls

Controlling the Data Transfer

Calling Modules Unconditionally

Conditional Module Calls

Input Checks

Automatic Input Checks

Checking Fields in the Screen Flow Logic

Input Checks in Dialog Modules

Field Help, Input Help, and Dropdown Boxes

Field Help

Input Help

Input Help from the ABAP Dictionary

Input Help on the Screen

Input Help in Dialog Modules

Dropdown Boxes

Modifying Screens Dynamically

Setting Attributes Dynamically

The Field Selection Function

Setting the Cursor Position

Switching on Hold Data Dynamically

Complex Screen Elements

Status Icons

Context Menus

Subscreens

Tabstrip Controls

Custom Controls

Table Controls

Using the LOOP Statement

Looping Through an Internal Table

Example Transaction: Table Controls

Looping Directly Through a Screen Table

How the System Transfers Data Values

Using Step Loops

Selection Screens

Selection Screens and Logical Databases

Defining Selection Screens

Defining Input Fields for Single Values

Basic Form of Parameters

Dynamic Dictionary Reference

Default Values for Parameters

SPA/GPA Parameters as Default Values

Allowing Parameters to Accept Upper and Lower Case

Reducing the Visible Length

Defining Required Fields

Search Helps for Parameters

Checking Input Values

Defining Checkboxes

Defining Radio Buttons

Hiding Input Fields

Modifying Input Fields

Defining Complex Selections

Selection Tables

Basic Form of Selection Criteria

Selection Criteria and Logical Databases

Default Values for Selection Criteria

Restricting Entry to One Row

Restricting Entry to Single Fields

Additional Options for Selection Criteria

Formatting Selection Screens

Blank Lines, Underlines, and Comments

Several Elements in a Single Line

Blocks of Elements

Calling Selection Screens

Calling Standard Selection Screens

Calling User-Defined Selection Screens

User Actions on Selection Screens

Pushbuttons on the Selection Screen

Checkboxes and Radio Buttons with Function Codes

Pushbuttons in the Application Toolbar

Changing the Standard GUI Status

Selection Screen Processing

Basic Form

PBO of the Selection Screen

Processing Single Fields

Processing Blocks

Processing Radio Buttons

Processing Multiple Selections

Defining Field Help

Defining Input Help

Subscreens and Tabstrip Controls on Selection Screens

Selection Screens as Subscreens

Tabstrip Controls on Selection Screens

Subscreens on Selection Screens

Using Selection Criteria

Selection Tables in the WHERE Clause

Selection Tables in Logical Expressions

Selection Tables in GET Events

Lists

Creating Lists

Creating Simple Lists with the WRITE Statement

The WRITE Statement

Positioning WRITE Output on the List

Formatting Options

Displaying Symbols and Icons on the List

Blank Lines and Drawing Lines

Displaying Field Contents as Checkboxes

Using WRITE via a Statement Structure

Creating Complex Lists

The Standard List

Structure of the Standard List

GUI Status for the Standard List

The Self-Defined List

Individual Page Header

Determining the List Width

Creating Blank Lines

Determining the Page Length

Defining a Page Footer

Lists with Several Pages

Programming Page Breaks

Standard Page Headers of Individual Pages

Page length of individual pages

Page Width of List Levels

Scrolling in Lists

Scrolling Window by Window

Scrolling by Pages

Scrolling to the Margins of the List

Scrolling by Columns

Defining Where the User Can Scroll on a Page

Laying Out List Pages

Positioning the Output

Absolute Positioning

Relative Positioning

Formatting Output

The FORMAT Statement

Colors in Lists

Enabling Fields for Input

Outputting Fields as Hotspots

Special Output Formats

Lines in Lists

Interactive Lists

Detail Lists

Dialog Status for Lists

Context Menus for Lists

List Events in an ABAP Program

Lists in Dialog Boxes

Passing Data from Lists to Programs

Passing Data Automatically

Passing Data by Program Statements

Manipulating Detail Lists

Scrolling in Detail Lists

Setting the Cursor from within the Program

Modifying List Lines

Lists and Screens

Starting Lists from Screen Processing

Calling Screens from List Processing

Printing Lists

Printing a List after Creating it

Printing a List while Creating it

Print Parameters

Execute and Print

Printing from within the Program

Printing Lists from a Called Program

Print Control

Determining Left and Upper Margins

Determining the Print Format

Documentation Not Available in Release 4.6C

Messages

Message Management

Messages

Message Processing

Messages Without Screens

Messages on Screens

Messages on Selection Screens

Messages in Lists

Messages in Function Modules and Methods

Running ABAP Programs

Defining Processing Blocks

Event blocks

Dialog modules

Running Programs Directly - Reports

Linking to a Logical Database

Report Transactions

Event Blocks in Executable Programs

Description of Events

INITIALIZATION

AT SELECTION-SCREEN

START-OF-SELECTION

GET

GET … LATE

END-OF-SELECTION

Leaving Event Blocks

Leaving Event Blocks Using STOP

Leaving Event Blocks Using EXIT

Leaving Event Blocks Using CHECK

Leaving a GET Event Block Using REJECT

Dialog-Driven Programs: Transactions

Dialog Programs: Overview

Sample Transaction

Maintaining Transactions

Dialog Transactions

Report Transactions

Variant Transactions

Parameter Transaction

Screen Sequences

Static Next Screen

Dynamic Next Screen

Leaving a Screen from a Program

Starting a Screen Sequence

Calling Modal Dialog Boxes

Screen Sequences: Example Transaction

Calling Programs

Calling Executable Programs

Filling the Selection Screen of a Called Program

Affecting Lists in Called Programs

Program Statements to Leave a Called Program

Calling Transactions

Calling Screen Sequences as Modules

Passing Data Between Programs

Filling an Initial Screen using SPA/GPA Parameters

ABAP Database Access

Accessing the Database in the R/3 System

Open SQL

Reading Data

Defining Selections

Specifying a Target Area

Specifying Database Tables

Selecting Lines

Grouping Lines

Selecting Groups of Lines

Specifying a Sort Order

Subqueries

Using a Cursor to Read Data

Locking Conflicts

Changing Data

Inserting Lines into Tables

Changing Lines

Deleting Lines

Inserting or Changing Lines

Committing Database Changes

Performance Notes

Keep the Result Set Small

Minimize the Amount of Data Transferred

Minimize the Number of Data Transfers

Minimize the Search Overhead

Reduce the Database Load

Native SQL

Native SQL for Oracle

Native SQL for Informix

Native SQL for DB2 Common Server

Logical Databases

Structure of Logical Databases

Selection Views

Example of a Logical Database

Using Logical Databases

Linking a Logical DB to an Executable Program

Calling a Logical Database Using a Function Module

Editing Logical Databases

Creating a Logical Database

Processing the Structure

Editing a Search Help

Editing Selections

Editing the Database Program

Dynamic Selections in the Database Program

Field Selections in the Database Program

Search Helps in the Database Program

Independent Calls and the Database Program

Editing Other Components

Improving Performance

What are Contexts?

The Context Builder in the ABAP Workbench

Creating and Editing a Context

Using Tables as Modules

Using Function Modules as Modules

Using Contexts as Modules

Testing a Context

Buffering Contexts

Fields

Modules

Interfaces

Using Contexts in ABAP Programs

Finding and Displaying a Context

Creating an Instance of a Context

Supplying Context Instances with Key Values

Querying Data from Context Instances

Message Handling in Contexts

Message Handling in Table Modules

Message Handling in Function Module Modules

Working With Contexts - Hints

Programming Database Updates

Transactions and Logical Units of Work

Database Logical Unit of Work (LUW)

SAP LUW

SAP Transactions

The R/3 Lock Concept

Example Transaction: SAP Locking

Update Techniques

Asynchronous Update

Updating Asynchronously in Steps

Synchronous Update

Local Update

Creating Update Function Modules

Calling Update Functions

Calling Update Functions Directly

Adding Update Task Calls to a Subroutine

Special LUW Considerations

Transactions That Call Update Function Modules

Dialog Modules that Call Update Function Modules

Error Handling for Bundled Updates

What is Object Orientation?

What are ABAP Objects?

From Function Groups to Objects

Example

Classes

Overview Graphic

Classes - Introductory Example

Object Handling

Overview Graphic

Objects - Introductory Example

Declaring and Calling Methods

Methods in ABAP Objects - Example

Inheritance

Inheritance: Overview Graphic

Inheritance: Introductory Example

Interfaces

Overview Graphics

Interfaces - Introductory Example

Triggering and Handling Events

Overview Graphic

Events: Introductory Example

Events in ABAP Objects - Example

Class Pools

Programs, Screens, and Processing Blocks

Introductory Statements for Programs

Overview of ABAP Calls

Call Contexts

Internal Calls

External Procedure Calls

External Program Calls

Callable Units

ABAP Programs

Procedures

Screens and Screen Sequences

ABAP Statement Overview

ABAP System Fields

Syntax Conventions