Advanced ABAP

Statement-Oriented Language: every statement began with a keyword, followed by some operands and
additions, and ended with a full-stop.

COMPUTE

CALL METHOD

MOVE

DESCRIBE TABLE <internal_table> LINES <variable>

Replaced by: LINES( <internal_table> )

Functional Methods

Chain of Methods Calls

reference_object->method_1( )->method_2( ).

CONV

CONV <data_type>( <data_object> )

Converts the contents of the data object enclosed in the parentheses into the data type before the
opening parentheses.

If the conversion is not possible, the program will react with an exception. The precise exception class
depends on the conversion that you tried to perform, but all are subclasses of the class
CX_SY_CONVERSION_ERROR.

Pound Sign #

With CONV: used instead of an explicit target type before the opening parenthesis. The target type is
derived from the context of the expression.

CONV #( <data_object> )

EXACT
<field_name> = EXACT #(<value>)

Ensures that the value you are assigning to the field fits the target field with no losses.

If the assignment cannot be performed without loss of data, an exception occurs, it will be a subclass of
the class CX_SY_CONVERSION_ERROR.

CORRESPONDING

If the argument is a structure, it searches for components that exist with identical name in the source
structure and the target structure and copies the values of these components.

Looks for identical component names and attempts a conversion when source and target type are not
the same.

SWITCH

The value of the variable or result of the expression is compared with each of the values after WHEN
and, if it matches, the value following THEN is taken as the result of the expression.

The construct may conclude with an ELSE clause.

The result of a WHEN or ELSE expression may be to raise a class-based exception.

Typically, a SWITCH expression replaces a CASE ... ENDCASE construct.

COND

Returns a value depending on the result of a logical expression.

You may specify one or more logical expressions in the form WHEN <logical expression> THEN <value>.

May conclude with an ELSE clause.

Similar to an IF… ELSEIF… ELSE… ENDIF construct.

You can declare data objects using the following:

Predefined ABAP types: differentiated depending on whether the system requires an additional length
specification when you declare the corresponding data objects.

Global data types

Local data types: defined using TYPES statement.

Incomplete Types: have to be supplemented with a length specification to create a complete type using
the LENGTH addition to DATA or TYPES statements.

Complete Types

STRING

XSTRING

DECFLOAT16

DECFLOAT34

Numeric ABAP Data Types:

I: Integer

P: Packed Number

F: Binary Floating Point Number

DECFLOAT16: Decimal Floating Point Number

DECFLOAT34: Decimal Floating Point Number

INT8: Large Number

Character-Like Data Types:

N: Sequence of Digits

C: Sequence of Characters

D: Date Field
T: Time Field

STRING: Sequence of Characters

Byte Types

X: Sequence of Bytes in Hexadecimal Notation

XSTRING: Sequence of Bytess in Hexadecimal Notation

Generic Types:

Do not completely define the attributes of a data object, and therefore cannot be used in the
declaration of data objects.

Used exclusively to type format parameters.

Predefined Generic Types:

- ANY: Any Type

- DATA: Any Data Type

- SIMPLE: Elementary Data Type of Flat, Character-Like Structure

- NUMERIC: Numeric Data Type

- DECFLOAT: Numeric Data Type

- CLIKE: Character Data Type

- CSEQUENCE: Text Data Type

- XSEQUENCE: Byte Data Type

Data Object

Can be categorized as follow:

- Flat data objects: have a static length and do not refer to other objects. All elementary data objects
apart from strings and all structures with exclusively flat components (regardless of potential nesting)
are flat.

- Deep data objects: include references, strings, and internal tables. Structures are also called deep if
they contain at least one deep component, taking all includes and substructures into account.

In terms of internal structure:

- Elementary fields.
 - Structures

- Internal tables

- References

Literals:

Numeric literals

