Sap abap training Course Syllabus in Chennai sap abap training in Chennai

 Position of the Basis System Within the R/ System

 Application Servers

 Work Processes

 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

 Opening a Program from the Repository Browser

 Opening Programs in the ABAP Editor

 Opening Programs Using Forward Navigation

 Maintaining Program Attributes

 Editing Programs

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

 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

 Indexing Print Lists for Optical Archiving
Running ABAP ProgramsMessages

 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

 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 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/ 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 for Oracle

 Native SQL for Informix

 Native SQL for DB Common Server

 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
Using Contexts

 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

 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/ 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

 Example

 Overview Graphic

 Classes - Introductory Example
Object Handling

 Overview Graphic

 Objects - Introductory Example
Declaring and Calling Methods

 Methods in ABAP Objects - Example

 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

 Call Contexts

 Internal Calls

 External Procedure Calls

 External Program Calls

 Callable Units

 ABAP Programs

 Procedures