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
      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
            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
   ABAP Objects
      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
   Appendix
      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
      ABAP Glossary
      Syntax Conventions