Text field literals: a character string that is enclosed in single quotation marks (')

String literals: a character string that is enclosed in back quotation marks (`). Spaces are not suppressed
at the end of a string literal, compared to text field literals.

Visibility of Data Objects:

Locat Data Types

- Between FORM and ENDFORM

- Between FUNCTION and ENDFUNCTION

- Between METHOD and ENDMETHOD

Global Data Types

The TABLES statement always creates data objects that are visible throughout the program, even if the
statement appears within a subroutine or function module.

Visibility of Data Objects in Object-Oriented ABAP:

Private Attributes

Public Attributes

Protected Attributes

STATIC Statement

When used to declare local data objects, the system extend their lifetime to the overall program
lifetime. Therefore, these such data objects have the same lifetime as global data objects, but their
visibility is still limited to the respective modularization unit.

Can be used in function modules, subroutines, and static methods.

Array Fetch (SELECT ... INTO TABLE): The ABAP runtime system copy the contents of the database
interface directly to an internal table.

New Open SQL Syntax:

You cannot use classical and new syntax elements in the same Open SQL statement.

Use of @ symbol to escape host variables.

Comma separated field list in the SELECT statement.

The INTO clause can (and should be) the last clause of a SELECT statement.

The FROM clause of a SELECT statement can be specified in front of field list. In this case, the field list
must be introduced using the new addition FIELDS.

Inline declarations can be made using the declaration operator DATA(...) with the prefixed escape
character @.

Host Variable: an ABAP variable or constant inside an Open SQL statement. Escaped using @ symbol.

Two options when calling another program synchronously:

The process flow of the calling program pauses while the called program executes, and resumes when
the called program is complete.

The calling program terminates and the called program starts.

Sequential Calls

Synchronous Calls

Asynchronous Processing (Execution)

Passing Data for Input Fields of the Standard Selection Screen When Calling the Program:

By specifying a variant for the selection screen.

By specifying specific values for the input fields.

UPDATE techniques:

Asynchronous (default)

Synchronous

Local

ABAP Compiler: generate develpment objects.

Runtime Object (LOADS):

Created by the system when you generate a development object.

To avoid generating programs every time they run, program LOADS are saved in the database and
buffered on the application server.

Parts of a Program:

Non-modifiable parts of a program:

- Byte code for statements

- Values of constants and literals.

- Program texts.

- Screen definitions.

Modifiable parts of a program:

- Data objects (variable)

Working Memory:

PXA

Roll Areas

Program Execution Area (PXA)

A memory area that is shared by all users on the application server and exists only once on each server.

Used by the systrem to store non-modifiable parts of a program and buffer them there as long as
possible.
Check whether a program is loaded into PXA:

1. Transaction code: ST02

2. Detail Analysis Menu

3. Other Buffers - Program

4. Buffered Objects

Roll Area

A memory space in which the modifiable parts of a program are created during every execution.

Each execution of a program has its own roll area.

Logical Memory Model

External Session

Main session

Corresponds to an SAPGUI window.

Up to 16 external sessions are possible,

The maximum number of sessions available in a given system is defined by system parameter
rdisp/max_alt_modes (default 6)

Subdivided into internal sessions (paced in a stack)

Internal Session

A maximum of nine internal sessions can exist in each external session, and they must all belong to the
same call stack.

The system reserves on roll area for each internal session.

Program Groups

The programs within an internal session.

Each program group contains one main program, and possibly other programs as well.

There can be one or more additional program groups (any number of additional program groups can be
created in the same internal session).
The program data objects are only visible within its program group

MPG => Main Program Group

APG => Additional Program Group

COMMON PART

Analyzing the memory management for user sessions

Transaction Codes: SM04 and AL08

Exiting an internal session:

Entering /I in the command field.

The system automatically initializes or releases the corresponding ABAP memory.

EXPORT ... TO MEMORY

EXPORT ... TO MEMORY ID ...

IMPORT ... FROM MEMORY

IMPORT ... FROM MEMORY ID ...

Data Cluster: number of ABAP data objects with their current values. In the cluster, the content of a
given ABAP data object is labeled with a symbolic name.

SAP Memory Areas (Called Parameters)

SET PARAMETER ID <id> FIELD <field>

GET PARAMETER ID <id> FIELD <field>

INITIAL SIZE addition to DATA statement

CLEAR, REFRESH, & FREE

FREE statement can delete the table header if it takes up too much memory (compared to CLEAR &
REFRESH).

COPY-ON-WRITE semantics

Shared Objects

Shared Objects Memory: where an application can save shared objects.

Shared Memory

A memory area on an application server that the ABAP programs running on the same server can access.

Enhanced by the introduction of shared objects.

SHARED BUFFER and SHARED MEMORY additions (to EXPORT and IMPORT statments): were used,
before shared objects, to access shared memory area.

Saving an Object in Shared Memory:

If the class is local: SHARED MEMORY ENABLED addition in the CLASS statement.

If the class is global class, select the SHARED MEMORY ENABLED attribute in the Class Builder.

Area

The template for area instances in shared memory.

One area can generate several area instances.

For an area, the sytem generates an identically named global and final area class as a subclass of
CL_SHM_AREA.

Area Instance

Differ by name.

Can have several versions that differ in their version IDs or version numbers.

Creating an Area Instance

Anlayze a Shared Objects Area

Transaction Code: SHMA

Area Name

Monitor

Tabs: Areas | Shared Objects Memory

Changing the View

Selecting an Active Version

Reading an Active Version => Instance of the Root Object

Root Class

In Test Envrionment

Attributes for All Root Class

CL_SHM_AREA Class

DETACH_COMMIT method: remove a change lock.

AREA HANDLE addition for CREATE OBJECT statement: creates an object in the shared objects memory.
It informs the system about the area instance where it should create the objects.

ATTACH_FOR_WRITE method

ATTACH_FOR_READ method: the program obtains the handle for the area instance. It sets a read lock
that prevents the system from deleting the area instance during the access.

SET_ROOT method

DETACH method

CL_SHM_UTILITIES class: programmatically query the attributes of area instances.

NUMBER OF VERSIONS attribute of the area

OUTDATE attribute of the area

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

Arithmetic Expressions

Pure Arithmetic Expressions: all of the involved data objects have the same type

Mixed Arithmetic Expressions

Numeric Data Types

Calculations with integer arithmetic are faster than calculations with fixed-point or floating-point
arithmetic because the system executes them directly using the processor's airthmetic command set.

Floating-point arithmetic:

- The main advantage of floating-point numbers is their large range of values. In addition, you need to
use floating-point numbers for special aggregation functions of the SELECT statement.

- Floating-point arithmetic is unsuitable for business calculations because business calculations have to
be exact and comply with legal rounding regulations.

SAP introduced packed numbers in ABAP to expand the value range of decimal numbers, but avoiding
the rounding problems associated with floating-point numbers. You should always accept this value and
use packed numbers for business calculations.

Decimal floating-point numbers vs. Binary floating-point numbers

Two kinds of decimal floating point numbers:

1. DECFLOAT16

2. DECFLOAT34

Conversions affect performance: To avoid conversions, ensure that all operands and the result field have
the same numeric type.

ABAP Statements for Processing Character-Type Data Objects:

CONCATENATE: combine multiple strings

FIND: find pattern (firs/all occurrences). Replaced by the statement SEARCH

REPLACE: replace pattern (firs/all occurrences).

SHIFT: shift left/right

SPLIT: split string in segments

CONDENSE: remove space characters. Doesn't set system field SY-SUBRC.

OVERLAY: replace characters in string by characters from second string 2 at same position.

TRANSLATE: replace characters according to rule. Doesn't set system field SY-SUBRC.

WRITE..TO: format string.

Additions:

IN BYTE MODE

IN CHARACTER MODE

Byte-type Data Objects:

X, XSTRING

All elementary data objects with a byte-type data type.

Character-type Data Objects:

C, N, D, T, STRING

All elementary data objects with a character-type data type.

Non-Unicode Systems

Unicode Systems: can differentiate clearly between byte-type and character-type data objects.

Comparison Operators

Character Type:

- CO: contains only

- CA: contains any

- CS: contains substring

- CP: compare pattern

- CN: contains not only

- NA: contains not any

 - NS: contains no string

- NP: does not match pattern

Byte Type:

- BYTE-CO

- BYTE-CA

- BYTE-CS

- BYTE-CN

- BYTE-NA

- BYTE-NS

String Expression: consists either of one string template or of two or more operands concatenated as a
character string.

String Template:

Define a character string, that is determined by any sequence of text literals, embedded expressions, or
control characters.

Enclosed in two "|" characters. A string template that starts with “|” must be closed with “|” within the
same line of source code.

Can only be specified in Unicode programs.

String Operator: &&

Control Characters:

\n

\r

\t

Fomatting Options that Can Be Used in String Expressions:

WIDTH

ALIGN
PAD

CASE

SIGN

EXPONENT

DECIMALS

ZERO

STYLE

CURRENCY

NUMBER

DATE

TIME

TIMESTAMP

TIMEZONE

COUNTRY

CL_ABAP_FORMAT class: constants that may be assigned to the formatting parameters are defined in
this class.

ABAP functions are divided into three groups as follows:

Descriptive functions: returning a numeric result

Processing functions: returning a character-type result

Predicate functions: returning TRUE or FALSE

String Functions:

STRLEN

NUMOFCHAR

FIND

FIND_ANY_OF

COUNT
COUNT_ANY_OF

Processing Functions:

CMAX

CMIN

CONCAT_LINES_OF

ESCAPE

MATCH

REPEAT

REVERS

TO_LOWER

TO_MIXED

FROM_MIXED

TRANSLATE

SHIFT_LEFT

SHIFT_RIGHT

CONDENSE

TO_UPPER

REPLACE

INSERT

SUBSTRING

Predictive Functions: can be used to find out if a certain substring or search pattern exists in a character
string.

CONTAINS(): supports strings defining search patterns. Allows you to check for multiple occurrences of
search patterns.

MATCHES(): accepts regular expressions only

Regular Expressions:

A literal containing all kinds of characters.

Used for complex string processing.

One of the principle uses is the search for substrings in character strings.

Th search of regular expressions is realized using the addition REGEX of the statement FIND, whereby
the substrings found are determined without overlapping according to the leftmost-longest rule.

The replacement is realized using regular expressions with the addition REGEX of the statement
REPLACE.

Special Character Combinations to Describe a Single Character:

. => placeholder for single character

\<c> => placeholder for group characters.

[ ] => value set for single character

[^ ] => negation of a value set for single character

[ - ] => value range for single character

[[:<c>:]] => description for group of characters.

Additional Special Character Combinations to Describe a Character String Expression

{n} => concatenation of n single characters

{n,m} => concatenation of n to m single characters

? => one or more single character

* => arbitrary number of characters (including emtpy string)

+ => arbitrary number of characters (excluding empty string)

| => logical OR

(?: ) => Subgroup definition (without registration).

() => subgroup definition with registration.

String Functions that Support the Use of Regular Expressions:

COUNT ()
COUNT_... ()

CONTAINS... ()

FIND ()

FIND_... ()

MATCH ()

MATCHES ()

REPLACE ()

SUBSTRING ()

SUBSTRING_... ()

MATCH( VAL = `<string_value>`

REGEX = '<regex_value>' )

FIND ALL OCCURRENCES OF REGEX `<regex_value>` IN `<string_value|variable_name>` RESULTS

<variable_name>

REPLACE ALL OCCURRENCES OF REGEX `<regex_value>` IN `<string_value|variable_name>` WITH

`<string_value>`

Special Character Combinations that Support Searching in a Character String:

\A

\z

\<

\>

(?= )

(?! )

Character Combinations that Can be Used in the Replacement Text:

$` => complex text before current found location

$' => complete text after current found location

$n => character string stored in the register of subgroups for the n-th found location

$& => complete text

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

Internal Tables

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

Internal Table Categories:

Standard

Sorted

Hashed

- The table kind determines how the runtime environment stores data in the table and how the
application program can access this data.

- The main reason for using sorted and hashed tables is not to gain additional features but to improve
efficiency when accessing large internal tables. The one additional feature is the possibility to define a
unique key for sorted and hashed tables.

Standard Tables

Managed internally using a table index (line numbers).

You can append new lines at the end of the table or insert them at specific positions.

The system has to search the entire table sequentially during a key access. If the internal table is
explicitly sorted by using the SORT statement, the BINARY SEARCH addition can significantly speed up
access.

Sorted Tables

Managed using a table index.

The entries are always kept sorted by the table key in ascending order.

The runtime environment automatically performs a binary search during table key accesses.

If the sorted table has a non-unique key, several lines could match the criteria. The system always
returns the first line of the block, that is, the entry with the smallest index.
You must never change the sort sequence of a sorted table, even temporarily. If the sort sequence is
destroyed, and ITAB_ILLEGAL_SORT_ORDER runtime error occurs.

Hashed Tables

Managed internally using a hash algorithm.

A hash board is created in addition to the actual table and the memory addresses of the table lines are
managed in that table.

The table contents are completely unsorted.

A hash function makes it possible to directly calculate the position of the entry in the hash board from
the key values.

The key of a hashed table must always be unique.

Loops (LOOP ... ENDLOOP) ignore the hash board and search the table contents directly. The content is
unsorted, but for this purpose, it can be sorted by using the SORT statement.

GET RUN TIME FIELD <field_name>

Types of Access:

Index Acces

Key Access

READ TABLE Statement

Reading single records from internal tables.

If several entries satisfy the condition, it always returns the first entry.

INDEX addition: specifies an explicit index. It is not allowed for hashed tables.

FROM addition: perform key accesses with an implicit specification of the key.

WITH (TABLE) KEY addition: perform key accesses with an explicit specification of the key.

TRANSPORTING addition: copies selected columns instead of the entire line into the specified structure
defined in the program (after INTO).

TRANSPORTING NO FIELDS addition: the system looks for a line with the specified index and/or key,
setting the SY-SUBRC and SY-TABIX system fields accordingly. No data is read and INTO is not needed.
Keys:

Implicit: the key field values are taken from the structure after the FROM addition. FROM and INTO do
not need to have the same structure.

Explicit:

- WITH TABLE KEY addition: the full table key can be specified. The syntax check demands that all of
the key fields in the table are listed and supplied with a value. If a key field is missing, this causes a
syntax error.

- WITH KEY addition: any other key can be specified. The syntax check does not compare them with
the key fields.

Single Record Write Access

Statements:

- INSERT .. INTO

- MODIFY

- DELETE

The type of access:

- By index: not allowed in hashed tables

- By Key: the keyword TABLE appears next to the name of the internal table.

Within loops:

- By index: you can omit the explicit index, the system implicitly uses the current value from SY-TABIX.

- The constraint that these statements can only be used within loops is not verified by the syntax check
(it causes a fatal exception TABLE_ILLEGAL_STATEMENT).

WHERE Condition:

Specified in special variants of MODIFY and DELETE. You should specify the internal table without the
TABLE addition in these statements.

If you combine MODIFY and WHERE, you must use the TRANSPORTING addition

Mass Access

With the use of WHERE, the runtime required to locate the line depends primarily on the table type.

Loops:
LOOP AT <internal_table> INTO <work_area>

WHERE addition: WHERE <conditions>

FROM addition: FROM <starting_point: sy-tabix>

EXIT statement: an explicit termination ends processing as soon as the execution reaches a line that
does not satisfy the condition.

Testing a Global Class

Creating an instance of the class

Testing instance methods

Editing the Source Code of a Global Class => Source Code-Based Button

BINARY SEARCH addition of READ TABLE statement:

Makes the runtime environment apply the same binary search algorithm in a key access to a standard
table.

Reduce the access time for large tables.

When using the this addition for key access to standard tables, the table must be sorted by the fields
used to restrict access. Using a binary search when the table is not sorted leads to incorrect results.

You cannot optimize a single access with the BINARY SEARCH addition if you must sort the table
specifically for that access.

SORT <internal_table> BY <field>

MOVE-CORRESPONDING Statement

Can be used for internal tables.

KEEPING TARGET LINES addition: stops the target table from being deleted. Instead, the statement adds
the same number of rows as exist in the source table.

DELETE ADJACENT DUPLICATES Statement

Removes duplicate lines from an internal table.

The system deletes all lines in which the contents of certain fields are identical to the contents of the
same fields in the immediately preceding lines.
Retains the first line of each group in the internal table and deletes all the others.

The table must be sorted by the comparison fields if the statement is to find and remove all duplicates.

Default (without the COMPARING addition): compare by key fields for internal tables with non-unique
keys. With unique keys, there cannot be two lines with the same contents in the key fileds.

COMPARING addition: compares the contents of any number of columns.

COMPARING ALL FIELDS addition: compares all fields. It deletes only those lines that are completely
identical to its preceding line.

COLLECT Statement

A special technique for filling an internal table.

if the table does not have a line with the same key yet, it has the same effect as an INSERT by key.

Sums the values of all non-key fields in the new line to the corresponding values in the top line, if the
table already contains one or more lines with this key.

Only allowed when all non-key fields are numeric.

WITH DEFAULT KEY addition: define an internal table with a standard key. It ensures that all non-key
fields are numeric (all non-numeric fields are key fields and all non-key fields have a numeric type).

Secondary Keys

Can be hashed or sorted.

A sorted secondary key can be unique or non-unique.

The maximum number of secondary keys per internal table is 15.

You can define secondary keys for table types in the TYPES statement or the DATA statement.

WITH UNIQUE HASHED KEY <key_name> COMPONENTS <columns_list>

WITH NON-UNIQUE SORTED KEY <key_name> COMPONENTS <columns_list>

WITH UNIQUE SORTED KEY <key_name> COMPONENTS <columns_list>

WITH NON-UNIQUE KEY primary_key ALIAS <alias> COMPONENTS <column>

Using a Secondary Key in a Processing Statement:

USING <key_name> addition

WITH KEY <key_name> addition

Processing statements where the use of secondary keys are not allowed: APPEND, INSERT, READ...WITH
TABLE KEY, DELETE...WITH TABLE KEY.

Update of secondary keys:

- Non-unique secondary key: the update is delayed until the next statement that explicitly uses this
secondary key (lazy update). The first access is slower, because the key has to be updated.

- Unique secondary key: the update is at the successive access to the internal table. The first read using
the secondary key is relatively fast.

- Use non-unique secondary keys because the system always delays the update and peforms the
update only when the respective secondary key is actully used. In addition to uniqueness violation when
using unique secondary key.

Recommendations for using secondary keys:

- Use secondary keys only when deployed often.

- Prefer non-unique secondary keys.

- Be careful with index operations.

Table Expression

- Can be viewed as a short form for a variant of the statement READ TABLE.

- ASSIGN statement

- Table — descriptive — function line_index(): returns the number of the row found for the table
expression specified. The return value has the type i.

- Predicate function line_exists(): checks whether the row of an internal table specified in the table
expression exists and returns the appropriate logical value.

The VALUE() Operator:

Assign values to a simple variable, structure, or internal table.

The option BASE: build the result on top of an existing internal table.

FOR addition: builds the result based on an existing internal table. It defines a loop — with an optional
selection — and constructs one new line in the result for every line in the source.

Parenthesises identify one row of the internal table

Data References
Data objects that contain the address of any other data object of the specified type.

Data reference variables contain data references or pointers to data objects.

Uses reference semantics: when a data reference variable is accessed, the data reference is addressed.

TYPE REF TO addition for the TYPES statement: define a reference type for a data object.

The DATA statement defines the data reference variable.

GET REFERENCE OF statement: obtain a reference to a data object that has already been defined.

REF operator

De-referencing Operator: ->

Object References

<reference_variable> IS BOUND expression: query whether the reference variable contains a valid
reference.

<reference_variable> IS INITIAL expression: determine whether the reference variable contains the null
reference.

Field Symbols

Provide symbolic access to an existing data object. All accesses you make to the field symbol are made
to the data object assigned to that field symbol (the value semantics of field symbols).

FIELD-SYMBOLS statement: declare field symbols. The angle brackets (<>) in the field symbol name are
part of the syntax.

ASSIGN statement: assign a data object to the field symbol.

IS ASSIGNED expression: find out whether the field symbol is assigned to a field.

UNASSIGN statement: sets the field symbol so that it points to nothing.

Inline Declarations for Field Symbols:

- The type of the field symbol is derived implicitly from the context of the declaration.

- The visibility of the field symbols is the same as if the field symbol had been declared statically in the
same context.
 - FIELD-SYMBOL is used to decalre field symbol.

If a field symbol or data reference points to a line of the internal table you can access this table line via
the field symbol or by dereferencing the data reference.

ASSIGNING <field_symbol> addition to READ TABLE and LOOP AT: assign the rows of the internal table
to a field symbol. The system does not copy the entry from the internal table to a work area and back
again.

ASSIGNING <field_symbol> additions to INSERT, COLLECT, and MODIFY statements: used to point a field
symbol to the processed line of an internal table.

REFERENCE INTO <reference_name>

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

Dynamic Programming

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

The parts of the statement that will be defined at runtime are replaced with a data object.

Two cases with regard to syntax (depending on the use of the data object):

- The data object in place of a literal

- The data object in place of an identifier

To avoid ambiguity, specify the data object whose content appears in place of an identifier in
parentheses.

Not all ABAP syntax supports the dynamic specification of certain components of an ABAP statement.

Dynamic Open SQL

Clauses of a SELECT statement that can be supplied dynamically using a data object:

- FROM clause.

- WHERE clause.

- The field list.

- ORDER BY addition.

The INTO clause is the only clause that does not support the use of the dynamic technique.

Field symbols and data references are used to dyanmically determine the data object that is filled by the
SELECT statement.
If you use dynamic SQL statements, be sure to always catch and handle the errors (exception classes
CX_SY_DYNAMIC_OSQL_SEMANTICS and CX_SY_DYNAMIC_OSQL_SYNTAX)

Calling Modularization Units Dynamically:

Replace the name of the modularization unit, the transaction, or the program with a character-type data
object in the call syntax.

Do not use parentheses for function modules or transaction codes because variables replace text
literals.

Use parentheses for subroutines, methods, and executable programs because here you replace an
identifier not a literal.

You can pass parameters in dyanmic calls statically or dynamically.

Calling Function Modules Dynamically

PARAMETER-TABLE statement: dyanmically assign the actual parameters to the formal parameters.

The actual parameters are assigned to the formal parameters dynamically by specifying an appropriately
typed internal table after the PARAMETER-TABLE addition. The internal table must have table type
ABAP_FUNC_PARMBIND_TAB from type group ABAP, which defines a sorted table (use key access with
INSERT...INTO TABLE to fill it).

The line type includes the following components:

- NAME: the name of the formal parameter. Specify NAME in uppercase.

- KIND: the type of parameter transfer (exporting, importing, changing, or tables). Use the constants
ABAP_FUNC_EXPORTING, ABAP_FUNC_IMPORTING, ABAP_FUNC_TABLES, and ABAP_FUNC_CHANGING
to fill it.

- VALUE: the data reference to the value supplied for the parameter. This field has the generic type
TYPE REF TO DATA. Fill the field with a GET REFERENCE OF <actual_parameter> INTO
<work_area_of_parameter_table>-<value> statement.

To catch an exception raised by the funcion module dynamically, specify an internal table with type
ABAB_FUNC_EXCPBIND_TAB after the EXCEPTION-TABLE addition in which the name and value columns
define the assignment between the conventional exception and a value for system field SY-SUBRC. The
evaluation of SY-SUBRC needs to be implemented after the dyanmic call of the function module.

Catch and handle the runtime errors of the exception classes (start with CX_SY_DYN_CALL_), or catch
and handle the superclass CX_SY_DYN_CALL_ERROR instead.

The syntax:

TRY.
 CALL FUNCTION <function_moule_name>

PARAMETER-TABLE <parameter_table>

EXCEPTION-TABLE <exception_table>.

IF sy-subrc <> 0.

...

ENDIF.

CATCH ...

ENDTRY.

Dynamic Method Calls:

Similar to the procedure for function modules.

The internal tables must have table type ABAP_PARMBIND_TAB (describe a hashed table) and
ABAP_EXCP_TAB from type group ABAP.

The KIND field can remain initial in method calls. To fill the field, the corresponding constants are
contained in global class CL_ABAP_OBJECTDESCR, not type group ABAP.

The exception classes for the runtime errors are subclassesx of class CX_SY_DYN_CALL_ERROR.

The syntax (static method as an example):

TRY.

CALL FUNCTION CLASS_NAME=>(<method_name>)

PARAMETER-TABLE <parameter_table>

EXCEPTION-TABLE <exception_table>.

IF sy-subrc <> 0.

...

ENDIF.

CATCH ...

ENDTRY.

Dynamic Program Calls

WITH SELECTION-TABLE addition to SUBMIT statement: supply the selection screen with values by
passing an internal table with the dictionary type RSPARAMS as the line type.
The components of the RSPARAMS structure type:

- SEL_NAME: the name of the parameter or selection criterion (SELECT-OPTIONS) in uppercase.

- KIND: The values P and S determine whether it is a parameter or a selection criterion.

- SIGN, OPTION, LOW, HIGH: for selection criteria (KIND = ’S’), the SIGN, OPTION, LOW, and HIGH
values correspond with the same columns in a SELECT-OPTIONS internal table. For parameters (KIND =
’P’), fill only the LOW field.

INSERT REPORT Statement

Creates a program that is saved permanently in the repository.

Fill an internal table with the source code that has a REPORT statement in the first line.

Do not forget the period at the end of each ABAP statement.

The contents of the internal table are saved as an executable program (program type 1).

Once the program is saved, it can be called with the SUBMIT statement.

The syntax:

INSERT RERPORT <program> FROM <internal_table>

Subroutine Pool Generation

GENERATE SUBROUTINE POOL <internal_table> NAME <program>: generates a program with type S - a
subroutine pool. This program exists only at runtime of the generating program and contains only
subroutines.

Call these subroutines with an external subroutine call

PERFORM <form_name> IN PROGRAM <program>.

Generic Data Types:

You cannot use generic types to define the properties of data objects.

You only use generic types to type formal parameters and field symbols.

Currently, the two built-in types, ... TYPE REF TO OBJECT and ... TYPE REF TO DATA are the only types
available for typing reference variables generically.

Each of the generic types is compatible with the set of ABAP types:

- Fully generic: ANY and DATA

 - Elementary, flat: SIMPLE

- Numeric: NUMERIC and DECFLOAT

- Character-type: CLIKE and CSEQUENCE

- Hexadecimal: XSEQUENCE

- Internal tables: ANY TABLE, INDEX TABLE, STANDARD TABLE, SORTED TABLE, and HASHED TABLE.

Generically Typed Formal Parameters

When you generically type formal parameters of a procedure, the procedure becomes more flexible.

Use the syntax check to ensure that the procedure handles the different types.

If conflicts occur, the system raises runtime errors that cannot be caught in most cases (like
OBJECTS_NOT_CHARCONV).

Generically Typed Field Symbols

ASSIGN data_object TO <field_symbol> CASTING [TYPE type_name]

CASTING addition to ASSIGN statement: used when a data object is assigned to a field symbol that has a
different type, the restrictions of having to use the data objects original type are removed.

CASTING TYPE addition to ASSIGN statement: used when assigning a data object to a field symbol that
has a different type, the data object can be accessed using the field symbol as if it has that explicitly
specified type.

Dynamic Access to Data Objects, Insance Attributes, and Class Attributes Using ASSIGN statement:

- Any data object: object_name

gv_name = 'VARIABLE'.

ASSIGN (gv_name) TO <field_symbol>.

- Structure component:

1. Structure component (using the full name)

gv_name = 'STRUCTURE-COMPONENT'.

ASSIGN (gv_name) TO <field_symbol>.

2. Structure component (using its component name)

gv_comp_name = 'COMPONENT'.
 ASSIGN COMPONENT gv_comp_name OF STRUCTURE structure TO <field_symbol>.

3. Structure component (using its position in the structure)

gv_comp_number = 2.

ASSIGN COMPONENT gv_comp_numer OF STRUCTURE structure TO <field_symbol>

- Static attribute:

1. gv_name = 'CLASS=>STATIC_ATTRIBUE'.

ASSIGN (gv_name) TO <field_symbol>.

2. gv_attribute_name = 'STATIC_ATTRIBUTE'.

gv_class_name = 'CLASS_NAME'.

ASSIGN (gv_class_name)=>(gv_attribute_name) TO <field_symbol>.

- Instance attribute:

1. gv_name = 'OBJECT->INSTANCE_ATTRIBUTE'.

ASSIGN (gv_name) TO <field_symbol>.

2. gv_attribute_name = 'INSTANCE_ATTRIBUTE'.

ASSIGN object_name->(gv_attribute_name) TO <field_symbol>.

Genrically Typed Data References

Only the generic types DATA (for data references) and OBJECT (for object references) are available for
reference variables.

Generically typed reference variables cannot be dereferenced directly in operand positions.

Only use generic data references where generic field symbols do not work.

Addressing the content of referenced data objects:

- Use fully-type data reference.

Cast assignment: assigning values between two reference variables with different types

- Upcast: occurs when the target variable has a more general definition than the source variable

- Downcast: occurs when the target variable has a more specific type than the source variable

While upcasts to type TYPE REF TO DATA always work, the downcast must have the ?= cast operator to
pass the syntax check.

Class-based exception CX_SY_MOVE_CAST_ERROR occurs if the type of the new reference variable does
not match the exact type of the referenced data object.
ASSIGN statement:

- Can be used to dereference a generically typed reference variable.

- Assigns a (generic) field symbol to the data object to which the generic reference variable points.

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

Dynamic Data Types, Data Objects, and Objects at Runtime

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

RTTI Class Hierarchy

RTTI: Runtime Type Identification

Class-based concept.

Consists of a hierarchy of ten global classes.

Determines type properties, such as data types and object types, at runtime.

All classes inherit properties from a shared superclass, either directly or indirectly, and their names all
follow the pattern CL_ABAP_xxxDESCR (xxx stands for the category of the type used to describe the
respective class).

Each class relate to a specific category of types.

Six of the ten RTTI classes can be instantiated and used to describe specific types.

- CL_ABAP_ELEMDESCR: describe elementary data types

- CL_ABAP_REFDESCR: describe reference types

- CL_ABAP_STRUCTDESCR: describe structure types

- CL_ABAP_TABLEDESCR: describe table types

- CL_ABAP_CLASSDESCR: describe classes

- CL_ABAP_INTFDESCR: describe insterfaces

All other RTTI classes are abstract, which means that they cannot be instantiated. They are used to
centrally define the attributes and methods that are used in several of the other classes:

- CL_ABAP_TYPEDESCR

- CL_ABAP_DATADESCR

- CL_ABAP_COMPLEXDESCR

- CL_ABAP_OBJECTDESCR
It is not possible to instantiate the RTTI description classes directly with the CREATE OBJECT statement.
To retrieve a reference to a description object, call static method DESCRIBE_BY_xxx of class
CL_ABAP_TYPEDESCR. The description objects are generated and the data is filled and returned using a
return parameter with generic type REF TO CL_ABAP_TYPEDESCR.

DESCRIBE FIELD and DESCRIBE TABLE statements: limited to properties of data objects, and do not
determine as many properties as RTTI.

CREATE OBJECT statement

Creates objects or specifically, instances of classes at runtime.

TYPE addition: specify the class to be instantiated. If used it enables the use of a token (dynamic
selection of the class to be instantiated).

LIKE addition

LENGTH addition

DECIMALS addition

HANDLE addition: generate a data object whose type matches the specified type description object (an
RTTI type object).

CREATE DATA reference_variable TYPE HANDLE description_object.

Constructor expression NEW

An alternative for statement CREATE OBJECT.

Does not support tokens to specify the class (specifying the class dynamically)

Does not support additions (LIKE, TABLE OF, LENGTH, DECIMALS, etc.)

Dyanmic parameter transfer: performed using internal tables after the PARAMETER-TABLE and
EXCEPTION-TABLE additions.

CREATE DATA Statement

Creates data objects at runtime, it is used in a similar way to the CREATE OBJECT statement.

Creates a data object dyanmically, assigns memory to it, and points the data reference variable to that
data object in memory. The data object is not given a name, so it is often called an anonymous data
object.
Token: data object in parentheses.

RTTC (Runtime Type Creation): the RTTI concept was enhanced, in addition to describing existing types,
you can use it to generate new types.

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

ABAP Open SQL

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

SAP Database Interface (DBSS)

Accepts the SQL statements that the ABAP applications send in dialog work processes (Dia-WP)

Retrieves the requested data

Makes the requested data available to the application program.

Divided into an ABAP Open SQL interface and a native SQL interface.

Tasks of the ABAP Open SQL interface:

- Translating ABAP Open SQL to native SQL

- Client handling, including the client in the WHERE condition

- Managing the SAP table buffer

Database Work Processes: handle the requests from the SAP application servers. The system assigns
each work process on the application server side to exactly one work process in the database.

Database Cache (buffer): storing frequently used data.

Database Cursor Cache (Database Access Paths): a shared memory allocated by the database, which
contains the redo log and other information.

Database Optimizer

A database feature that analyzes an SQL statement and then determines an access strategy based on
the WHERE condition and the structure of the existing indexes.
Two groups of optimizers:

- A rule-based optimizer: uses a set of analysis rules to determine the most appropriate procedure for
executing the statement.

- A cost-based optimizer: uses more information about the table, and produce faster access to the
data.

Data Block:

Index records and table records are organized in data blocks.

The system searches for the requested data records either in the database table directly by:

- Using a full table scan

- With the assistance of an index

An index scan:

- An index unique scan or an index range scan.

- If the index contains all the requested fields, the table itself does not need to be accessed.

Types of data blocks:

- Index blocks

- Table blocks

The represent the granularity with which data can be written to or read from the hard drive.

Data blocks can contain several data records, or one data record can stretch over several data blocks.

Database index:

- Root block

- Branch blocks

- Leaf blocks

Key Fields or Primary Keys: combination of fields that uniquely identify an entry within the table.

Primary Index: unique

Index Search String

Formed from the WHERE condition.

The system concatenates the desired values of the fields contained in the index.

The longer the search string is, starting from the left, without placeholders ("_" or "%"), the more
efficient the access through this index.

The corresponding positions of the missing fields in the WHERE condition are set to "_" in the index
search string.

Qualify (fill with values) as many index fields as possible, from left to right, and do not leave any gaps in
the index search string.

When creating an index for a database table, the MANDT (client) field should always be chisen, because
the client is automatically added to the WHERE clause when SELECT statements are sent to the
database.

Database Resources:

CPU load

Main memory

Table Buffering:

Table buffer: a memory area in the shared memory of the active application server.

Accesses to the table buffer are much faster than database accesses.

The database interface controls the filling and reading of the buffer at runtime.

Buffering types:

- Single record buffer (technically TABLP): only single records are from the database and loaded into
the table buffer. This type is only read if the SELECT SINGLE statement is used. The WHERE clause has to
contain restrictions for all key fields.

- Generic table buffer (technically TABL): to buffer a table generically, a generic area (consists of the
first n key fields of the table) needs to be defined first. If an SQL statement is executed with a specific
instantiation of the generic area for a generically buffered table, the corresponding records are loaded
into the table buffer. All subsequent accesses with the same instantiation (and, potentially with
additional fields that are not part of the generic area) can be served from the table buffer.

- Full buffering: the first time the table is accessed, the entire table is loaded into the table buffer
(generic table buffer). All subsequent accesses of the table are served from the table buffer.

Technically, single record buffer and generic table buffer use the same memory area on the application
serve
Buffer synchronization

A mechanism that the application servers in a system use to ensure that obsolete data is removed from
the table buffers when data in a buffered table is changed. The buffer is synchronized at fixed intervals
that you can configure in the system profile.

The system parameter for the synchronization interval is rdisp/bufreftime, which specifies the length of
the interval in seconds.

The frequency of the synchronization is every one to two minutes (controlled by a profile parameters).

Buffer synchronization table: DDLOG

Immediately after a change access to a buffered table, the table buffers of the non-local SAP instances
are no longer current. Inconsistent data can be read during this period, so only buffer tables where this
is acceptable.

Before you decide to buffer tables, consult your system administrator to make sure that sufficient space
is available in shared memory (single record buffer needs approximately 40 MB and generic table buffer
needs approximately 80 MB). Otherwise, the table buffers overwrite each other.

Access Types:

Work area mode (single record access)

Set mode (mass access)

ORDER BY

ORDER BY PRIMARY KEY

ORDER BY <field_1> DESCENDING <field_2> ASCENDING

Fields types that are not allowed in ORDER BY addition

Alternative to ORDER BY:

Using SORT statement

SORT internal_table BY column_name

Defining a sorted table

DATA internal_table TYPE SORTED TABLE OF database_table WITH NON-UNIQUE KEY key
SELECT DISTINCT statement: request condensed datasets from the databse.

Alternative to SELECT DISTINCT:

DELETE ADJACENT DUPLICATES FROM internal_table

Define an internal table with unique key

internal_table TYPE SORTED TABLE OF table_type WITH UNIQUE KEY [DEFAULT KEY | key_columns]

DISTINCT addition can be used for all aggregate functions. For example (most useful with COUNT, not
commonly combined with the MIN, MAX, SUM, and AVG):

COUNT (DISTINCT col): returns the number of unique, distinct values in the specified column.

Aggregate Functions:

If the field list in a SELECT statement contains only aggregate expressions, the result consists of a single
line (a structure may be specified as the target if an INTO clause is used).

If the field list of a SELECT statement contains fields and aggregate expressions, the result is always
multiline. The SELECT statement must contain the GROUP BY clause.

SELECT * is not allowed after SELECT when using GROUP BY clause.

Field types that are not allowed after GROUP BY statement.

HAVING:

- Restrict the result set. Entries are removed after aggregate formation (WHERE: lines are ignored
durign aggregate formation).

- Can contain aggregate functions.

- Can only contain fields that are specified after GROUP BY.

- A catchable runtime error occurs if there are fields not listed after GROUP BY.

- Aggregate functions used after HAVING do not have to be used after SELECT.

OPEN CURSOR Statement: defines and executes the access, but does not pass any data on the
application program.

Wildcards for LIKE:

- => placeholder for a single character

% => placeholder for substring of any length

ESCAPE addition

Table Field Comparison:

Both fields must have the same (technical type), otherwise the result is dependent on the database.

To avoid the confusion of the second table field with a data object, the name of the database table must
be specified with the field name connected with the “~” character. Alternatively, use an alias for the
table name, which you can define with the AS addition after the table name in the FROM clause.

Single Line Target Area

A structure (structured data object).

A list of elementary data objects.

Elementary structure components.

Multiline Target Area:

INTO TABLE

INTO CORRESPONDING FIELDS OF TABLE

APPENDING TABLE

APPENDING CORRESPONDING FIELDS OF TABLE

If you use INTO, the contents of the internal table are replaced completely with the selected data. If you
use APPEND, the data is added to any existing lines in the table.

Packaged Processing (Explicit Package Size):

Sequential processing in a SELECT loop has low memory requirements because only one record is
transported to the working memory at any one time.

PACKAGE SIZE addition to SELECT...ENDSELECT: the number of records that are placed in the internal
table at the same time and processed in the current loop pass is defined. The value determines number
of lines that the database interface provides to the application program in each loop pass.

SELECT * FROM table INTO TABLE internal_table PACKAGE SIZE package_size.

...

ENDSELECT.
Operators and Functions in String Expressions:

Operators: &&

String functions:

- LENGTH

- LPAD

- LTRIM

- RTRIM

- RIGHT

- REPLACE

- SUBSTRING

- CONCAT

Operators and Functions in Arithmetic Expression:

Operators: +, -, *, /

Arithmetic Funtions:

- ABS

- CEIL

- FLOOR

- DIV

- MOD

- ROUND

CAST Expression

Converts the value of argument arg into the ABAP Dictionary type specified after addition AS.

CAST (col AS type)

CX_SY_OPEN_SQL_DB occurs when divisioning by zero.

Using Literals and Constants:

Implement faster existence check.

SELECT SINGLE 1

FROM table

WHERE col = value.

CASE Expression

Embed conditional assignments in SQL statement.

Operands can be any SQL expression (columns, literals, host variables, and host expressions).

CASE operand

WHEN operand1 | sql_cond1 THEN result1

[WHEN operand2 | sql_cond2 THEN result2]

...

[ELSE resultn]

END

Nested SELECTs:

The most resource-intensive method possible for reading multiple linked database tables.

Place a high load on the database server and produce large amounts of network traffic

Subqueries

A subquery is a query within a SELECT, UPDATE, or DELETE statement. It is formulated in the WHERE or
HAVING clause to check whether the data in various database tables or views possess certain attributes.

If the subquery returns exactly one value, you can use the usual comparison operators apart from LIKE
and BETWEEN.

Types:

- Subquery that returnes single value

- Subquery that returns single-column, multiline result

- Subquery that returns any result

IN comparison operator: used to compare all the returnedc calues.

Correlated subqueries: subqueries whose WHERE condition contains fields from the main query.

If subqueries are nested, each subquery can use all the fields from the higher-level subqueries in the
hierarchy.

JOIN vs. Subquery

(SELECT col FROM table)

Read-On Demand and Buffering:

Reading the matching data from another table.

Encapsulate the reading of table records in a read routine.

The table contents read from the table are buffered in a static internal table. Before each database
access, the system checks whether the corresponding table entry has already been read.

Creating a table type of a previously created structure type:

* Defining the structure type

TYPES: BEGIN of ty_s_type,

...

END OF ty_s_type.

* Defining the table type

TYPES: ty_t_type TYPE [STANDARD | SORTED | HASHED] TABLE OF ty_s_type [WITH UNIQUE KEY key].

SELECT … FOR ALL ENTRIES

Replaces a SELECT SINGLE statement inside a LOOP over the internal table, and normally shows better
performance than such a LOOP.

If you want to read large data volumes, use FOR ALL ENTRIES only in exceptional cases.

Should be used when you want to create a join between an internal table and a database table.

Checkpoints

Define places in a program where the program state is tested during execution.

Marked with special statements in the source code.

Can be made activatable by assigning them to a checkpoint group.

Types of Checkpoints:

- Breakpoints: are places in the program that instruct the ABAP runtime processor to interrupt
program execution at a specific place in the source text. The Debugger is not activated until one of these
positions are reached.

- Assetions: help to check whether the program flow is progressing the way that is intended.

- Logpoints: when the system encounters an active logpoint, this is recorded in the log of the assigned
checkpoint group.

BREAK-POINT statement:

- Defines an unconditional checkpoint.

- You can activate breakpoints and create them without assignement to a checkpoint group.

- To identify the breakpoints more easily if you number them (BREAK-POINT 1, BREAK-POINT 2, ...).

- BREAK <user name> statement: set user-specific breakpoints.

- The extented program check is helpful for checking static breakpoints in a program. It displays an
error message if the program contains static breakpoints.

ASSERT statement:

ASSERT <logical_expression>

- Defines a conditional checkpoint.

- It is always linked with a logical condition.

- When an active assertion is reached, the system checks the logical condition. If the condition is not
true, the assertion is violated and the system terminates the program with a runtime error or dump.

- If assigned to a checkpoint group, you can select a different response for violated assertions.

LOG-POINT statement:

- Defines an unconditional checkpoint that serves merely to log when execution reaches a certain point
in the source code.

- A logpoint never interrupts or terminates a program.

- Logpoints must always be assigned to a specific checkpoint group, which means they can always be
activated.

- Always used with ID addition.

Use the statements for defining checkpoints exclusively for test purposes.

The ID addition to the statements BREK-POINT and ASSERT: assign a checkpoint group.
BREAK-POINT

ID <group>

ASSERT

ID <group>

FIELDS <f1> ... <f2>

CONDITION <logical_expression>

If the checkpoint group specifies that the assertion is inactive, the assertion condition will not cause a
runtime error in case of false.

LOG-POINT

ID <group>

FIELDS <f1>...<f2>

Types of Breakpoints:

Static breakpoints: part of the source code.

Dynamic breakpoints: user-specific and they are set in the ABAP Debugger.

States (Modes) of Assertions:

Inactive: assertion is ignored or not processed.

Break: the system starts the Debugger if the logical expression is false.

Log: if the expression is false, a log entry is written. The content of any data objects (except for
reference variables) can be stored in the log. Use the supplement FIELDS.

Abort: if the expression is false, a runtime error is raised. The system displays the content of the first
eight data objects that are listed behind FIELDS in the generated short dump.

Using the ABAP Trace (E-book: 341 - 346)

Using the SQL Trace (E-book: 347 - 351)

Using the SQL Monitor

SAP BusinessObjects Lumira