ABAP

ABAP (Advanced Business Application Programming, originally

ABAP/4
Allgemeiner Berichts-Aufbereitungs-Prozessor, German for "general report
creation processor"[3]) is a high-level programming language created by Paradigm Object-oriented, structured,
the German software company SAP SE. It is extracted from the base imperative
computing languages Java, C, C++ and Python. It is currently positioned, Designed by SAP SE
alongside Java, as the language for programming the SAP NetWeaver First appeared 1983
Application Server, which is part of the SAP NetWeaver platform for
Stable release 7.54[1] / September 20,
building business applications.
2019[2]
Typing Static, strong, safe,
discipline nominative
Contents OS Cross-platform
Introduction Website scn.sap.com/community/abap
ABAP runtime environment (http://scn.sap.com/communi
SAP systems and landscapes ty/abap)
Software layers Major implementations
Transactions SAP R/2, SAP R/3, SAP S/4HANA
Types of ABAP programs Influenced by

Development environment Objective-C, COBOL, SQL

ABAP Workbench
ABAP Development Tools
ABAP Dictionary
ABAP syntax
Hello world
Chained statements
Comments
Spaces
ABAP statements
Data types and variables
Explicitly typed declaration
Inline declaration
ABAP Objects
CDS Views
Features
Internal tables in ABAP
History
See also
References
External links

Introduction
ABAP is one of the many application-specific fourth-generation languages (4GLs) first developed in the 1980s. It was
originally the report language for SAP R/2, a platform that enabled large corporations to build mainframe business
applications for materials management and financial and management accounting. ABAP establish integration between
independent software.

ABAP used to be an abbreviation of Allgemeiner Berichts-Aufbereitungs-Prozessor, German for "generic report

preparation processor", but was later renamed to the English Advanced Business Application Programming. ABAP was
one of the first languages to include the concept of Logical Databases (LDBs), which provides a high level of
abstraction from the basic database level(s),which supports every platform, language and units.

The ABAP language was originally used by developers to develop the SAP R/3 platform. It was also intended to be used
by SAP customers to enhance SAP applications – customers can develop custom reports and interfaces with ABAP
programming. The language was geared towards more technical customers with programming experience.

ABAP remains as the language for creating programs for the client-server R/3 system, which SAP first released in 1992.
As computer hardware evolved through the 1990s, more and more of SAP's applications and systems were written in
ABAP. By 2001, all but the most basic functions were written in ABAP. In 1999, SAP released an object-oriented
extension to ABAP called ABAP Objects, along with R/3 release 4.6.

SAP's current development platform NetWeaver supports both ABAP and Java.

ABAP has an abstraction between the business applications, the operating system and database. This ensures that
applications do not depend directly upon a specific server or database platform and can easily be ported from one
platform to another.

SAP Netweaver currently runs on UNIX (AIX, HP-UX, Solaris, Linux), Microsoft Windows, i5/OS on IBM System i
(formerly iSeries, AS/400), and z/OS on IBM System z (formerly zSeries, S/390). Supported databases are HANA, SAP
ASE (formerly Sybase), IBM DB2, Informix, MaxDB, Oracle, and Microsoft SQL Server (support for Informix was
discontinued in SAP Basis release 7.00).[4]

ABAP runtime environment

All ABAP programs reside inside the SAP database. They are not stored in separate external files like Java or C++
programs. In the database all ABAP code exists in two forms: source code, which can be viewed and edited with the
ABAP Workbench tools; and generated code, a binary representation somewhat comparable with Java bytecode. ABAP
programs execute under the control of the runtime system, which is part of the SAP kernel. The runtime system is
responsible for processing ABAP statements, controlling the flow logic of screens and responding to events (such as a
user clicking on a screen button); in this respect it can be seen as a Virtual Machine comparable with the Java VM. A
key component of the ABAP runtime system is the Database Interface, which turns database-independent ABAP
statements ("Open SQL") into statements understood by the underlying DBMS ("Native SQL"). The database interface
handles all the communication with the relational database on behalf of ABAP programs; It also contains extra features
such as buffering of tables and frequently accessed data in the local memory of the application server.

SAP systems and landscapes

All SAP data exists and all SAP software runs in the context of a SAP system. A system consists of a central relational
database and one or more application ("instances") accessing the data and programs in this database. A SAP system
contains at least one instance but may contain more, mostly for reasons of sizing and performance. In a system with
multiple instances, load balancing mechanisms ensure that the load is spread evenly over the available application
servers.

Installations of the Web Application Server (landscapes) typically consist of three systems: one for development; one
for testing and quality assurance; and one for production. The landscape may contain more systems (e.g., separate
systems for unit testing and pre-production testing) or it may contain fewer (e.g., only development and production,
without separate QA); nevertheless three is the most common configuration. ABAP programs are created and undergo
first testing in the development system. Afterwards they are distributed to the other systems in the landscape. These
actions take place under control of the Change and Transport System (CTS), which is responsible for concurrency
control (e.g., preventing two developers from changing the same code at the same time), version management, and
deployment of programs on the QA and production systems.

The Web Application Server consists of three layers: the database layer; the application layer; and the presentation
layer. These layers may run on the same or on different physical machines. The database layer contains the relational
database and the database software. The application layer knowledge contains the instance or instances of the system.
All application processes, including the business transactions and the ABAP development, run on the application layer.
The presentation layer handles the interaction with users of the system. Online access to ABAP application servers can
go via a proprietary graphical interface, which is called "SAP GUI", or via a Web browser.

Software layers
ABAP software is deployed in software components. Examples for these are:

SAP_BASIS is the required technical base layer which is required in every ABAP system.
SAP_ABA contains functionalities which is required for all kinds of business applications, like business partner and
address management.
SAP_UI provides the functionality to create SAP UI5 applications.
BBPCRM is an example for a business application, in this case the CRM application
SAP ABAP is an ERP programming language....

Transactions
A transaction in SAP terminology is the execution of a program. The normal way of executing ABAP code in the SAP
system is by entering a transaction code (for instance, VA01 is the transaction code for "Create Sales Order").
Transactions can be called via system-defined or user-specific, role-based menus. They can also be started by entering
the transaction code directly into a command field, which is present in every SAP screen. Transactions can also be
invoked programmatically by means of the ABAP statements CALL TRANSACTION and LEAVE TO TRANSACTION. The
general notion of a transaction is called a Logical Unit of Work (LUW) in SAP terminology; the short form of transaction
code is T-code.

Types of ABAP programs

As in other programming languages, an ABAP program is either an executable unit or a library, which provides
reusable code to other programs and is not independently executable.

ABAP distinguishes two types of executable programs:

Reports
Module pools
Reports follow a relatively simple programming model whereby a user optionally enters a set of parameters (e.g., a
selection over a subSET of data) and the program then uses the input parameters to produce a report in the form of an
interactive list. The term "report" can be somewhat misleading in that reports can also be designed to modify data; the
reason why these programs are called reports is the "list-oriented" nature of the output they produce.

Module pools define more complex patterns of user interaction using a collection of screens. The term “screen” refers
to the actual, physical image that the user sees. Each screen also has a "flow logic", which refers to the ABAP code
implicitly invoked by the screens, which is divided into a "PBO" (Process Before Output) and "PAI" (Process After Input)
section. In SAP documentation the term “dynpro” (dynamic program) refers to the combination of the screen and its
flow logic.

The non-executable program types are:

INCLUDE modules
Subroutine pools
Function groups
Object classes
Interfaces
Type pools
An INCLUDE module gets included at generation time into the calling unit; it is often used to subdivide large
programs.
Subroutine pools contain ABAP subroutines (blocks of code enclosed by FORM/ENDFORM statements and invoked
with PERFORM).
Function groups are libraries of self-contained function modules (enclosed by FUNCTION/ENDFUNCTION and
invoked with CALL FUNCTION).
Object classes and interfaces are similar to Java classes and interfaces; the first define a set of methods and
attributes, the second contain "empty" method definitions, for which any class implementing the interface must provide
explicit code.
Type pools define collections of data types and constants.

ABAP programs are composed of individual sentences (statements). The first word in a statement is called an ABAP
keyword. Each statement ends with a period. Words must always be separated by at least one space. Statements can be
indented as you wish. With keywords, additions and operands, the ABAP runtime system does not differentiate between
upper and lowercase.

Statements can extend beyond one line. You can have several statements in a single line (though this is not
recommended). Lines that begin with asterisk * in the first column are recognized as comment lines by the ABAP
runtime system and are ignored. Double quotations marks (") indicate that the remainder of a line is a comment.

Development environment
There are two possible ways to develop in ABAP. The availability depends on the release of the ABAP system.

ABAP Workbench
The ABAP Workbench is part of the ABAP system and is accessed via SAPgui. It contains different tools for editing
programs. The most important of these are (transaction codes are shown in parentheses):

ABAP Editor for writing and editing reports, module pools, includes and subroutine pools (SE38)
ABAP Dictionary for processing database table definitions and retrieving global types (SE11)
Menu Painter for designing the user interface (menu bar, standard toolbar, application toolbar, function key
assignment) (SE41)
Screen Painter for designing screens and flow logic (SE51)
Function Builder for function modules (SE37)
Class Builder for ABAP Objects classes and interfaces (SE24)
The Object Navigator (transaction SE80) provides a single integrated interface into these various tools.

ABAP Development Tools

The ABAP Development Tools (ADT), formally known as "ABAP in Eclipse", is a set of plugins for the Eclipse platform
to develop ABAP.[5]

In this scenario, the ABAP developer installs the required tools on his computer and works locally, whereas a
continuous synchronization with the backend is performed.

ABAP Dictionary
The ABAP Dictionary contains all metadata about the data in the SAP system. It is closely linked with the ABAP
Workbench in that any reference to data (e.g., a table, a view, or a data type) will be obtained from the dictionary.
Developers use the ABAP Dictionary transactions (directly or through the SE80 Object Navigator inside the ABAP
Workbench) to display and maintain this metadata.

When a dictionary object is changed, a program that references the changed object will automatically reference the
new version the next time the program runs. Because ABAP is interpreted, it is not necessary to recompile programs
that reference changed dictionary objects.

A brief description of the most important types of dictionary objects follows:

Tables are data containers that exist in the underlying relational database. In the majority of cases there is a 1-to-1
relationship between the definition of a table in the ABAP Dictionary and the definition of that same table in the
database (same name, same columns). These tables are known as "transparent". There are two types of non-
transparent tables: "pooled" tables exist as independent entities in the ABAP Dictionary but they are grouped
together in large physical tables ("pools") at the database level. Pooled tables are often small tables holding for
example configuration data. "Clustered" tables are physically grouped in "clusters" based on their primary keys; for
instance, assume that a clustered table H contains "header" data about sales invoices, whereas another clustered
table D holds the invoice line items. Each row of H would then be physically grouped with the related rows from D
inside a "cluster table" in the database. This type of clustering, which is designed to improve performance, also exists
as native functionality in some, though not all, relational database systems.
Indexes provide accelerated access to table data for often used selection conditions. Every SAP table has a "primary
index", which is created implicitly along with the table and is used to enforce primary key uniqueness. Additional
indexes (unique or non-unique) may be defined; these are called "secondary indexes".
Views have the same purpose as in the underlying database: they define subsets of columns (and/or rows) from one
or - using a join condition - several tables. Since views are virtual tables (they refer to data in other tables) they do
not take a substantial amount of space.
Structures are complex data types consisting of multiple fields (comparable to struct in C/C++).
Data elements provide the semantic content for a table or structure field. For example, dozens of tables and
structures might contain a field giving the price (of a finished product, raw material, resource, ...). All these fields
could have the same data element "PRICE".
Domains define the structural characteristics of a data element. For example, the data element PRICE could have an
assigned domain that defines the price as a numeric field with two decimals. Domains can also carry semantic
content in providing a list of possible values. For example, a domain "BOOLEAN" could define a field of type
"character" with length 1 and case-insensitive, but would also restrict the possible values to "T" (true) or "F" (false).
Search helps (successors to the now obsolete "matchcodes") provide advanced search strategies when a user wants
to see the possible values for a data field. The ABAP runtime provides implicit assistance (by listing all values for the
field, e.g. all existing customer numbers) but search helps can be used to refine this functionality, e.g. by providing
customer searches by geographical location, credit rating, etc.
Lock objects implement application-level locking when changing data.

ABAP syntax
This brief description of the ABAP syntax begins with the ubiquitous "Hello world" program.

Hello world

REPORT TEST.
WRITE 'Hello World'.

This example contains two statements: REPORT and WRITE. The program displays a list on the screen. In this case, the
list consists of the single line "Hello World". The REPORT statement indicates that this program is a report. This
program could be a module pool after replacing the REPORT statement with PROGRAM.

Chained statements
Consecutive statements with an identical first (leftmost) part can be combined into a "chained" statement using the
chain operator :. The common part of the statements is written to the left of the colon, the differing parts are written
to the right of the colon and separated by commas. The colon operator is attached directly to the preceding token,
without a space (the same applies to the commas in the token list on, as can be seen in the examples below).

Chaining is often used in WRITE statements. WRITE accepts just one argument, so if for instance you wanted to display
three fields from a structure called FLIGHTINFO, you would have to code:

WRITE FLIGHTINFO-CITYFROM.
WRITE FLIGHTINFO-CITYTO.
WRITE FLIGHTINFO-AIRPTO.

Chaining the statements results in a more readable and more intuitive form:

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

In a chain statement, the first part (before the colon) is not limited to the statement name alone. The entire common
part of the consecutive statements can be placed before the colon. Example:

REPLACE 'A' WITH 'B' INTO LASTNAME.

REPLACE 'A' WITH 'B' INTO FIRSTNAME.
REPLACE 'A' WITH 'B' INTO CITYNAME.

could be rewritten in chained form as:

REPLACE 'A' WITH 'B' INTO: LASTNAME, FIRSTNAME, CITYNAME.

Comments
ABAP has 2 ways of defining text as a comment:

An asterisk (*) in the leftmost column of a line makes the entire line a comment
A double quotation mark (") anywhere on a line makes the rest of that line a comment
Example:

***************************************
** Program: BOOKINGS **
** Author: Joe Byte, 07-Jul-2007 **
***************************************

REPORT BOOKINGS.

* Read flight bookings from the database

SELECT * FROM FLIGHTINFO
WHERE CLASS = 'Y' "Y = economy
OR CLASS = 'C'. "C = business
(...)

Spaces
Code in ABAP is whitespace-sensitive.

x = a+b(c).

assigns to variable x the substring of the variable a, starting from b with the length defined by the variable c.

x = a + b( c ).

assigns to variable x the sum of the variable a and the result of the call to method b with the parameter c.

ABAP statements
In contrast with languages like C/C++ or Java, which define a limited set of language-specific statements and provide
most functionality via libraries, ABAP contains an extensive amount of built-in statements. These statements
traditionally used sentence-like structures and avoided symbols, making ABAP programs relatively verbose. However,
in more recent versions of the ABAP language, a terser style is possible.[6]

An example of statement based syntax (whose syntax originates in COBOL) versus expression-based syntax (as in
C/Java):

ADD TAX TO PRICE.

* is equivalent to
 PRICE = PRICE + TAX .

Data types and variables

ABAP provides a set of built-in data types. In addition, every structure, table, view or data element defined in the ABAP
Dictionary can be used to type a variable. Also, object classes and interfaces can be used as types.

The built-in data types are:

Type Description

I Integer

P Packed decimal

F Floating point

N Character numeric

C Character

D Date

T Time

X Hexadecimal (raw byte)

STRING Variable-length string

XSTRING Variable-length raw byte array

Date variables or constants (type D) contain the number of days since January 1, 1 AD. Time variables or constants
(type T) contain the number of seconds since midnight. A special characteristic of both types is that they can be
accessed both as integers and as character strings (with internal format "YYYYMMDD" for dates and "hhmmss" for
times), which can be used for date and time handling. For example, the code snippet below calculates the last day of
the previous month (note: SY-DATUM is a system-defined variable containing the current date):

DATA LAST_EOM TYPE D. "last end-of-month date

* Start from today's date

LAST_EOM = SY-DATUM.
* Set characters 6 and 7 (0-relative) of the YYYYMMDD string to "01",
* giving the first day of the current month
LAST_EOM+6(2) = '01'.
* Subtract one day
LAST_EOM = LAST_EOM - 1.

WRITE: 'Last day of previous month was', LAST_EOM.

All ABAP variables have to be explicitly declared in order to be used. They can be declared either with individual
statements and explicit typing or, since ABAP 7.40, inline with inferred typing.

Explicitly typed declaration

Normally all declarations are placed at the top of the code module (program, subroutine, function) before the first
executable statement; this placement is a convention and not an enforced syntax rule. The declaration consists of the
name, type, length (where applicable), additional modifiers (e.g. the number of implied decimals for a packed decimal
field) and optionally an initial value:

* Primitive types:
DATA: COUNTER TYPE I,
VALIDITY TYPE I VALUE 60,
TAXRATE(3) TYPE P DECIMALS 1,
LASTNAME(20) TYPE C,
DESCRIPTION TYPE STRING.

* Dictionary types:
DATA: ORIGIN TYPE COUNTRY.

* Internal table:
DATA: T_FLIGHTS TYPE TABLE OF FLIGHTINFO,
T_LOOKUP TYPE HASHED TABLE OF FLT_LOOKUP.

* Objects:
DATA: BOOKING TYPE REF TO CL_FLT_BOOKING.

Notice the use of the colon to chain together consecutive DATA statements.

Inline declaration
Since ABAP 7.40, variables can be declared inline (https://help.sap.com/doc/abapdocu_751_index_htm/7.51/en-US/aben
data_inline.htm) with the following syntax:
 DATA(variable_name) = 'VALUE'.

For this type of declaration it must be possible to infer the type statically, e.g. by method signature or database table
structure.

This syntax is also possible in OpenSQL statements:

SELECT * FROM ekko into @DATA(lt_ekko) WHERE ebeln EQ @lv_ebeln.

ABAP Objects
The ABAP language supports object-oriented programming, through a feature known as "ABAP Objects".[7] This helps
to simplify applications and make them more controllable.

ABAP Objects is fully compatible with the existing language, so one can use existing statements and modularization
units in programs that use ABAP Objects, and can also use ABAP Objects in existing ABAP programs. Syntax checking
is stronger in ABAP Objects programs, and some syntactical forms (usually older ones) of certain statements are not
permitted.

Objects form a capsule which combines the character to the respective behavior. Objects should enable programmers
to map a real problem and its proposed software solution on a one-to-one basis. Typical objects in a business
environment are, for example, ‘Customer’, ‘Order’, or ‘Invoice’. From Release 3.1 onwards, the Business Object
Repository (BOR) of SAP Web Application Server ABAP has contained examples of such objects. The BOR object model
will be integrated into ABAP Objects in the next Release by migrating the BOR object types to the ABAP class library. A
comprehensive introduction to object orientation as a whole would go far beyond the limits of this introduction to ABAP
Objects. This documentation introduces a selection of terms that are used universally in object orientation and also
occur in ABAP Objects. In subsequent sections, it goes on to discuss in more detail how these terms are used in ABAP
Objects. The end of this section contains a list of further reading, with a selection of titles about object orientation.

Objects are instances of classes. They contain data and provide services. The data forms the attributes of the object.
The services are known as methods (also known as operations or functions). Typically, methods operate on private
data (the attributes, or state of the object), which is only visible to the methods of the object. Thus the attributes of
an object cannot be changed directly by the user, but only by the methods of the object. This guarantees the internal
consistency of the object.
Classes describe objects. From a technical point of view, objects are runtime instances of a class. In theory, any
number of objects based on a single class may be created. Each instance (object) of a class has a unique identity and
its own set of values for its attributes.
Object References are unique addresses that may be used to identify and point to objects in a program. Object
references allow access to the attributes and methods of an object.
In object-oriented programming, objects usually have the following properties:

Encapsulation - Objects restrict the visibility of their resources (attributes and methods) to other users. Every object
has an interface, which determines how other objects can interact with it. The implementation of the object is
encapsulated, that is, invisible outside the object itself.
Inheritance - An existing class may be used to derive a new class. Derived classes inherit the data and methods of the
superclass. However, they can overwrite existing methods, and also add new ones.
Polymorphism - Identical (identically-named) methods behave differently in different classes. In ABAP Objects,
polymorphism is implemented by redefining methods during inheritance and by using constructs called interfaces.

CDS Views
The ABAP Core Data Services (ABAP CDS) are the implementation of the general CDS concept for AS ABAP. ABAP CDS
makes it possible to define semantic data models on the central database of the application server. On AS ABAP, these
models can be defined independently of the database system. The entities of these models provide enhanced access
functions when compared with existing database tables and views defined in ABAP Dictionary, making it possible to
optimize Open SQL-based applications. This is particularly clear when an AS ABAP uses a SAP HANA database, since
its in-memory characteristics can be implemented in an optimum manner.

The data models are defined using the data definition language (DDL) and data control language (DCL) provided in the
ABAP CDS in the ABAP CDS syntax. The objects defined using these languages are integrated into ABAP Dictionary and
managed here too.

CDS source code can only be programmed in the Eclipse-based ABAP Development Tools (ADT). The Data Definition
Language (DDL) and the Data Control Language (DCL) use different editors.[8]

Features
SAP NW ABAP SQL Joins SQL Set Operations SELECT Clauses

WHERE
INNER JOIN
7.40 SP05 UNION GROUP BY
LEFT OUTER JOIN
UNION ALL HAVING
RIGHT OUTER JOIN
AS

7.40 SP08

7.50

7.51 CROSS JOIN

SAP NW ABAP Literals Arithmetic Operators Conditional Expressions

Boolean operators

+ NOT, AND, OR
7.40 SP05 In SELECT list, e.g. literal as FieldName
- Comparison operators
As RHS value
∗
BETWEEN, =, <>, <, >, <=, >=, LIKE
IS [NOT] NULL (Only in WHERE condition)

7.40 SP08 / (Float-based division)

7.50

7.51 Function as RHS value

SAP NW ABAP Aggregate functions Numeric functions String functions

AVG( [DISTINCT] )
MAX

7.40 SP05 MIN CEIL SUBSTRING

SUM( [DISTINCT] ) MOD LPAD
COUNT( [DISTINCT] )
COUNT( * )

ABS
DIV (Integer-based division)
7.40 SP08 CONCAT
DIVISION (Decimal-based division)
REPLACE
FLOOR
ROUND

CONCAT_WITH_SPACE
INSTR
LEFT
7.50 LENGTH
LTRIM
RIGHT
RPAD
RTRIM

7.51 UPPER
AVG( [AS] ) to specify return type FLTP_TO_DEC
LOWER
 SAP NW Byte string
Date and time functions Other functions
ABAP functions

7.40 SP05 CAST to built-in DDIC types, e.g. abap.fltp

COALESCE

7.40 SP08 CURRENCY_CONVERSION

UNIT_CONVERSION
DECIMAL_SHIFT

DATS_DAYS_BETWEEN
DATS_ADD_DAYS
DATS_ADD_MONTHS
DATS_IS_VALID CAST
7.50 BINTOHEX
TIMS_IS_VALID to data elements, e.g. CHAR80
HEXTOBIN
TSTMP_IS_VALID can be nested
TSTMP_CURRENT_UTCTIMESTAMP
TSTMP_SECONDS_BETWEEN
TSTMP_ADD_SECONDS

CAST
ABAP_SYSTEM_TIMEZONE
ABAP_USER_TIMEZONE PRESERVING TYPE

TSTMP_TO_DATS SSTRING to other types

7.51
TSTMP_TO_TIMS CLNT, LANG, TIMS, UNIT to data elements of type CHAR and
SSTRING
TSTMP_TO_DST
CHAR, SSTRING, NUMC to ACCP and vice versa
DATS_TIMS_TO_TSTMP
Aggregate function as operand

SAP
Conditional (CASE)
NW Extensibility (Unmanaged) Associations
expressions
ABAP

Path expressions in

SELECT list
"Simple" CASE (behaves like FROM clause
7.40 $EXTENSION.* (support for database table
SP05 switch statement) WHERE clause
extensions)
Nested CASE statements HAVING clause
Filter conditions in path expressions, e.g.
Products._Texts[ lagu = 'EN' ] as
english_name

7.40 "Searched" CASE (behaves

SP08 EXTEND VIEW
like if ... else if)

CASE expressions can be EXTEND VIEW with input parameters, path

7.50 used as operands in CAST expressions, conversions, date and time
functions functions

Association definitions in views with UNIONs

Default filters for associations (WITH
7.51 EXTEND VIEW with aggregate functions,
Function as RHS value DEFAULT FILTER)
GROUP BY clauses and UNIONs
Cardinality "to many" ( *: ) can be specified
in path filters

SAP NW ABAP Session variables Input parameters Other

7.40 SP05 KEY elements

7.40 SP08 input parameters on most DBs

$session.user (sy-uname)
7.50 $session.client (sy-mandt) Input parameters on AnyDB Table function (SAP HANA only)
$session.system_language (sy-langu)

7.51 $session.system_date (sy-datum) Metadata extensions

[9]
Internal tables in ABAP
Internal tables are an important feature of the ABAP language. An internal table is defined similarly to a vector of
structs in C++ or a vector of objects in Java. The main difference with these languages is that ABAP provides a
collection of statements to easily access and manipulate the contents of internal tables. Note that ABAP does not
support arrays; the only way to define a multi-element data object is to use an internal table.

Internal tables are a way to store variable data sets of a fixed structure in the working memory of ABAP, and provides
the functionality of dynamic arrays. The data is stored on a row-by-row basis, where each row has the same structure.

Internal tables are preferably used to store and format the content of database tables from within a program.
Furthermore, internal tables in connection with structures are an important means of defining complex data structures
in an ABAP program.

The following example defines an internal table with two fields with the format of database table VBRK.

* First define structured type

TYPES: BEGIN OF t_vbrk,
VBELN TYPE VBRK-VBELN,
ZUONR TYPE VBRK-ZUONR,
END OF t_vbrk.

* Now define internal table of our defined type t_vbrk

DATA : gt_vbrk TYPE STANDARD TABLE OF t_vbrk,
gt_vbrk_2 TYPE STANDARD TABLE OF t_vbrk. "easy to define more tables

* If needed, define structure (line of internal table)

* Definition with type or with reference to internal table:
DATA : gs_vbrk TYPE t_vbrk,
gs_vbrk2 LIKE LINE OF gt_vbrk2.

* You can also define table type if needed

TYPES tt_vbrk TYPE STANDARD TABLE OF t_vbrk.

History
The following list only gives a rough overview about some important milestones in the history of the language ABAP.
For more details, see ABAP - Release-Specific Changes (http://help.sap.com/abapdocu_740/en/abennews.htm).

Release
Version Major changes
date

4.6C May 2000 ABAP Objects

6.40 2004 Shared Objects (https://blogs.sap.com/2004/12/09/netweaver-for-th

e-holidays-a-lession-in-sharing-abap-shared-memory/)

7.0 2006 Switch framework/Enhancement concept

Expressions like
7.02
check lcl=>mi( 1 ) + abs( -2 ) >= 3.

"Code pushdown"—use advanced features from the underlying

database
Constructor expressions ( NEW, VALUE, REF, CONV, CAST, EXACT,
7.40 (http://scn.sap.com/community/abap/blog/2013/07/22 2012-11-
COND, SWITCH )
/abap-news-for-release-740) 29
Partially Implemented test classes' interfaces
Table Expressions
Internal table line existence/line index functions

MOVE-CORRESPONDING for internal tables

LET expression in constructor expressions
7.40 SP05 (https://blogs.sap.com/2014/02/06/abap-news-f December
or-release-740-sp05/) 2013 CORRESPONDING operator
CDS Views
ABAP Managed Database Procedures

FOR expressions
Constructor operator REDUCE
Start value for constructor expressions
7.40 SP08 (https://blogs.sap.com/2014/02/06/abap-news-f September
GROUP BY for internal tables
or-release-740-sp05/) 2014
Filter expressions and default values for table expressions
Open SQL inline declarations after INTO statement
 Optional interface methods

New built-in data type INT8

Relational expression IS INSTANCE OF
Open SQL host expressions
7.50 (https://blogs.sap.com/2015/11/27/abap-language-ne November Open SQL expressions ROUND, CONCAT, LPAD, LENGTH, REPLACE,
ws-for-release-750/) 2015 RIGHT, RTRIM and SUBSTRING
Open SQL path expressions
Open SQL SELECT UNION
Open SQL INSERT FROM subquery

Enumerations
Common table expressions in Open SQL
Open SQL/CDS CROSS JOIN
7.51 (https://blogs.sap.com/2016/11/04/abap-news-for-rele October
ase-7.51/) 2016 CDS client handling
Metadata extensions in CDS
Date and Time in Open SQL/CDS
Floating point on Open SQL/CDS

7.52 (https://blogs.sap.com/2017/09/20/abap-news-for-rele September

ase-7.52-virtual-sorting-of-internal-tables/) 2017 Virtual sorting of internal tables

New Built-In Data Types

New Built-In ABAP Type utclong
Calculation Assignments
Decimal Places in Time Stamps
Client Handling
Extensions of the INTO Clause
Definition of Associations
New Aggregate Function STRING_AGG
New Built-In Functions
Addition DISTINCT Optional in Aggregate Function COUNT
Window Expressions
SQL Conditions Revised
Temporal Hierarchies
New Hierarchy Navigators
Aggregate Expressions in SQL Expressions
CAST Matrix Revised
Strict Mode in the Syntax Check
Syntax Check for Literals and Host Constants
Annotation for Database Hints
Annotations for Releasing Elements
Specifying CDS Entities After USING
Quotation Marks for Logical Schemas
7.54 (https://help.sap.com/doc/abapdocu_latest_index_htm September Addition in place of the Statement late numbering
/latest/en-US/abennews-754.htm) 2019 Addition in class ... unique
External name of an action
Static Field Control
Arbitrary Name for Handler Methods
Behavior Pool No Exceptions
Entity Manipulation Language
TYPE STRUCTURE FOR
Response Information
Absolute Type Names
Business Service
Authorization Checks in Updates
Implicit Message Type in IF_T100_DYN_MSG
Using Test Classes
Addition COMBINATION MODE OR|AND of the Statement GRANT
SELECT ON
Addition REDEFINITION of the Statement GRANT SELECT ON
Predicate VOID
Addition IN SCENARIO of the Statement GRANT SELECT ON
Generic Aspect Condition of the Statement DEFINE ROLE
New Variant INHERITING CONDITIONS FROM SUPER
Different REPLACING Operators
Definition of a Generic Aspect
DCL Restrictions for ABAP CDS Hierarchies
DCL Restrictions for Transactional Projection View Entities
See also
ERP software
Secure Network Communications
SAP Logon Ticket
Single Sign-On

References
1. ABAP — Release-Specific Changes: Changes in Releases 7.5x (https://help.sap.com/doc/abapdocu_latest_index_htm/la
test/en-US/index.htm?file=abennews-75.htm)
2. ABAP Platform for SAP S/4HANA 1909 (https://blogs.sap.com/2019/10/17/abap-platform-for-sap-s4hana-1909)
3. "ABAP History". SAP-technical.com (http://www.sap-technical.com/content/abap/1ABAP%20History.htm)
4. See Product Availability Matrix (http://scn.sap.com/docs/DOC-8693)
5. http://scn.sap.com/docs/DOC-29297
6. Example of an ABAP program with many expressions (http://help.sap.com/abapdocu_740/en/abenmesh_for_abexa.ht
m)
7. "Classes". SAP NetWeaver 7.0. [1] (http://help.sap.com/saphelp_nw70/helpdata/en/c3/225b5c54f411d194a60000e835
3423/frameset.htm) accessed 10 August 2009.
8. https://help.sap.com/doc/abapdocu_740_index_htm/7.40/en-US/index.htm?file=ABENCDS.htm
9. https://blogs.sap.com/2015/02/02/core-data-services-cds-abap-feature-matrix/

External links
ABAP — Keyword Documentation (https://help.sap.com/doc/abapdocu_latest_index_htm/latest/en-US/index.htm)
SAP Help Portal (http://help.sap.com)
ABAP Development (http://scn.sap.com/community/abap) discussions, blogs, documents and videos on the SAP
Community Network (SCN) (http://scn.sap.com/welcome)

Retrieved from "https://en.wikipedia.org/w/index.php?title=ABAP&oldid=936922933"

This page was last edited on 21 January 2020, at 21:06 (UTC).

Text is available under the Creative Commons Attribution-ShareAlike License; additional terms may apply. By using this site, you agree to the Terms
of Use and Privacy Policy. Wikipedia® is a registered trademark of the Wikimedia Foundation, Inc., a non-profit organization.