ABAP Eclipse

5/7/2023
SAP - ABAP Development User Guide

Generated on: 2023-05-07 11:00:56 GMT+0000
| 2020
PUBLIC
Original content: https://help.sap.com/docs/ABAP_PLATFORM_NEW/c238d694b825421f940829321ffa326a?locale=en-

US&state=PRODUCTION&version=202009.000
Warning
This document has been generated from the SAP Help Portal and is an incomplete version of the official SAP product
documentation. The information included in custom documentation may not re ect the arrangement of topics in the SAP Help
Portal, and may be missing important aspects and/or correlations to other topics. For this reason, it is not for productive use.
For more information, please visit the https://help.sap.com/docs/disclaimer.
This is custom documentation. For more information, please visit the SAP Help Portal 1
5/7/2023
 List of Development Objects with an Eclipse-based Editor

ABAP Development Tools provides an Eclipse-based editor for the following development objects:
Use Case Development Available Available Available Available Available Available Available Appli
Object since SAP since SAP since SAP since SAP since SAP since since Serve
NetWeaver NetWeaver NetWeaver NetWeaver NetWeaver Application Application ABAP
7.3 EHP1 7.4 7.5 AS for AS for Server Server
ABAP 7.51 ABAP 7.52 ABAP 7.53 ABAP 7.54
innovation
package
Core ABAP class SP04 SP02

development
ABAP function SP04 SP02
group

group include

module
ABAP include SP04 SP02
ABAP interface SP04 SP02
ABAP program SP04 SP02
Message class - SP04
Simple - - SP00
transformation
(ST)
XSLT program - - SP00
Other ABAP ABAP - - - - SP00

repository packages
objects
Knowledge SP00
transfer
document
(KTD)
ABAP ABAP type - SP08

Dictionary group
Structure - - SP00
Database table - - - - SP00
Data element - - SP00
Domain - - - SP01
Lock objects - - - - - SP00
Table types - - - - - - SP00
Connectivity ABAP Push - - SP00

Channel
5/7/2023
innovation
package
Messaging - - - SP01
channel
SAP HANA Database - SP02

artifacts procedure
proxy
External - SP02
dictionary view
SAP HANA - SP02

transport
container
Core Data Access control - SP10

Services
(CDS) Data de nition - SP02
Metadata - - - SP00
extensions
Abstract CDS - - - - - SP00

entities
Dynamic cache - - - - - - SP00
BOPF Business SP04 SP02

Business object
Objects
Business Behavior - - - - - SP00

Objects de nition
Behavior - - - - - SP00
implementation
Service binding - - - - - - SP00
Service - - - - - - SP00
de nition
Enterprise Consumer- - SP02

services Factory
Consumer- - SP02
Mapping
Contract - SP02
Contract - SP02
implementation
Integration - SP02
scenario
de nition
5/7/2023
innovation
package
Operation - SP02
mapping
RFC consumer - SP02
Semantic - SP02
contract
Service - SP02
consumer
Service - SP02
provider
Web Dynpro Application SP07 SP02
Application SP07 SP02

con guration
Component SP07 SP02
Component SP07 SP02

con guration
Custom- SP07 SP02

Controller
Floorplan SP04 SP02

manager
application
Interface view SP07 SP02
View SP07 SP02
Window SP07 SP02
 Note
The remaining development objects are opened in the SAP GUI.
Related Information
ABAP Development Objects
Opening in the SAP GUI
ABAP Source Code Editor
ABAP Dictionary Editors
Keyboard Shortcuts for ABAP Development

The following shortcuts are highly frequently used for working with development objects in ABAP Development Tools.
5/7/2023
 Note
The availability of the shortcuts depends on the user interface area you are currently working.
Select Ctrl + Shift + L to open a list that displays the area-speci c keyboard shortcuts.
You can display a list of all available keyboard shortcuts from the menu bar ( Windows Preferences General Keys ).
The subsequent lists are designed for using the operating systems Microsoft Windows© or Linux©. If you are working with
Apple Mac©, you might need to choose the Command tab instead of Ctrl.
Edit Actions
Function Shortcut
Activate inactive development object Ctrl + F3
Activate all inactive development objects Ctrl + Shift + F3
Check consistency and syntax Ctrl + F2
Close Ctrl + W
Close all Ctrl + Shift + W
Code completion / Content Assist Ctrl + Space
Delete line Ctrl + D
Delete next word Ctrl + Delete
Delete previous word Ctrl + Backspace
Find Next Ctrl + K
Find Previous Ctrl + Shift + K
Format source code (a.k.a. Pretty Printer) Shift + F1
Format source block (a.k.a. Pretty Printer) Ctrl + Shift + F1
Keyword completion Tab
Mark word Double-click
Mark whole line Triple-click
New ABAP development object Ctrl + N
Open quick x / quick assist dialog Ctrl + 1
Rename Alt + Shift + R
Save Ctrl + S
Save all Ctrl + Shift + S
Selection to upper case Ctrl + Shift + X
Selection to lower case Ctrl + Shift + Y
5/7/2023
Displaying Actions
Function Shortcut
Open a development object in other ABAP project(s) Alt + Ctrl + P
Show bookmarks, breakpoints, and tasks of the focused editor row Alt + Ctrl + P
Show the properties of the currently focused object or le Shift + Alt + P
Show bookmarks, breakpoints, and tasks of the focused editor row Shift + Alt + P
Show the Variable view in the ABAP debugger and to set the focus into the view. Shift + Alt + Q/V
 Note
Switch back to the source by using F12 .
Set the View menu, for text editors the ruler context menu is shown, or add bookmarks, breakpoints, or tasks Ctrl + F10
Show bookmarks, breakpoints, and tasks of the focused editor row Alt + Ctrl + F10
Adopt the size of the current editor, view, and so on to the maximum screen size Ctrl + M
Navigation Actions
Function Shortcut
Backward navigation to the previous opened tab Alt + Left
Forward navigation to the next opened tab Alt + Right
Select the next open editor you want to navigate to Ctrl + F6
Switch between perspectives Ctrl + F8
Select the previous open editor you want to navigate to Ctrl + Shift + F6
Navigate to last edited location Ctrl + Q
Open development object Ctrl + Shift + A
Open Quick Outline Ctrl + O
Open Quick Type Hierarchy Ctrl + T
 Open SAP GUI Ctrl + 6
Switch to next view Ctrl + F7
Switch to next perspective Ctrl + F8
Navigate to ABAP source code F3 or Ctrl + Click
Move the keyboard focus into the top level editor or the active editor tab F12
Show context menu Shift + F10
Moving Actions
5/7/2023
Function Shortcut
Backward one word Ctrl + Left
Forward one word Ctrl + Right
Jump to line Ctrl + L
Move one line down Alt + Down
Move one line up Alt + Up
Commenting Actions
Function Shortcut
Add comments Ctrl + <
Remove comments Ctrl + >
Add block comment Ctrl + Shift + /
Toggle comments Ctrl + 7
Hide comments Ctrl + Alt + 7
Search and Help

Function Shortcut
Open Search dialog Ctrl + H
Show ABAP Keyword Documentation of an ABAP keyword F1
Show ABAP element info F2
Where-used list Ctrl + Shift + G
WindowsTM-based Shortcuts
Function Shortcut
Find / Replace text Ctrl + F
Copy selection Ctrl + C
Close Ctrl + F4
Close all Ctrl + Shift + F4
Cut selection Ctrl + X
Paste selection Ctrl + V
Redo typing Ctrl + Y
Select all Ctrl + A
5/7/2023
Function Shortcut
Undo typing Ctrl + Z
Syntax of ABAP Dictionary Objects

This documentation describes the syntax that is used for editing classic ABAP Dictionary objects within ABAP Development
Tools (ADT).
Structures
Database Tables
 Note
Detailed concept information about classic objects in ABAP Dictionary can be found in the ABAP Keyword Documentation.
Related Information
 Classic Objects in ABAP Dictionary (ABAP Keyword Documentation)
Structures
Syntax Form
structure_annotations
DEFINE STRUCTURE structure {
components
}
De nition
A structure is a data type that consists of components. Each component can be an elementary type (either through a data
element or the speci cation of the data type and length in the structure de nition), another structure, or a table type. A
structure can be nested to any depth.
Notes
In ABAP Development Tools (ADT), you can create and edit structures in the ABAP source code editor.
This feature is supported as of SAP NetWeaver 7.5 or higher.
Use
Example
The source code below de nes a structure named employee that
5/7/2023
has a single component for the name of the employee.
has the short text “Employee of a company” and cannot be enhanced. This restriction is de ned by its structure
annotation.
@EndUserText.label: 'Employee of a company'

@AbapCatalog.enhancementCategory: #NOT_EXTENSIBLE
DEFINE STRUCTURE employee {
name : employee_name;
}
Related Information
 Structures (ABAP Keyword Documentation)
Structure Annotations
Annotations enable you to add metadata to a structure.
In ABAP Development Tools (ADT), you can add the following annotations to structures:
Short Description
Enhancement Category
 Note
Both annotations are mandatory when you are creating or editing structures in ADT.
Syntax Form
@AbapCatalog.enhancementCategory : #NOT_EXTENSIBLE |
#NOT_CLASSIFIED |
#EXTENSIBLE_CHARACTER |
#EXTENSIBLE_CHARACTER_NUMERIC |
#EXTENSIBLE_ANY
De nition
SAP's structures and database tables can be enhanced by customers using customizing includes or append structures.
Use
You use enhancement categories to prede ne warnings to be displayed if your changes result in n problems.
Values
You can use the following values to de ne enhancement categories in the source code:
List of Supported Enhancement Categories
5/7/2023
Annotation Value Description
#NOT_CLASSIFIED The structure/database table has no enhancement category.
 Note
This value is only provided for structures that already exist. Therefore, it should not be
used when creating new structures or changing existing ones.
#NOT_EXTENSIBLE The structure/database table might be enhanced.
 Note
This is the default value for creating structures in ADT.
#EXTENSIBLE_CHARACTER All structure/database table components and their enhancements must be character-like and
at.
#EXTENSIBLE_CHARACTER_NUMERIC All structure/database table components and their enhancements must be at.
#EXTENSIBLE_ANY All structure/database table components and their enhancements can have any kind of data
type.
Related Information
 Enhancement Category of Structures (ABAP Keyword Documentation)
Short Description
Syntax Form
@EndUserText.label: 'short_description'
De nition
The short text is used as an explanatory text for the entire structure/database table.
Notes
These texts are always displayed in the original language. If you change any text, the text is saved in the original language as
well.
If the logon language differs from the original language of the structure, a warning is displayed in the editor.
Related Information
 Semantic Attributes of Structures (ABAP Keyword Documentation)
Output Style
Syntax Form
5/7/2023
@AbapCatalog.decfloat.outputStyle : #NORMAL |
#SIGN_RIGHT |
#SCALE_PRESERVING |
#SCIENTIFIC |
#SCIENTIFIC_WITH_LEADING_ZERO |
#SCALE_PRESERVING_SIENTIFIC |
#ENGINEERING
De nition
This value determines the output style of a decimal oating point number.
Values
You can use the following values to de ne the output style of a decimal oating point number in the source code:
List of Supported Output Styles
#NORMAL Mathematical or scienti c in accordance to the available space
 Note
This is the default value.
#SIGN_RIGHT Leading sign on the right
#SCALE_PRESERVING Preservative scaling
#SCIENTIFIC Scienti c
#SCIENTIFIC_WITH_LEADING_ZERO Scienti c with leading zero
#SCALE_PRESERVING_SIENTIFIC Scienti c preservative scaling
#ENGINEERING Engineering
Structure Components
A component is, for example, a subunit of a structure. The components of a structure can be elementary (any data type), a
structure itself, an internal table, or a reference type.
Components can be created from scratch or by including them from a structure that already exists.
Syntax Form
1. Creating Components from Scratch
[component_annotations]
[foreign_key_annotations]
[KEY] component : [REFERENCE TO] user_defined_type | predefined_type
[NOT NULL] [foreign_key_addition] [value_help_addition];
2. Including Components from Existing Structures
[group :] INCLUDE structure | database table | view [WITH SUFFIX suffix] [component_extensions];
5/7/2023
Creating Components from Scratch
Syntax Form
[KEY] component : [REFERENCE TO] user_defined_type | predefined_type
De nition
A component always consists of a name and its type information, which can be followed optionally by a foreign key or a value
help assignment.
Notes
You can use the optional keywords REFERENCE TO for de ning reference-like components directly in the structure. Data
references can be de ned by a reference to any data type in ABAP Dictionary or to the generic type DATA. Object references
can be de ned by a reference to classes or interfaces in the class library or to the generic type OBJECT.
You can use the optional keyword KEY in front of a component de nition to de ne it as a key eld of the structure. This is
relevant for structures that are bound into database tables. Also, components of structures used as lock parameters in a lock
object must be de ned as KEY elds.
You can use the optional NOT NULL keywords at the end of a component de nition to de ne that the eld needs to have initial
values and cannot be null in a database table. Therefore this is relevant for structures that are bound into database tables only.
Example
The employee structure de nes the following components:
name is typed with the employee_name data element
date_of_birth is typed to the prede ned dictionary type abap.dats in order to contain a date value
address is de ned as a reference to the if_address_object interface
DEFINE STRUCTURE employee {

date_of_birth : abap.dats;
address : REFERENCE TO if_address_object;
...
}
Including Components from Existing Structures
Syntax Form
[group :] INCLUDE structure | database table | view

[WITH SUFFIX suffix] [component_extensions];
De nition
5/7/2023
Components of a structure can be de ned by including the components of other structures in ABAP Dictionary, including
database tables or views.
The name of the include structure thus follows after the INCLUDE keyword.
Use
Optionally, you can add:
a group to address the whole include structure like a component inside of an ABAP program
a suffix to resolve name con icts with other components of the structure by using the WITH SUFFIX keywords, followed
by a suffix of up to three characters that is added to the included components
component extensions to add/overrule value help or foreign key assignments to/of components from the include
structure
Example
The employee structure includes all components of the following structures:
org_data
address as the group office_address with the suffix off
address as the group private_address with the suffix pri
...
INCLUDE org_data;
office_address : INCLUDE address WITH SUFFIX off;
private_address : INCLUDE address WITH SUFFIX pri;
...
 Note
The following special characters are allowed in the eld names $%/&#@!*()~?<>.{}_. If a eld name contains one of these
characters, it must be written in double quotes. The same applies to group names and include suffixes.
Related Information
 Included Structures (ABAP Keyword Documentation)
Component/Field Annotations
Component/ eld annotations enable you to add metadata to a component/ eld.
In ABAP Development Tools (ADT), you can add the following annotations to a component/ eld:
Short Description if the component/ eld is typed with a prede ned type
Reference to a Currency Field if the component/ eld is an amount
Reference to a Unit Field if the component/ eld is a quantity
Reference to a Geographic Data Type if the component/ eld is a geographical location
Short Description
5/7/2023
Syntax Form
De nition
The short text is used as an explanatory text for a component/ eld that is typed with a prede ned ABAP Dictionary type. For
components/ elds that are de ned with a user-de ned ABAP Dictionary type, the corresponding short text is taken.
Editor-Speci c Information
well.
Related Information
Semantic Attributes of Structures (ABAP Keyword Documentation)
Currency Field
Syntax Form
@Semantics.amount.currencyCode : 'structure.field_containing_currency_key'
De nition
If a component/ eld is based on the abap.curr prede ned type, it has to be linked with a currency code eld based on the
abap.cuky prede ned type.
Example
The salary structure de nes the unit component with the prede ned data type abap.curr. Therefore, the reference to the
curreny_key component needs to be set. This is set through the given annotation.
DEFINE STRUCTURE salary {

@Semantics.amount.currencyCode : 'salary.currency_key'
amount : abap.curr(10,2);
currency_key : abap.cuky;
}
Related Information
 Currency Fields (ABAP Keyword Documentation)
Unit Field
5/7/2023
Syntax Form
@Semantics.quantity.unitOfMeasure: 'structure.field_containing_unit_key'
De nition
If a component/ eld is based on the abap.quan prede ned data type, it has to be linked with a unit eld based on the
abap.unit prede ned type.
Example
The order structure de nes the item_quantity component with the abap.quan prede ned data type. Therefore, the
reference to the item_unit component needs to be set. This is set through the given annotation.
DEFINE STRUCTURE order {

@Semantics.quantity.unitOfMeasure: 'order.item_unit'
item_quantity : abap.quan(4);
item_unit : abap.unit(2);
...
}
Related Information
Quantity Fields (ABAP Keyword Documentation)
Geographic Data Type

Syntax Form
@AbapCatalog.geo.spatialRefSystem : 'id'
De nition
This value determines the underlying spatial reference system of a geographic element that is typed with the prede ned ABAP
data type abap.geom_ewkb as Extended Well Known Binary (EWKB).
Notes
If the annotation is not explicitly given when de ning an element of the abap.geom_ewkb data type, the annotation will be
added with the default value '0' when saving the containing ABAP Dictionary object automatically. If an element already exists in
a structure, the annotation is always shown with the given value.
The underlying spatial reference system can no more be changed after activation.
Values
You can use, for example, the following values for de ning the underlying geographic reference system in the source code:
List of Supported System Values
5/7/2023
0 Default spatial reference system for unde ned Spatial Reference

Identi ers (SRID)
4326 Standard spatial reference system for spherical surfaces of the

Earth
1000004326 Spatial reference system for the WGS84 planar standard for
spherical surfaces of the Earth
2147483646 For unbounded planar spatial reference system
 Note
Only relevant for SAP-internal use.
Related Information
Spatial Reference Systems (SRS) and Spatial Reference Identi ers (SRID)
Prede ned ABAP Types
Syntax Form
... abap.name[(n)|(n,m)]
De nition
Elementary components/ elds can be typed with a user-de ned data element or directly with a prede ned data type. In the
latter case, you have to add the leading pre x abap., followed by the name of the prede ned dictionary type in a
component/ eld de nition. If the chosen type requires additional information on length and decimal places, you will need to add
this information in brackets.
Notes
You will nd a list of the available prede ned ABAP Dictionary types and their technical attributes in the ABAP Keyword
Documentation that is linked below.
Example
Both components are assigned to the prede ned data types that begin with abap. as leading pre x. After the value, the length
and decimals places follow in brackets.
...
gender : abap.char(1);
cost_factor : abap.dec(2,1);
...
Related Information
 Prede ned Data Types in ABAP Dictionary (ABAP Keyword Documentation)
5/7/2023
User-De ned ABAP Types
Syntax Form
...
data element | structure | database table | view | table type | class | interface
...
De nition
Components can be typed with any user-de ned dictionary type or with classes or interfaces from the class library.
The following categories of user-de ned types are provided:
Data element
Structure
 Note
The optional keyword BOXED can be added after the structure name. This component is then de ned as a boxed
component within the surrounding structure.
Database table
View
Table type
ABAP class or interface: can only be used with the leading REFERENCE TO addition.
Example
The following components are typed:
employee_id as a data element
address as a boxed component with a surrounding struct structure
accounts as a table type
department is referenced to an ABAP class
...
employee_id : dtel_employee_id;
address : struct_address BOXED;
accounts : itab_accounts;
department : REFERENCE TO cl_department
...
Related Information
 Data Types (ABAP Keyword Documentation)
 Boxed Components (ABAP Keyword Documentation)
Value Help Assignments
5/7/2023
Syntax Form
...
WITH VALUE HELP value_help
WHERE value_help_parameter1 = structure.component1
[AND value_help_parameter2 = structure.component2 ...];
...
De nition
You can add a value help to an elementary component/ eld. For this, you add the WITH VALUE HELP keywords, followed by
the name of the value help and the assignments, to the value help parameters as a WHERE condition.
Notes
In the WHERE condition, you must provide all parameters of the value help.
Single assignments are connected through the AND keyword.
You can only use value helps of the ABAP Dictionary. Value helps that are implemented with check tables or similar technologies
are maintained through a foreign key relationship.
Example
The employee_number component is typed with the s_employee_id data element. For this component, the
z_department value help is de ned. The id and depnumber value help parameters are supplied with components of the
surrounding structure. The language value help parameter receives a constant value.
...
employee_number : s_employee_id WITH VALUE HELP z_department
WHERE id = structure.id
AND depnumber = structure.dep_number
AND language = 'EN';
...
Related Information
Foreign Key Annotations

A foreign key represents one or more columns of a database table (foreign check table) that contains primary keys of another
database table (check table). Both tables have a foreign key dependency.
If the component/ eld has a foreign key relationship, the following foreign key annotations can be added:
Foreign Key Short Description
Foreign Key Field Type
Input Value Check on Dynpro
5/7/2023
Message Class and Message Number
 Note
You will nd examples of all foreign key annotations in the Foreign Keys chapter.
Related Information
 Foreign Key (ABAP Keyword Documentation)
 Check Table (ABAP Keyword Documentation)
Syntax Form
@AbapCatalog.foreignKey.keyType : #KEY |
#NON_KEY |
#TEXT_KEY
De nition
The foreign key eld type of a foreign key describes the meaning of the foreign key elds in the foreign key table. In structures,
this information is used for documentation purposes only.
Notes
You can assign the following values of foreign key types to a component:
List of Available Foreign Key Field Values
Values in ADT Meaning Description
#NON_KEY No key elds / key candidates The foreign key elds are not primary key elds of the
foreign key table and do not uniquely identify a record
of the foreign key table.
#KEY Key elds / key candidates The foreign key elds are either primary key elds of
the foreign key table or they uniquely identify a record
of the foreign key table as a key candidate.
#TEXT_KEY Key elds of a text table If this type of foreign key eld is de ned, the foreign
key table is handled as a text table to the check table.
The primary key of the foreign key table must match
the check table, plus a language key eld with the LANG
type. There can be only one text table for each check
table. Otherwise, a warning occurs at activation.
 The texts in a text table are used, amongst others, to

explain input helps on dynpros and Web Dynpros.
Related Information
 Foreign Key
5/7/2023
Syntax Form
@AbapCatalog.foreignKey.screenCheck : true | false
De nition
The input value check on dynpros and Web Dynpros tests whether the check table contains a record with the key given by the
values in the foreign key elds.
Notes
You can de ne the values true (for activation) and false (for deactivation).
Syntax Form
@AbapCatalog.foreignKey.messageClass : 'message_class_name'
@AbapCatalog.foreignKey.messageNumber : 'message_number'
De nition
If an input value check on a dynpro or Web Dynpro fails, a standard message is displayed. This standard message can be
replaced with any message in the de nition of the foreign key. To de ne this, you can set a message class and message number
through its annotation.
Notes
You should only add a message class if the screenCheck annotation is set on true.
Related Information
 Messages (ABAP Keyword Documentation)
 Dynpro (ABAP Keyword Documentation)
Foreign Keys
Syntax Form
foreign_key_annotations
...
WITH FOREIGN KEY [[1,m]] check_table
WHERE check_field1 = structure.component1
[AND check_field2 = structure.component2 ...];
...
5/7/2023
De nition
You can add a foreign key relationship to an elementary component. To do this, you add the WITH FOREIGN KEY keywords,
followed by the name of the check table and the assignments, to its check elds as a WHERE condition. Single assignments are
connected with the AND keyword.
Notes
If you de ne a foreign key for a component or on a component extension, you should add foreign key annotations.
You can de ne an optional [n:m] cardinality for each foreign key. In structures, cardinalities serve for documentation purposes
only. In the source code editor,
n relates to records typed with the surrounding structure
m relates to entries in the check table
Possible Values for n
[1]: Precisely one record must exist for each row in the check table.
[0..1]: There can be no more than one record for each row in the check table.
[1..*]: There must be at least one record for each row in the check table.
[0..*]: There can be any number of records for each row in the check table.
Possible Values for m
[1]: Precisely one row in the check table must exist for each record.
[0..1]: No assigned rows must exist in the check table for a record.
Example
The elementary component department_id has a foreign key relationship with the sdepartment check table. In this
relationship, the mandt component for entries in the check table must match the sy-mandt eld and the id component of the
check table must match the department_id eld of any record based on this structure.
The cardinality de nes that for each record an entry should exist in the check table, but not vice versa.
If the foreign key check fails, the message with the number 001 of the employee_messages message class is displayed.
...
@AbapCatalog.foreignKey.label : 'Departments'
@AbapCatalog.foreignKey.keyType : #KEY
@AbapCatalog.foreignKey.screenCheck : true
@AbapCatalog.foreignKey.messageClass : 'employee_messages’
@AbapCatalog.foreignKey.messageNumber : '001'
department_id : dtel_department WITH FOREIGN KEY [0..*,1] sdepartment
WHERE mandt = syst.mandt
AND id = employee.department_id;
...
Related Information
5/7/2023
Component Extensions
Syntax Form
EXTEND field : foreign_key_addition | value_help_addition;
De nition
Component extensions can be used:
to add/overrule value help or foreign key assignments to/of components from an include structure
in append structures to add value help or foreign key assignments to components of the original structure
A component extension is introduced with the EXTEND keyword, followed by the name of the component, and a foreign key or
value help addition, or both.
Use
A component extension is used to add, overrule, or remove one or more components from another or the same structure.
Notes
If a structure is included, you can remove existing value helps or foreign keys using the REMOVE VALUE HELP or REMOVE
FOREIGN KEY keywords.
Example
The zip_code and street components of the address include structure are extended:
For the zip_code component, a foreign key relationship is added.
For the street component, the value help originally de ned in the included structure is removed for usage in the
employee structure.
...
office_address : INCLUDE address
EXTEND zip_code: WITH FOREIGN KEY subsideries
WHERE plz = employee.zip_code
EXTEND street:
REMOVE VALUE HELP;
...
 Note
To nd more information about how to use component extensions in an append structure, see an example in the chapter
Append Structures.
Related Information
5/7/2023
Append Structures
Syntax Form
<structure_annotations>
EXTEND TYPE struct WITH append_struct {
[components]
[component_extensions]
}
De nition
Append structures are used to add components or component extensions to an existing structure without modifying the latter.
They are independent development objects that are edited separately.
An append structure is introduced with the EXTEND TYPE keywords, followed by the name of the original structure, followed by
the WITH keyword and the name of the append structure.
For append structures you use the same annotations as for regular structures.
Notes
You can only add a
value help if no value help exists for the original component
foreign key if no foreign key exists for the original component
Example
The employee_with_address append structure adds the street and city components.
In addition, the existing component department is extended by an assignment to the departments value help.
@EndUserText.label: 'Employee with additional fields'

@AbapCatalog.enhancementCategory: #EXTENSIBLE_CHARACTER
EXTEND TYPE employee WITH employee_with_address {
street : abap.char(40);
city : abap.char(30);
EXTEND department : WITH VALUE HELP departments
WHERE department_id = employee_with_address.department;
...
}
Related Information
 Append Structures (ABAP Keyword Documentation)
Creating Append Structures
Database Tables
Syntax Form
5/7/2023
This statement de nes a database table in ABAP Dictionary.
database_table_annotations
DEFINE TABLE database_table {
components
}
De nition
A database table is the set of data from a relational database. Each database table has technical and semantic properties that
are de ned in ABAP Dictionary.
Use
A database table can be used to create, edit, or display database tables in a source-based editor.
All database tables de ned in ABAP Dictionary can be referenced in ABAP programs as a structured data type.
You can access database tables de ned in ABAP Dictionary directly in ABAP programs using ABAP SQL.
Notes
 This feature is supported as of SAP NetWeaver AS for ABAP 7.52 SP00.
Database tables de ned in ABAP Dictionary are instantiated as database objects in ABAP database schema of the underlying
database of the current AS ABAP.
In this reference documentation, you will nd the ADT-speci c content for source-based database tables. To get more concept
information about database tables, see the ABAP Keyword Documentation below.
Example
The source code below de nes a database table named employees.
It consists of ...
the following annotations from de nition properties of the entire table:
@EndUserText.label determines the "All employees of a company" description
@AbapCatalog.enhancementCategory determines the NOT_EXTENSIBLE enhancement category and

cannot be enhanced
@AbapCatalog.tableCategory determines the TRANSPARENT table category
@AbapCatalog.deliveryClass determines the A application type for application table and stores master
data and transaction data
@AbapCatalog.dataMaintenance determines the LIMITED maintenance category for limited write access
several table elds that are de ned as follows:
key <employee_id> determines the key eld of the database table using the abap.char prede ned ABAP
type that allows up to 20 characters
5/7/2023
name determines the name of the employee using the abap.char prede ned ABAP type that allows up to 40
characters. Here, the text label "Employee Name" is added using the @EndUserText.label annotation. It
determines a semantic property of the subsequent table eld.
include <zabc_struc_empl> structure includes components of the zabc_struc_empl structure
<wage> determines the currency of the employee wages that is speci ed in the z_wage data element
The @Semantics.amount.currencyCode annotation refers to the currency eld of the

demo_cds_currcode classical view. The latter de nes the currency of the table eld itself.
@EndUserText.label : 'All employees of a company'

@AbapCatalog.enhancementCategory : #NOT_EXTENSIBLE
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #A
@AbapCatalog.dataMaintenance : #LIMITED
define table employees {
key employee_id : abap.char(20) not null;
@EndUserText.label : 'Employee Name'
name : abap.char(40);
include zabc_struc_empl;
@Semantics.amount.currencyCode : 'demo_cds_currco.currency'
wage : z_wage not null;
}
Related Information
 Database Table (ABAP Keyword Documentation)
 Database Tables (ABAP Keyword Documentation)
Database Table Annotations

Annotations enable you to add metadata to a database.
In ABAP Development Tools (ADT), you can use the following annotations for source-based database tables:
Technical attributes:
Table Category*
Enhancement Category*
Activation Type
Semantic attributes:
Short Description*
Data Maintenance*
Delivery Class*
Replacement Object
 Note
*These annotations are mandatory when creating or editing database tables in ADT.
When the source code of a database table is activated, annotations and comments that cannot be mapped to the database
are removed.
5/7/2023
Technical Attributes
Technical attributes describe information about the technical speci cation and implementation of a database table. The
technical attributes of a database table are the attributes of their structure and the database table-speci c properties.
The technical settings (data class, size category, buffering, and storage type) constitute a standalone object and can be
activated and transported separately from the table.
 Note
To edit these technical settings or to create/edit indexes, open the integrated SAP GUI.
Table Category
Syntax Form
@AbapCatalog.tableCategory: #TRANSPARENT |
#GLOBAL_TEMPORARY
De nition
The table category speci es the storage method and primary access method to the underlying database.
 Note
ABAP Dictionary supports transforming database tables from one category to another.
Values
You can use the following values for de ning the table category in the source code:
List of Supported Table Categories
Annotation Value Description Note
#TRANSPARENT The database object of a transparent table has the identically named
 Note
characteristic with the same columns as the de nition in ABAP
Dictionary. This is the default value for
creating database tables in
ADT.
#GLOBAL_TEMPORARY A global temporary table is a special transparent table exclusively used

for repository of temporary data.
Related Information
 Table Category of Database Tables (ABAP Keyword Documentation)
 Global Temporary Tables (ABAP Keyword Documentation)
 Storage Type of Database Tables (ABAP Keyword Documentation)
5/7/2023
Syntax Form
@AbapCatalog.enhancementCategory : #NOT_EXTENSIBLE |
#NOT_CLASSIFIED |
#EXTENSIBLE_CHARACTER |
#EXTENSIBLE_CHARACTER_NUMERIC |
#EXTENSIBLE_ANY
De nition
SAP's structures and database tables can be enhanced by customers using customizing includes or append structures.
Use
You use enhancement categories to prede ne warnings to be displayed if your changes result in n problems.
Values
You can use the following values to de ne enhancement categories in the source code:
List of Supported Enhancement Categories
#NOT_CLASSIFIED The structure/database table has no enhancement category.
 Note
This value is only provided for structures that already exist. Therefore, it should not be
used when creating new structures or changing existing ones.
#NOT_EXTENSIBLE The structure/database table might be enhanced.
 Note
This is the default value for creating structures in ADT.
#EXTENSIBLE_CHARACTER All structure/database table components and their enhancements must be character-like and
at.
#EXTENSIBLE_CHARACTER_NUMERIC All structure/database table components and their enhancements must be at.
#EXTENSIBLE_ANY All structure/database table components and their enhancements can have any kind of data
type.
Related Information
 Enhancement Category of Structures (ABAP Keyword Documentation)
Activation Type
Syntax Form
@AbapCatalog.activationType : #NOT_CLASSIFIED |
#NAMETAB_GENERATION_OFFLINE |
#ADAPT_C_STRUCTURES |
#INITIAL_TABLE_REQUIRED
5/7/2023
De nition
The activation type of a database table describes if a database table can be activated using the relevant tools in ABAP
Dictionary or if activation needs to be triggered by the ABAP runtime.
Use
You, as a customer, can only de ne the default value.
Values
You can use the following values for de ning activation types in the source code:
List of Supported Activation Types
Annotation Value Description Note
#NOT_CLASSIFIED The database table can be activated using with an ABAP Dictionary This is the default
tool interactively. value for creating
database tables in
 Recommendation ADT.
SAP recommends that database tables for application development

should use this default value.
#NAMETAB_GENERATION_OFFLINE The runtime object of the database table must be created using an This value is used for
ABAP kernel program before activating in ABAP Dictionary. This makes database tables that
it impossible to modify and activate important system tables directly. are needed from the
ABAP runtime.
#ADAPT_C_STRUCTURES The database table is used from the ABAP kernel. Activation and Therefore, it is only
therefore creation of its runtime objects is despite possible in ABAP relevant for SAP-
Dictionary. internal development.
Check the programs in use from the kernel for possible adoptions.
#INITIAL_TABLE_REQUIRED The database table is required before other objects are modi ed as
part of a transport.
Related Information
 Activation Type of Database Tables (ABAP Keyword Documentation)
 Activating ABAP Dictionary Types (ABAP Keyword Documentation)
Semantic Attributes
Semantic attributes provide additional information and specify the behavior of a database table. The semantic attributes of a
database table are the properties of their structure and the database table-speci c properties.
Short Description
Syntax Form
5/7/2023
De nition
The short text is used as an explanatory text for the entire structure/database table.
Notes
well.
Related Information
Data Maintenance
Syntax Form
@AbapCatalog.dataMaintenance : #LIMITED |
#ALLOWED |
#NOT_ALLOWED
De nition
Data maintenance describes the possibilities if displaying and/or editing the content of a database table is allowed or not.
Use
You can use the
Data Browser (transaction SE16) and Table View Maintenance (transactions SM30 and SM31) to maintain database
tables.
Data Preview to access and display the content stored in a database table.
 Note
In the current client version of ABAP Development Tools, the technical settings and maintenance features can only be edited
using the embedded SAP GUI.
Values
You can use the following values for de ning the data maintenance possibilities in the source code:
List of Supported Data Maintenance Values
5/7/2023
#LIMITED  Database tables can be displayed but not edited using Data Browser (transaction SE16).
Maintenance dialogs can be created using transaction SE54.
Tables cannot be displayed and edited with transactions SM30 and SM31. Maintenance dialogs can, however,
be used in "View Cluster Maintenance" (transaction SM34).
 Note
This is the default value for creating database tables in ADT.
#ALLOWED  Database tables can be displayed and edited using Data Browser (transaction SE16).
Maintenance dialogs can be created using transaction SE54.
Tables cannot be displayed and edited with transactions SM30 and SM31. Maintenance dialogs can, however,
be used in "View Cluster Maintenance" (transaction SM34).
#NOT_ALLOWED  Database tables cannot be displayed or edited using Data Browser (transaction SE16).
No maintenance dialogs can be created using transaction SE54. This means that transactions SM30 and
SM31 cannot be used.
Related Information
 Displaying and Editing Database Tables (ABAP Keyword Documentation)
Delivery Class
Syntax Form
@AbapCatalog.deliveryClass : #A |
#C |
#L |
#G |
#E |
#S |
#W
De nition
The delivery class of a database table controls
the transport of table data from installations, upgrades, or client copies, and
the transports between customer systems.
It is also considered in extended table maintenance.
Values
You can use the following values for the de ning delivery class in the source code:
List of Supported Delivery Classes
5/7/2023
#A Application table for master data and transaction data. The data is written by application programs.
 Note
This is the default value for creating database tables in ADT.
#C Customer table for data entered by the customer only
#L Table used as a repository of temporary data
 Note
SAP delivers tables in the delivery class L as empty tables.
#G Customer table where SAP can add data but not modify or delete
 Note
A customer table of this delivery class must be assigned a customer namespace in the database table
TRESC using program RDDKOR54.
#E System table in which customers can make entries
 Note
A system table in the delivery class E must be assigned a customer namespace in the database table
TRESC. To do this, you use program RDDKOR54.
#S System table delivered by SAP with prede ned data as part of the system, such as ABAPDOCU_TREE
 Note
Data of the tables of this delivery class is transported and handled like repository objects. This means
that they have an original system. Any changes in other systems are handled as modi cations or repairs.
#W System table for administration data of a system, such as TFDIR as a directory of all function modules
 Note
A system table in the delivery class W is usually delivered with entries from SAP. It can be affected by
customer modi cations. The content is transported using the transport objects assigned to the objects in
questions.
 Example
R3TR FUNC for function modules
Related Information
 Delivery Class for Database Tables (ABAP Keyword Documentation)
Replacement Object
Syntax Form
@AbapCatalog.replacementObject : 'cds_entity_name'
5/7/2023
De nition
A CDS view can be de ned as a replacement object for a transparent database table or a classic database view in ABAP
Dictionary. In this case, read access using ABAP SQL is carried out through the replacement object.
Use
You can assign a transparent database table and a classic database view in ABAP Dictionary to a CDS view. To do this, you
assign the name of the relevant CDS entity to the @AbapCatalog.replacementObject annotation as a replacement
object.
This enables you to retrieve data using a substitute object instead of a database table or a classic database view.
 Recommendation
SAP might deliver a replacement object for database tables for aggregated data. But SAP does not recommend you create
your own replacement objects.
 Note
You can only assign a replacement object if the structure type – de ned by the CDS view – ful lls speci c requirements.
You cannot de ne replacement objects for global temporary tables.
For further information, see the Related Information below.
Value
Enter the name of the replacement object to be considered in quotation marks after the annotation name and the colon.
Notes
The relevant name will not be considered for translation.
Related Information
 Replacement object (ABAP Keyword Documentation)
 Replacement Objects (ABAP Keyword Documentation)
Database Table Fields
De nition
A database table eld (short form eld) describes the data to be stored in the database.
Use
Database table elds can be created:
from scratch or
5/7/2023
by including them from a structure with a at data type that already exists.
Syntax Form
You have the following possibilities to add elds to database tables:
1. Creating Fields from Scratch
[KEY] component : user_defined_type | predefin
[NOT NULL] [foreign_key_addition] [value_help_
2. Including Fields from Existing Structures
[group :] [KEY] INCLUDE structure [component_extensions] | [NOT NULL];
Creating Fields from Scratch
Syntax Form
[KEY] field : user_defined_type | predefined_type
De nition
A eld always consists of a name and its type information.
In addition, a foreign key or a value help assignment can be added to a eld.
Use
You can use the optional keyword KEY in front of a component de nition to de ne it as a key eld of the structure. This is
relevant for structures that are bound to database tables. Also, components of structures used as lock parameters in a lock
object must be de ned as KEY elds.
You can use the optional NOT NULL SQL keywords at the end of a component de nition to de ne that the eld needs to have
initial values and cannot be null in a database table. This is relevant for structures that are bound into database tables only.
Example
The employees table de nes the following components:
pers_id is the key eld of the table and typed to the prede ned ABAP type abap.char(40)
name is typed with the employee_name data element
DEFINE TABLE employees {

key pers_id : abap.char(40);
5/7/2023
...
}
 Note
The following special characters are allowed in the group names $%/&#@!*()~?<>.{}_ where . and ! cannot be used in
the rst position. If a group name contains one of these characters, it must be written in double quotes. The same applies to
include suffixes.
Related Information
 Names of Structure Components (ABAP Keyword Documentation)
Including Fields from Existing Structures

An include structure (include) in a database table is a reference to an existing structure.
Syntax Form
[group :] INCLUDE structure

[WITH SUFFIX suffix] [component_extensions];
De nition
Fields of a database table can be de ned by including the components of other structures in ABAP Dictionary.
The name of an include structure (includes) comes after the INCLUDE keyword. The data type of an include structure must be
at.
Use
Optionally, you can add:
a group to address the whole include structure like a component inside of an ABAP program
a suffix to resolve name con icts with other components of the structure by using the WITH SUFFIX keywords, followed
by a suffix of up to three characters that is added to the included components
eld extensions to add/overrule value help or foreign key assignments to/of elds from an include structure
Example
The employee structure includes all components of the following structure:
org_data
address as the group office_address with the suffix off
address as the group private_address with the suffix pri
...
INCLUDE org_data;
office_address : INCLUDE address WITH SUFFIX off;
5/7/2023
private_address : INCLUDE address WITH SUFFIX pri;
...
 Note
The following special characters are allowed in the group names $%&#@!*()~?<>.{}_. If a group name contains one of
these characters, it must be written in double quotes. The same applies to include suffixes.
Related Information
 Included Structures (ABAP Keyword Documentation)
Component/Field Annotations
Component/ eld annotations enable you to add metadata to a component/ eld.
In ABAP Development Tools (ADT), you can add the following annotations to a component/ eld:
Short Description if the component/ eld is typed with a prede ned type
Reference to a Currency Field if the component/ eld is an amount
Reference to a Unit Field if the component/ eld is a quantity
Reference to a Geographic Data Type if the component/ eld is a geographical location
Short Description
Syntax Form
De nition
The short text is used as an explanatory text for a component/ eld that is typed with a prede ned ABAP Dictionary type. For
components/ elds that are de ned with a user-de ned ABAP Dictionary type, the corresponding short text is taken.
well.
Related Information
Semantic Attributes of Structures (ABAP Keyword Documentation)
Currency Field
5/7/2023
Syntax Form
@Semantics.amount.currencyCode : 'structure.field_containing_currency_key'
De nition
If a component/ eld is based on the abap.curr prede ned type, it has to be linked with a currency code eld based on the
abap.cuky prede ned type.
Example
The salary structure de nes the unit component with the prede ned data type abap.curr. Therefore, the reference to the
curreny_key component needs to be set. This is set through the given annotation.
DEFINE STRUCTURE salary {

@Semantics.amount.currencyCode : 'salary.currency_key'
amount : abap.curr(10,2);
currency_key : abap.cuky;
}
Related Information
 Currency Fields (ABAP Keyword Documentation)
Unit Field
Syntax Form
@Semantics.quantity.unitOfMeasure: 'structure.field_containing_unit_key'
De nition
If a component/ eld is based on the abap.quan prede ned data type, it has to be linked with a unit eld based on the
abap.unit prede ned type.
Example
The order structure de nes the item_quantity component with the abap.quan prede ned data type. Therefore, the
reference to the item_unit component needs to be set. This is set through the given annotation.
DEFINE STRUCTURE order {

@Semantics.quantity.unitOfMeasure: 'order.item_unit'
item_quantity : abap.quan(4);
item_unit : abap.unit(2);
...
}
Related Information
Quantity Fields (ABAP Keyword Documentation)
5/7/2023
Geographic Data Type
Syntax Form
@AbapCatalog.geo.spatialRefSystem : 'id'
De nition
This value determines the underlying spatial reference system of a geographic element that is typed with the prede ned ABAP
data type abap.geom_ewkb as Extended Well Known Binary (EWKB).
Notes
If the annotation is not explicitly given when de ning an element of the abap.geom_ewkb data type, the annotation will be
added with the default value '0' when saving the containing ABAP Dictionary object automatically. If an element already exists in
a structure, the annotation is always shown with the given value.
The underlying spatial reference system can no more be changed after activation.
Values
You can use, for example, the following values for de ning the underlying geographic reference system in the source code:
List of Supported System Values
0 Default spatial reference system for unde ned Spatial Reference

Identi ers (SRID)
4326 Standard spatial reference system for spherical surfaces of the

Earth
1000004326 Spatial reference system for the WGS84 planar standard for
spherical surfaces of the Earth
2147483646 For unbounded planar spatial reference system
 Note
Only relevant for SAP-internal use.
Related Information
Spatial Reference Systems (SRS) and Spatial Reference Identi ers (SRID)
Prede ned ABAP Types
Syntax Form
... abap.name[(n)|(n,m)]
5/7/2023
De nition
Elementary components/ elds can be typed with a user-de ned data element or directly with a prede ned data type. In the
latter case, you have to add the leading pre x abap., followed by the name of the prede ned dictionary type in a
component/ eld de nition. If the chosen type requires additional information on length and decimal places, you will need to add
this information in brackets.
Notes
You will nd a list of the available prede ned ABAP Dictionary types and their technical attributes in the ABAP Keyword
Documentation that is linked below.
Example
Both components are assigned to the prede ned data types that begin with abap. as leading pre x. After the value, the length
and decimals places follow in brackets.
...
gender : abap.char(1);
cost_factor : abap.dec(2,1);
...
Related Information
 Prede ned Data Types in ABAP Dictionary (ABAP Keyword Documentation)
User-De ned ABAP Types
Syntax Form
...
data element | predefined_abap_type
...
De nition
Fields can be typed with any user-de ned ABAP Dictionary type.
The following categories of user-de ned types are supported:
Data element
Prede ned ABAP types
Example
The following components/ elds are typed:
employee_id as a data element
date_birth as the prede ned ABAP type for dates
5/7/2023
...
employee_id : dtel_employee_id;
date_birth : abap.dats;
...
Value Help Assignments
Syntax Form
...
WITH VALUE HELP value_help
WHERE value_help_parameter1 = structure.component1
[AND value_help_parameter2 = structure.component2 ...];
...
De nition
You can add a value help to an elementary component/ eld. For this, you add the WITH VALUE HELP keywords, followed by
the name of the value help and the assignments, to the value help parameters as a WHERE condition.
Notes
In the WHERE condition, you must provide all parameters of the value help.
Single assignments are connected through the AND keyword.
You can only use value helps of the ABAP Dictionary. Value helps that are implemented with check tables or similar technologies
are maintained through a foreign key relationship.
Example
The employee_number component is typed with the s_employee_id data element. For this component, the
z_department value help is de ned. The id and depnumber value help parameters are supplied with components of the
surrounding structure. The language value help parameter receives a constant value.
...
employee_number : s_employee_id WITH VALUE HELP z_department
WHERE id = structure.id
AND depnumber = structure.dep_number
AND language = 'EN';
...
Related Information
Foreign Key Annotations
5/7/2023
A foreign key represents one or more columns of a database table (foreign check table) that contains primary keys of another
database table (check table). Both tables have a foreign key dependency.
If the component/ eld has a foreign key relationship, the following foreign key annotations can be added:
 Note
You will nd examples of all foreign key annotations in the Foreign Keys chapter.
Related Information
Syntax Form
@AbapCatalog.foreignKey.label: 'literal_string'
De nition
The short text is used as an explanatory text for a foreign key relationship.

Syntax Form
@AbapCatalog.foreignKey.keyType : #KEY |
#NON_KEY |
#TEXT_KEY
De nition
The foreign key eld type of a foreign key describes the meaning of the foreign key elds in the foreign key table. In structures,
this information is used for documentation purposes only.
Notes
You can assign the following values of foreign key types to a component:
List of Available Foreign Key Field Values
5/7/2023
Values in ADT Meaning Description
#NON_KEY No key elds / key candidates The foreign key elds are not primary key elds of the
foreign key table and do not uniquely identify a record
of the foreign key table.
#KEY Key elds / key candidates The foreign key elds are either primary key elds of
the foreign key table or they uniquely identify a record
of the foreign key table as a key candidate.
#TEXT_KEY Key elds of a text table If this type of foreign key eld is de ned, the foreign
key table is handled as a text table to the check table.
The primary key of the foreign key table must match
the check table, plus a language key eld with the LANG
type. There can be only one text table for each check
table. Otherwise, a warning occurs at activation.
 The texts in a text table are used, amongst others, to

explain input helps on dynpros and Web Dynpros.
Related Information
 Foreign Key

Syntax Form
@AbapCatalog.foreignKey.screenCheck : true | false
De nition
The input value check on dynpros and Web Dynpros tests whether the check table contains a record with the key given by the
values in the foreign key elds.
Notes
You can de ne the values true (for activation) and false (for deactivation).
Syntax Form
@AbapCatalog.foreignKey.messageClass : 'message_class_name'
@AbapCatalog.foreignKey.messageNumber : 'message_number'
De nition
If an input value check on a dynpro or Web Dynpro fails, a standard message is displayed. This standard message can be
replaced with any message in the de nition of the foreign key. To de ne this, you can set a message class and message number
through its annotation.
5/7/2023
Notes
You should only add a message class if the screenCheck annotation is set on true.
Related Information
 Messages (ABAP Keyword Documentation)
 Dynpro (ABAP Keyword Documentation)
Foreign Keys
Syntax Form
foreign_key_annotations
...
WITH FOREIGN KEY [[1,m]] check_table
WHERE check_field1 = structure.component1
[AND check_field2 = structure.component2 ...];
...
De nition
You can add a foreign key relationship to an elementary component. To do this, you add the WITH FOREIGN KEY keywords,
followed by the name of the check table and the assignments, to its check elds as a WHERE condition. Single assignments are
connected with the AND keyword.
Notes
If you de ne a foreign key for a component or on a component extension, you should add foreign key annotations.
You can de ne an optional [n:m] cardinality for each foreign key. In structures, cardinalities serve for documentation purposes
only. In the source code editor,
n relates to records typed with the surrounding structure
m relates to entries in the check table
Possible Values for n
[1]: Precisely one record must exist for each row in the check table.
[0..1]: There can be no more than one record for each row in the check table.
[1..*]: There must be at least one record for each row in the check table.
[0..*]: There can be any number of records for each row in the check table.
Possible Values for m
[1]: Precisely one row in the check table must exist for each record.
[0..1]: No assigned rows must exist in the check table for a record.
Example
5/7/2023
The elementary component department_id has a foreign key relationship with the sdepartment check table. In this
relationship, the mandt component for entries in the check table must match the sy-mandt eld and the id component of the
check table must match the department_id eld of any record based on this structure.
The cardinality de nes that for each record an entry should exist in the check table, but not vice versa.
If the foreign key check fails, the message with the number 001 of the employee_messages message class is displayed.
...
@AbapCatalog.foreignKey.label : 'Departments'
@AbapCatalog.foreignKey.keyType : #KEY
@AbapCatalog.foreignKey.screenCheck : true
@AbapCatalog.foreignKey.messageClass : 'employee_messages’
@AbapCatalog.foreignKey.messageNumber : '001'
department_id : dtel_department WITH FOREIGN KEY [0..*,1] sdepartment
WHERE mandt = syst.mandt
AND id = employee.department_id;
...
Related Information
Syntax Form
EXTEND field : foreign_key_addition | value_help_addition;
De nition
Component extensions can be used:
to add/overrule value help or foreign key assignments to/of components from an include structure
in append structures to add value help or foreign key assignments to components of the original structure
A component extension is introduced with the EXTEND keyword, followed by the name of the component, and a foreign key or
value help addition, or both.
Use
A component extension is used to add, overrule, or remove one or more components from another or the same structure.
Notes
If a structure is included, you can remove existing value helps or foreign keys using the REMOVE VALUE HELP or REMOVE
FOREIGN KEY keywords.
Example
5/7/2023
The zip_code and street components of the address include structure are extended:
For the zip_code component, a foreign key relationship is added.
For the street component, the value help originally de ned in the included structure is removed for usage in the
employee structure.
...
office_address : INCLUDE address
EXTEND zip_code: WITH FOREIGN KEY subsideries
WHERE plz = employee.zip_code
EXTEND street:
REMOVE VALUE HELP;
...
 Note
To nd more information about how to use component extensions in an append structure, see an example in the chapter
Append Structures.
Related Information
 Logpoint Syntax
A logpoint is a logging point in an ABAP program.
Contents
You can use the LOG-POINT statement to de ne a static logpoint whose activation is controlled using the addition ID.
Related Information
ABAP Data Objects and Their Notations in Logpoints
Built-in Functions in Logpoints
Authorization Object S_DYNLGPTS for Logpoints
Glossary
Using Dynamic Logpoints
LOG-POINT (ABAP Keyword Documentation)
 ABAP Data Objects and Their Notations in Logpoints

To specify the condition, key de nition, or resulting eld values of a dynamic logpoint, uses the same notations of ABAP data
objects (variables, literals) that you would use during debugging at the same source position.
As you already know from using the ABAP Debugger, for displaying variable content you can use the variable name you would
use in the ABAP source code at that debugging position or you can use special debugger notiations that are not valid in ABAP
source code, for example:
itab[1]
5/7/2023
{O:23!CL_BASE_CLASS}-private_attr
(SAPMSSY0)ORDERS
Literals in Logpoints
Literals are used in conditions and in key de nitions of dynamic logpoints.
 Note
Literal support is not provided for the eld values (results).
As you already know from ABAP syntax, the following types of literals are also valid in logpoints:
Character Literals
Character literals are identi ed by single quotes:
ʻThis is a type C literal’
ʻ123456789’
 Note
Character literals have ABAP type C.
String Literals
String literals are identi ed by back quotes:
`This is a string`
`123456789`
 Note
String literals have ABAP type STRING.
Numeric Literals: Type I and Type P

Numeric literals consist of only number characters, optionally introduced by a ʻ-’ character, indicating a negative value:
123456789
-123456789
 Built-in Functions in Logpoints

A build-in function is a prede ned function in ABAP that can be used in certain operand positions.
Built-in functions allow you, for example, to de ne key or eld values of dynamic logpoints. All functions have a return value and
can include up to one argument. To nd out what the type of the return value and the argument is, read the detailed description
of the functions below.
5/7/2023
 Note
The syntax of the built-in functions is based on ABAP formatting. For example, spaces are mandatory before the argument
and before the closing bracket.
Functions Available
In ABAP Development Tools (ADT), you can use the following built-in functions in logpoints:
INEXACT_DF()
LINES( itab )
REQ_ENTRYPOINT( )
REQ_TYPE( )
SQL_TRACE( StackOn|StackOff )
STACK( )
STACK_HASH( )
STRLEN( <arg> )
SYSTEM_INFO( )
TABLEBUF_TRACE( StackOn|StackOff )
XSTRLEN( <arg> )
_DEBUG_INFO()
_SET_DEVTRACE(<trace_activation>)
 INEXACT_DF()
Semantics Delivers information about the exactness of the last arithmetic operation with result type
DECFLOAT16 or DECFLOAT34
Return value Returns
'X': The last arithmetic operation with result type DECFLOAT16 or DECFLOAT34
delivered an inexact result.
SPACE: The last arithmetic operation with result type DECFLOAT16 or

DECFLOAT34 delivered an exact result.
Argument The function parameter does not have any arguments.
 LINES( itab )
Semantics Returns the number of lines of an internal table itab .
Return value Number of lines.
Return values have ABAP type I.
5/7/2023
Argument Valid ABAP variable that represents an internal table.
 REQ_ENTRYPOINT( )
Semantics Returns the name of the current entry point, such as the name of the current transaction,
the URL of the currently processed HTTP request, or the name of the submitted report.
Two different granularities of request entry points are to be considered. The rst one is the
request-based request entry point, which identi es…
Every rst request of a new logon session (for example: HTTP request, RFC, batch
job, or update task)
Every new transaction in an already existing logon session
The second is the roll-area (internal session) - based request entry point, which
identi es…
All request-based requests AND
The submitted reports therein (using the ABAP statement SUBMIT <report>)
For the resulting names, the following rules apply:
Every internal session provides its own entry point name.
URLs with more than 60 characters are truncated at the left.
Example:
..CRC/001/ECC_VENUERESVNERPCNCRC/ECC_VENUERESVNERPCNCRC_BIND
If the entry point has been overwritten by an ABAP application (through calling
function module PF_SET_APPLICATION_INFO or the method
CL_REQUEST_ENTRY_POINT=>set_name), the function returns the new name.
Return value Has ABAP type C with the length of the name of the current entry point.
Argument The argument may contain the values 'Q' or 'R', with the following meaning :
'Q' : determines the request name of the request-based request
'R' : determines the request name of the roll-area-based request
If a value other than 'Q' or 'R' is speci ed, the default value 'R' is taken.
If no argument is supplied, the default value 'R' is taken as well.
If an argument type other than ABAP type C with length = 1 is speci ed, the string
'<INVALID_SYMBOL>' is returned by the function.
For better code readability, usage of the built-in constants CtxRoll (value 'R' ) and CtxReq
(value 'Q' ) is recommended:
req_type( CtxRoll ) or req_type( CtxReq )
 Note
These constants are de ned in the scope of the parameter list of built-in functions that
are used in dynamic logpoints only. This means they are not valid inside standard
ABAP code, nor can they be used as normal variables in the condition, in the key
de nition, or in the eld values of dynamic logpoints (outside the parameter list of
built-in functions).
5/7/2023
 REQ_TYPE( )
Semantics Returns the type of the current request entry point, such as
transaction, HTTP request, or SUBMIT <report>.
Two different granularities of request entry points are to be

considered. The rst one is the request-based request entry point,
which identi es…
Every rst request of a new logon session (for example:

HTTP request, RFC, batch job, or update task)
Every new transaction in an already existing logon session.
The second is the roll-area (internal session) - based request

entry point, which identi es…
All request-based requests AND
The submitted reports therein (using the ABAP statement

SUBMIT <report>)
Return value ABAP type: C with length of string given below:
TA Transaction
RFC Remote function

call
SUBM Submit report
URL HTTP request
BTC Batch job
UPD Update task
<NO_TYPE> Unknown
request type
Argument This built-in function can have only one argument of ABAP type C
with length = 1.
The argument may contain the values ʻQ’ or ʻRʻ, with the following
meaning:
ʻQ’ : determines the request type of the request-based request
ʻR’ : determines the request type of the roll-area-based request
If a value other than ʻQ’ or ʻRʻ is speci ed, the default value ʻRʻ is
taken.
If no argument is supplied, the default value ʻR’ is taken as well.
If an argument type other than ABAP type C with length = 1 is

speci ed, the string ’<INVALID_SYMBOL>’ is returned by the
function.
For better code readability, usage of the built-in constants CtxRoll

(value ʻRʻ ) and CtxReq (value ʻQʻ ) is recommended:
req_type( CtxRoll ) or req_type( CtxReq )
 Note
5/7/2023
These constants are de ned in the scope of the parameter list
of built-in functions that are used in dynamic logpoints only.
This means they are not valid inside standard ABAP code, nor
can they be used as normal variables in the condition, in the key
de nition, or in the eld values of dynamic logpoints (outside
the parameter list of built-in functions).
 SQL_TRACE( StackOn|StackOff )
Semantics Switches the SQL trace on before the rst statement in the current
ABAP source code line is processed. The trace is switched off
automatically before a next ABAP statement is processed (that
starts at any other line or is executed in another procedure call).
By means of the function’s argument, you have, in addition, the

option to switch on or switch off the tracing of the ABAP stack (as a
part of the SQL trace’s capability).
 Note
It can also happen that the SQL trace has already been
activated with such an additional option (for switching the ABAP
stack on or off) by means of the transaction ST05 - that is:
independent from the function SQL_TRACE () used by dynamic
logpoints. The ABAP stack is written to the SQL trace if, at least,
one activation has switched on the ABAP stack capability.
Return value 1 - If the SQL trace has been switched on successfully.
0 - If the SQL trace could not be switched on.
Return values have ABAP type I.
Argument This function can have only one argument of ABAP type C with
length = 1.
The argument may contain the values ʻX’ or ʻ ʻ, with the following
meaning :
ʻX’ - In addition to the SQL trace, it also switches on tracing for the
ABAP
stack ( Default value).
ʻ ’ - Switches additional tracing for the ABAP stack off.
If a value other than ʻX’ or ʻ ʻ is speci ed, the value ʻ ʻ for the
argument is assumed.
If no argument is speci ed, the ʻX’ value is assumed (default

value).
If an argument of a type other than ABAP type C with length = 1 is

function.
For better code readability, usage of the built-in constants StackOn

and S tackOff is recommended:
sql_trace( StackOn ) or sql_trace( StackOff )
 Note
5/7/2023
that these built-in constants are de ned in the scope of the
parameter list of built-in functions used in dynamic logpoints
only. This means they are not valid inside standard ABAP code,
nor can they be used as normal variables in conditions of
dynamic logpoints, in the key, or in the results elds section
outside the parameter list of built-in functions.
 STACK( )
Semantics Returns the ABAP stack for the current source code position.
The function returns the internal stack format < program_name >#
< cont > with:
< progname > - Name of current ABAP program
< cont > - Byte code offset of the ABAP virtual machine.
The tool UI for dynamic logpoints presents the internal stack

format in a user-friendly way, much like the ABAP Debugger does.
 Note
If an ABAP stack cannot be evaluated, the function returns the
string < NO_STACK >.
Return type ABAP type STRING
Restrictions:
Usage of this function is restricted to the eld value list only.
 STACK_HASH( )
Semantics Returns a base64 hash representation of the ABAP stack for the
current source code position. The length of the hash value is
approximately 24 characters.
This function is especially useful in the key de nition of logpoints

when using function STACK( ) in the eld value list at the same
time. As a result, you get the aggregated list of all different ABAP
stacks that occurred at the current source code position of the
logpoint.
 Note
If an ABAP stack cannot be evaluated, the function returns the
string < NO_STACK_HASH >.
Return type ABAP type: STRING
 STRLEN( <arg> )
5/7/2023
Semantics Delivers the string length in character
For strings the current length of the STRING
For argument types C, N, D, T and at structures the current length of the lled part
without trailing spaces
Argument The function parameter <arg> can be typed with ...
the technical ABAP types C, N, D, T as well as STRING
at structures with character-like components (no strings or deep sub-structures

are not allowed).
 SYSTEM_INFO( )
Semantics Returns system information according to the input parameters
Return type ABAP type: STRING
length = 1. The argument may contain the following values:
'A' : Returns the name of the application server instance as it is

given by the pro le parameter rdisp/myname.
'T' : Returns the current UTC time stamp (long), according to the
pattern: YYYYMMDDHHMMSS,mmmuuuun
't' : Returns the current UTC time stamp (short), according to the
pattern: YYYYMMDDHHMMSS
If no argument is speci ed, the ' A' value is assumed (default

value).
If a value other than ' A', ' T' or ' t' is speci ed, the string
'<INVALID_SYMBOL>' is returned by the function.
If an argument type other than ABAP type C with length = 1 is

speci ed, the string '<INVALID_SYMBOL>' is returned by the
function.
For better code readability, usage of the built-in constants is

recommended:
AppServName: 'A'
TstmpS: 't'
TstmpL: 'T'
 Example
system_info( AppServName ) or system_info( TstmpL )
 Note
These constants are de ned in the scope of the parameter list
of built-in functions that are used in dynamic logpoints only.
This means, they are not valid inside standard ABAP code, nor
can they be used as normal variables in the condition, in the key
5/7/2023
de nition, or in the eld values of dynamic logpoints (outside
the parameter list of built-in functions).
 TABLEBUF_TRACE( StackOn|StackOff )
Semantics Switches the table buffer trace on before the rst statement in the
current ABAP source code line is processed. The trace is switched
off automatically before a next ABAP statement is processed (that
starts at any other line or is executed in another procedure).
By means of the function’s argument, you have, in addition, the

option to switch on or switch off the tracing of the ABAP stack (as a
part of the table buffer trace’s capability).
 Note
It can also happen that the table buffer trace has already been
activated with such an additional option (for switching the ABAP
stack on or off) by means of the transaction ST05 - that is:
independent from the function TABLEBUF_TRACE () used by
dynamic logpoints. The ABAP stack is written to the table buffer
trace if, at least, one activation has switched on the ABAP stack
capability.
Return value 1 - If the table buffer trace has been switched on successfully.
0 - If the table buffer trace could NOT be switched on.
Return values have ABAP type I
length = 1.
The argument may contain the values ʻX’ or ʻ ʻ, with the following
meaning :
ʻX’ - In addition to the SQL trace, it also switches on tracing for the
ABAP
stack (Default value).
ʻ ’ - Switches additional tracing for the ABAP stack off.
If a value other than ʻX’ or ʻ ʻ is speci ed, the value ʻ ʻ for the
argument is assumed.
If no argument is speci ed, the ʻX’ value is assumed (default

value).
If an argument of a type other than ABAP type C with length = 1 is

function.
For better code readability, usage of the built-in constants StackOn

and S tackOff is recommended:
sql_trace( StackOn ) or sql_trace( StackOff )
 Note
that these built-in constants are de ned in the scope of the
parameter list of built-in functions used in dynamic logpoints
only. This means they are not valid inside standard ABAP code,
5/7/2023
nor can they be used as normal variables in conditions of
dynamic logpoints, in the key, or in the results elds section
outside the parameter list of built-in functions.
 XSTRLEN( <arg> )
Semantics Delivers the string length in byte
For xstrings the current length of the string in bytes
For argument type X the length of the type
Argument The function parameter <arg> can be typed with the technical types X and
XSTRING.
 _DEBUG_INFO()
Semantics Delivers the current status of debugging for the currently executed request
 Note
This function is for SAP-internal use only. SAP support may suggests using this
function.
This function writes a substantial amount of data (> 2 kB). Therefore, use this function
carefully.
 Restriction
Usage of this function is restricted to the eld value list only.
Return value Returns an internal table containing the debugging status information
Argument Does not have any arguments
 _SET_DEVTRACE(<trace_activation>)
Semantics Changes the trace level and trace components as they can be set using pro le parameter
' rdisp/TRACE” and rdisp/TRACE_COMPS'. However, this function results in changes
for the currently executed request, only.
The current trace settings can be set to an arbitrary level for arbitrary components. At a
later point in time, a second dynamic logpoint can be used to reset to the default trace
activation. If no reset has been con gured, an implicit reset will be performed at the next
roll-out of the request.
For better readability, the ' calling function _SET_DEVTRACE()' marker pattern is
written to the developer trace le. The latter is used to quickly nd the starting point for
trace analysis.
 Note
5/7/2023
This function is for SAP-internal use only. SAP support may suggests using this
function.
In addition to the required authorization for using dynamic logpoints, using function
' _set_devtrace()' requires authority for process administration.
Ensure that your user has the additional authorizations. If not, a syntax error (without
further explanations) will be raised, when you try to create a dynamic logpoint,
containing function ' _set_devtrace()'.
Return value Returns the work process ID where the trace activation has been changed. The pattern for
the result string is ' WPID=<wpid>', for example, ' WPID=9'
Argument Can have only one argument of ABAP type C with arbitrary length
The syntax of the parameter for activation is ' <level>|<comps>'.
For deactivation, to return to default trace activation, the built-in constant DEFAULT or the
literal ' D' should be used as parameter.
 Example
Activation of trace level 2 for components ABAP (A), TaskHandler (M), and Dynp
processor (Y):
_set_devtrace( '2|all'AMY' )
To reset to default activation:
_set_devtrace( DEFAULT )
_set_devtrace( 'D' )
 Note
The built-in constants, such as DEFAULT, are de ned in the scope of the parameter list
of built-in functions used in dynamic logpoints, only. This means, they are not valid in
standard ABAP source code nor they can be used as common variables in conditions
of dynamic logpoints, in the key, or in the results elds section outside the parameter
list of built-in functions.
 Authorization Object S_DYNLGPTS for Logpoints

Authorization Object Field Value Meaning
S_DYNLGPTS
OBJTYPE
LOGPTS Affects logpoints
RESULT Affects log results
OBJNAME
BASIC Literals, Stack, Root ID
TRACING Tracing
VARIABLES ABAP Variables
ACTVT
5/7/2023
Authorization Object Field Value Meaning
01 Create
02 Change
03 Display
06 Delete
07 Activate, Deactivate
 Glossary
De ning Logpoints
Dynamic Logpoints
Logpoint properties:
Source Code Location,
Key De nition (short: Key)
Condition,
Field Values
Activation
Processing Logpoints
Evaluation of Condition
Log event
Log entry (log event writes a log entry)
Aggregation
Counter
Syntax for Breakpoint Conditions

Breakpoint conditions have one or more operands. These can be:
Variables (including special debugger symbols)
Literals
Built-in debugger functions
Syntax
The condition syntax allowed in breakpoint conditions is basically a subset of what is allowed in ABAP logical expressions, such
as an IF statement.
You can specify elementary logical expressions (for example,SY-SUBRC = 0) and combine them using the keyword AND, OR.
In addition, you can change the order of valuation by using brackets - as you are familiar with from logical expressions in ABAP.
5/7/2023
Similar to ABAP, you can also make use of short-circuit evaluation semantics, just like in the in the following example:
oref is bound and oref->attr = 'abc'
The second elementary logical expression oref->attr = 'abc' is evaluated only if the rst expression oref is bound has
been evaluated to true.
Examples for Valid Conditions

sy-index > 5
sy-index = sy-tabix
lines( itab ) > 0
lines( itab ) <> sy-tabix
lines( itab ) < lines( itab2 )
strlen( s ) >= sy-index
INEXACT_DF = 'X'
'DEADBEEF' cs 'BEEF' and sy-fdpos = 4
a > b AND (c > b OR c > d)
Related Topics
Variables in Breakpoint Conditions
Literals in Breakpoint Conditions
Built-in Functions in Breakpoint Conditions
Operators in Breakpoint Conditions
Variables in Breakpoint Conditions

In breakpoint conditions, you can use both simple variables and components of structures as variables. In addition, you can also
access eld symbols, class attributes and the content of internal table rows. Finally, you have the option, to specify offset and
length for strings, xstrings, and character elds.
Using Variable Symbols

In addition, to access variables, you can make use of some speci c debugger notations (variable symbols) that are not available
in ABAP source code.
Variable Symbol Meaning
itab[] Identi es the internal table itab
This symbol is only important for tables with a header row where itab identi es the header row of the
internal table.
5/7/2023
Variable Symbol Meaning
itab[n] Accesses the n-th row of the internal itab
{C:my_class} Identi es a class with the name my_class
You can use these symbols to access components as operands for breakpoint conditions, for example:
{c:myclass}-attr1 - Accesses the static attribute attr1 of the class myclass
itab[100]-comp1 - Accesses the component comp1 of the internal table itab for the 100-th row
Literals in Breakpoint Conditions

Breakpoint conditions support literals as operands. As you are already familiar with from ABAP syntax, the following types of
literals are also valid in breakpoint conditions:
Character Literals
Character literals are identi ed by single quotes, for example:
ʻThis is a type C literal’
 Note
Character literals have the ABAP type C.
String Literals
String literals are identi ed by back quotes, for example:
`This is a string`
 Note
String literals have the ABAP type STRING.
Numeric Literals: Type I and Type P

Numeric literals consist only of number characters, optionally introduced by a ʻ-’ character, indicating a negative value:
123456789
-123456789
 Note
Numeric values in the range of -2147483648 … 2147483647 have the ABAP type I, while all other numeric values in the range
of -9999999999999999999999999999999 ... 9999999999999999999999999999999 have the ABAP type P.
5/7/2023
Built-in Functions in Breakpoint Conditions

There are several built-in functions available for de ning breakpoint conditions. All functions have a return value and can include
up to one argument. To nd out what the type of the return value and the argument is, read the detailed description of the
functions below.
Note that the syntax of the built-in functions is based on ABAP style. For example, SPACES are mandatory before the argument
and before the closing bracket.
Functions Available:
LINES( itab )
Semantics Returns the number of rows of an internal table itab
Return value Number of rows
Return value has ABAP type I.
Argument Valid ABAP variable that represents an internal table
If an argument type other than ABAP internal table or an invalid symbol is speci ed, the program
will stop when it reaches the breakpoint and a corresponding error message is issued.
STRLEN( str )
Semantics Returns the current length of string str
 Note
Trailing blanks in character elds with xed lengths are not counted.
Return value Number of characters
Argument Valid ABAP variable of generic type CHARLIKE
If an argument type other than CHARLIKE or an invalid symbol is speci ed, the program will stop
when it reaches the breakpoint and a corresponding error message is issued.
XSTRLEN( str )
Semantics Returns the number of bytes
Return value Number of bytes
Argument Valid ABAP variable of type X or XSTRING
If an argument type other than X or XSTRING, or an invalid symbol is speci ed, the program will
stop when it reaches the breakpoint and a corresponding error message is issued.
INEXACT_DF( )
Semantics This function is used to identify inexact arithmetic operations that are executed with the numeric
5/7/2023
data type decfloat16 or decfloat34.
Return value 'X' - if the nal result of the an operation (for example, COMPUTE or MOVE) is inexact due to
rounding
' ' - otherwise (exact result).
Argument No argument
Operators in Breakpoint Conditions

The operators you can use in your logical expression along with breakpoint conditions are a subset of what you can use in ABAP
source code. However, the syntax and semantics of this subset during runtime are the same:
Standard comparison operators: =, <, >, <=, >=, <> or EQ, LT, GT, LE, GE, NE
Logical operators: NOT, AND, OR and brackets to combine elementary conditions
Operators for string analysis: CO, CN, CA, NA, CS, NS, CP, NP
Special binary operators: IS [NOT] INITIAL, IS [NOT] BOUND, IS [NOT] ASSIGNED
Examples
sy-subrc <> 0
( itab[1]-string is initial or not itab[1]-string co '0123456789' ) and ( itab[2]-string is

initial or not itab[2]-string co '0123456789' )
( I < J ) AND NOT oref->i GT dref->k OR X = Y[3]-COMP1 OR X = Y[2]-COMP1
 FAQs for SE80 Experts Using ADT

The following chapters answer frequently asked questions (FAQs) about the ABAP Development Tools (ADT) – that is SAP’s
Eclipse-based IDE. These FAQs are structured in tables that enable you to skim the features you want to perform in ADT.
Scope
Focus is on SAP GUI-based functionality and its integration within the IDE for easy use and fast transition.
Contents
Each FAQ starts with a header containing the relevant keywords. Below, you will nd a table, split into how to information for
SE80 and ADT. Each column describes the procedure in a text and screenshot. The ADT column also provides a link to the
relevant content in the official ADT help documentation to get further details.
 Example
The FAQs describe use cases from your daily work, such as:
Comparing versions and editing objects across several systems
5/7/2023
Arranging the object tree in accordance to your current need
Working with quick xes to get support or the relevant code snippets for the appropriate position/activity
And so on
 Note
This document will be continously supplemented in future. If you want to propose an FAQ that needs to be added to this
documentation, comment our SCN blog , please. Thank you for your help!
Target Group
This reference guide is for all ABAP developers who:
Are used to work with the ABAP Workbench so far and are now starting to work with ADT
Already work with ADT and want to nd out how a speci c feature has been integrated
Contents
You will nd here FAQs for the following development areas:
ABAP Core Development
ABAP Dictionary Tools
Testing and Quality Checking
Troubleshooting Tools
Related Information
Eclipse Basics
Quick Launch
Basic Tutorials
 ABAP Core Development

 Note
You can trigger most of the subsequent functions from the context menu of the selected development object in Project
Explorer, or alternatively from the open development object in the source-based editor.
Overview
In the context of creating and editing development objects, the following "how to" information is provided:
How can I log on and get access to development objects?
How can I open a development object?
How can I open a development object from another SAP system?
5/7/2023
How can I open a transaction?
How can I copy a development object?
How can I switch between the display and edit mode?
How can I unlock a development object?
How can I use code completion?
How can I add a comment?
How can I format (a.k.a. pretty printer) source code?
How can I navigate within source code?
How can I check the syntax of source code?
How can I trigger a where-used list?
Where I can see superclasses and subclasses from a usage?
How can I trigger method creation?
How can I delete the method of an ABAP class?
How can I insert and edit patterns in the source code?
How can I rename a development object?
How can I add favorites?
How can I rede ne a method?
How can I open the SE80 browser from the active editor?
How can I execute an ABAP program (report)?
How can I compare versions of a development object?
How can I toggle between the active/inactive version of a development object?
Where can I nd the attributes (and similar properties)?
Where can I nd SE09 (Transport Organizer)?
How can I add short texts?
How can I nd class documentation?
How can I check object type-speci c properties, for example whether a function module is RFC-enabled?
How can I change the package assignment of a development object?
How can I log on and get access to development objects?
How To in SE80 How To in ADT
5/7/2023
In the SAP Logon pad, create a new system entry using the New You rst need to establish a system connection. To do this, create
icon from the toolbar. Then open transaction SE80. an ABAP project that represents the repository in a structured tree.
To create an ABAP project, start your IDE and choose File New
ABAP Project from the menu bar.
Example of how to define the system connection in the SAP Logon pad
Wizard page for editing the system connection of an ABAP project
You then enter the system and logon credentials. Note that this data
is automatically copied from the system connection of the SAP
Logon pad.
For more information, see Creating ABAP Projects
How can I open a development object?
5/7/2023
From Object Navigator (SE80), choose the relevant mode and You have several options for opening development objects. The
select your type from the dropdown menu. Then enter the name in most effective way is using Ctrl + Shift + A from Project
the input eld and choose the Search or Display button. Explorer. Alternatively, you can click the Open ABAP
Development Object icon from the toolbar.
Enter your search criteria in the dialog. In the search input eld, you
can bene t from the content assistant that helps you to limit your
search.
 Note
Using Ctrl + Shift + A , you can limit your selection, for
example to the object name or object type. To do this, use
asterisks (such as *) or content assist ( Ctrl + Space ).
Area to define a selection of content to be opened
Input field for defining the conditions for the object to be opened
For more information, see Opening Development Objects
How can I open a development object from another SAP system?
5/7/2023
You have to open the other system and log on. From SE80, open the You can open, edit, and compare development objects from
development object manually. different SAP systems in parallel without logging on again.
 Note
In theIn advance, you need to create a new ABAP project for
each system to establish the relevant system connection.
You can open multiple editors across multiple ABAP projects in

parallel. This enables you, for example, to display and open the
same object more than once or to compare different versions at
the same time. In addition, you can arrange views to your needs
by drag and drop.
To open the development object from another system, choose

Open in Project <Relevant System> from the context menu.
Context menu to compare a development object across the available

system connections
For more information, see Opening in Another System
How can I open a transaction?
5/7/2023
OK eld, enter /O followed by the relevant transaction code to open In the editor, choose Alt F8 to open the Run ABAP
a new session. Press Enter . Application dialog. In the input eld, enter the name of the object
to execute or the name of the transaction to perform. Con rm with
OK.
Example for opening a new session starting with the /O prefix
Run ABAP Application dialog to open transactions in ABAP Workbench
For more information, see Copying and Duplicating Development

Objects
How can I copy a development object?
5/7/2023
In Object Navigator (SE80), select the relevant object or element In Project Explorer, select the relevant source-based object and
and choose Copy from the context menu. choose Copy from the context menu.
 Note
In addition, you can also duplicate an object to create the exact
same entity in a selected ABAP project. Choose then
Duplicate... from the context menu.
Context menu to copy, for example an ABAP class
For more information, see Copying and Duplicating Development

Objects
Context menu to copy, for example an ABAP class
How can I switch between the display and edit mode?
From the toolbar in the editor, choose the Display/Change icon. Initially, you are in display mode when opening an object in ADT.
When you start typing in the editor, the object switches to edit
mode automatically.
To switch back to display mode, choose Unlock from the context

Icon from the toolbar to switch between display and change mode menu. Note that your changes are then replaced.
Note that you can open and edit multiple objects from different
projects at the same time.
For more information, see ABAP Source Code Editor
How can I unlock a development object?
5/7/2023
You can only edit development objects when they are unlocked. You can unlock a development object that you are currently editing,
for example, to make its active version available for other users.
In Project Explorer, select the locked object and choose Edit

Unlock from the context menu.
Context menu to unlock development objects
 Note
All changes added after activation are deleted.
For more information, see Unlocking Development Objects
How can I use code completion?
In the source code of your development object, choose Ctrl + In the source code of your development object, choose Ctrl +
Space . Space . In addition to SE80, you can overwrite methods from
superclasses using code completion in ADT.
For more information, see Getting Support from the Content Assist
How can I add a comment?
5/7/2023
Select, for example, the relevant part of your source code and You can add and remove comments in the same way as in ABAP
choose Ctrl + < to add a comment, or > to remove it. Workbench.
For more information, see Editing ABAP Comments
How can I format (a.k.a. pretty printer) source code?
From the menu bar, choose Utilities Settings ABAP Editor To format the source code, choose Source Code Format from
Pretty Printer to de ne the settings. the context menu in the source code editor.
From the toolbar, choose the Pretty Printer button to execute.
Button from the toolbar to format the source code
Context menu path to execute the ABAP formatter
 Note
To use formatting, you need to con gure the relevant
preferences for each ABAP project in advance.
For more information, see Formatting ABAP Source Code
How can I navigate within source code?
Double-click an element or usage in the source-based editor. You From an element or usage in the source code editor, choose F3 or
then navigate, for example, to the relevant usage and another editor Ctrl + Click . You then directly navigate to the selected
is then opened. element/object. The relevant position of the usage is highlighted.
For more information, see Displaying Element Info in Source Code

Editors
How can I check the syntax of source code?
5/7/2023
Open and edit the object in the source-based editor. Then choose You can check the syntax of a source-based development object:
the Check icon from toolbar.
Manually by choosing the Check icon from the toolbar
Automatically while programming using the default check

preferences
Icon from the toolbar to check the syntax of a source-based development

object
Icon from the toolbar to check the syntax of a source-based development
object manually
Possible syntax errors are then displayed in the Problems view:
For more information, see Checking ABAP Syntax
How can I trigger a where-used list?
From the context menu of the relevant development object in the From the context menu of the relevant development object in the
object tree, choose Where-Used List, or from the toolbar in the Project Explorer, choose Get Where-Used List....
editor, choose the Use of icon.
For more information, see Searching Usages (Where-Used)

Icon from the toolbar to trigger Where-used from the toolbar
Where I can see superclasses and subclasses from a usage?
5/7/2023
From Object Navigator (SE80), select the relevant node. You can display the ABAP type hierarchy in its speci c view or in
the ABAP Element Info popup.
In the source code editor, select the relevant element. You can then
choose:
F4 to open the ABAP Type Hierarchy view or
Ctrl + T to open the Quick Type Hierarchy
 Note
If you choose T a second time, the superclass
Example of displaying the subclasses and superclasses in the object tree hierarchy is displayed.
Example of displaying the Quick Type Hierarchy in the ABAP Element Info
popup
For more information look here:
Viewing the ABAP Type Hierarchy
Quick Type Hierarchy
How can I trigger method creation?
From the form-based editor of Class Builder, you can trigger the From the method name in the implementation or de nition, you can
creation of a method implementation by double-clicking the trigger creation of the corresponding opposite using the Add
relevant name of the method to be created in the Methods tab. implementation or de nition for quick x. Optionally, you can
directly choose Ctrl + 1 from the editor.
Example of creating the method implementation out of the form-based

editor from Class Builder
Example for creating a method implementation using a quick fix
For more information, see Creating De nitions and Implementations

of Methods
How can I delete the method of an ABAP class?
5/7/2023
In the form-based editor of the class builder, select the relevant In the source code editor, position the cursor on the relevant
method and choose the Delete Method icon from the toolbar. method name and choose Ctrl 1 . Then double-click the Delete
entry in the Quick Fix dialog box.
Icon from the toolbar to delete methods
Example of a possible trigger position in the editor and the delete entry in
the Quick Fix dialog box
For more information, see ABAP Quick Fixes
How can I insert and edit patterns in the source code?
In source code of a method implementation, for example, choose You can add default patterns by using code completion or by
the Pattern button from the toolbar. double-clicking from the Templates view.
Example of a default template provided when triggering code completion
For more information, see Working with Source Code Templates
Button from the toolbar to add a pattern
How can I rename a development object?

You want to, for example, rename the name of a method that is used in an ABAP class.
5/7/2023
In Object Navigator (SE80), select the relevant method and choose In the source code editor, select the method and choose Source
Rename... from the context menu. Rename from the context menu.
Context menu to rename identifiers
For more information, see Renaming Identi ers
Context menu to rename, for example a method from Object Navigator
How can I add favorites?
5/7/2023
In Object Navigator (SE80), select the relevant ABAP object, users, In Project Explorer, you have the options for adding ABAP object,
or packages. Then choose Favorites Add from the toolbar. users, or packages as favorites:
Select the Favorite Packages tree
and choose Add Packages... from the context menu. Select

the relevant package. The package is then listed in the
Favorite Packages tree.
Select the ABAP package and choose Add to favorites

Menu from the toolbar to add or edit favorites from the context menu. The package is then displayed in
the Favorite Packages tree.
You can de ne ABAP repository trees to represent a

speci c structure of development objects.
Select the Local Objects ($TMP) tree
and choose Add Local Objects of User... from the context

menu. Select the relevant package. Select the user. The
user is then listed in the Local Objects ($TMP) tree.
Select the development object and choose Add

Bookmark... from the context menu. The object is then
listed in the Bookmark tree.
 Note
You can also de ne a bookmark for a speci c position
within the source code. To do this, choose Add
Bookmark... from the context menu at the beginning of
the speci c line in the ruler bar. A bookmark decorator
is then added.
For more information, see:
Adding a Favorite Package
Working with ABAP Repository Trees
Adding Local Objects of Other Users to Favorites
Working with Bookmarks
How can I rede ne a method?
5/7/2023
In Class Builder (SE24), select the relevant method in the Methods You can trigger the Override code completion ( Ctrl + Space )
tab. Then choose the Rede ne Method icon from the toolbar. from the possible positions within the implementation of the
relevant subclass.
Icon from the toolbar to redefine a method implementation from Class

Builder
The selected method is then opened in the source code editor.
Example of a list that displays the superclass methods that can be

overridden, triggered by code completion
For more information, see: Overriding Methods from Superclasses
How can I open the SE80 browser from the active editor?
From the toolbar of the editor, choose the Display object list icon. Choose the icon from the toolbar of Project Explorer or most
The object tree then displays the relevant object/element in the of the views. When you then select an development object, for
tree. example, in the Project Explorer, the relevant opened editor is
automatically focused. Alternatively, if you select an opened editor,
for example, the relevant development object is selected in the
ABAP Repository tree.
Icon from the toolbar to display the object list
 Note
The "Link with Editor" functional is set by default.
Icon from the toolbar to enable/disable the "Link with Editor" functionality
For more information, see Linking the Project Explorer view to the
active editor
How can I execute an ABAP Program (report)?
5/7/2023
From the toolbar of the editor, choose the Direct Processing icon or From the source code editor of an ABAP program, choose F8 . The
F8 directly. integrated SAP GUI is then opened.
For more information, seeRunning Executable Objects
How can I compare versions of a development object?
From the menu bar, choose Utilities Version Version From the context menu in the source code editor, choose Compare
Management . With
Navigation path to open version management
Navigation path to compare versions in the available ABAP projects
From the submenu, you can then select
Revison History to compare your changes since the object

was last activated.
An ABAP project that you want to compare your version

with.
Local History to compare your saved changes since

opening the object. This provides you with a more detailed
change history.
For more information, see Comparing Source Code
How can I toggle between the active/inactive version of a development object?
5/7/2023
From the toolbar, choose the Active <-> Inactive icon. In the editor of an inactive object version, choose Show Active
Version or Show Inactive Version from the context menu.
Icon from the toolbar to toggle between the inactive version or active
version of an object
Context menu to toggle from the inactive version to the active version of an
object
In addition, you can open the History view to display and open the
relevant version.
History view to toggle between versions
For more information, see Switching between Inactive and Active

Versions of a Source-based Object
Where can I nd the attributes (and similar properties)?
5/7/2023
From the menu bar, choose Goto Object directory entry This information is displayed in the Properties view. To display
attributes, open the relevant object. Then choose Window
Show View Properties from the menu bar.
Example of displaying properties using SE80
Example of a Properties view in ADT
If the Properties view is not visible in your eclipse, choose

Window Show View Properties from the menu bar.
For more information, see Displaying Properties of Development

Objects
Where can I nd SE09 (Transport Organizer)?
From the menu bar, choose Environment Transport Organizer From the menu bar, choose Window Show View Other...
(Requests) ABAP Transport Organizer . Optionally, you can enter
Transport Organizer in the Quick Access.
Quick Access input field from the toolbar to open specific views directly
Integration of Transport Organizer in Object Navigator Note that the Transport Organizer view is already displayed by
default.
Example of the representation from the Transport Organizer view in ADT
For more information, see Working with Transport Organizer
5/7/2023
How can I add short texts?
From the Methods tab in the form-based editor, for example, You use ABAP Doc comments to document code elements (for example,
add your short text in the Description tab. attributes, methods, or local variables).
Note that ADT does not support class documentation in particular. You
use ABAP Doc to add short texts.
To add an ABAP Doc comment, add one or more lines pre xed with "!
before the code element in question.
Example of a short text provided as description in the form-based
editor
To toggle ABAP Doc comments, choose Ctrl + 7 to comment.
In addition, you can synchronize short texts with descriptions saved in

the class builder. To do this, use the following tag:
 Example
...
PRIVATE SECTION.
"! 
Short Text to be synchronized with the backend
"!
METHODS description.
...
For more information, see
ABAP Doc Comments
Editing Comments in ABAP Source Code
Synchronizing ABAP Doc Comments
How can I nd class documentation?
5/7/2023
Open the relevant ABAP class in the source-based editor and then Open the class and then select the relevant class name. Choose
choose the Open Class Documentation icon from toolbar. F2 .
Button from the toolbar to open class documentation
Example of class documentation that is displayed in the Element Info

popup
To add ABAP Doc comments, add "! characters one row before the
relevant statement. Start then typing your comment.
Displaying Element Info in Source Code Editors
Editing ABAP Doc Comments
How can I check object type-speci c properties, for example whether a function
module is RFC-enabled?
From the Attributes tab, check the Remote-Enabled Module radio From the Properties view, open the Speci c subtap. Then check
button in the Processing Type area. the entry for the Processing TypeExample of displaying attributes
in the speci c subtap of the Properties viewProcessing Type
dropdown listbox.
Example of displaying attributes in the Attributes tab

Processing TypeExample of displaying attributes in the specific subtap of
the Properties viewProcessing Type
Adding Operations Using RFC Function Module
Creating Remote Function Call (RFC) Consumers
Creating RFC Consumers for Single-Target Consumer

Mappings
How can I change the package assignment of a development object?
5/7/2023
In Object Navigator (SE80), select the object and choose In Project Explorer, select the object and choose Change Package
Additional Functions Change Package Assignment from the Assignment from the context menu.
context menu.
Context menu to change the package assignment from Object Navigator
Context menu to change the package assignment of a development object
For more information, see Changing the Package Assignment of

Development Objects
Related Information
 ABAP Dictionary Tools

In the context of creating and editing ABAP Dictionary objects, the following "how to" information is provided:
How can I edit ABAP Dictionary objects?
How to with SE80 How to with ADT
5/7/2023
From the Repository Information System mode or using SE11: From the relevant ABAP project in the Project Explorer, choose
Select the relevant tree, object type, and object name to be Ctrl + Shift + A and enter the object name or open the
opened. relevant tree from the Dictionary folder.
The relevant editor is opened. From here you can start your work.
Form-based editor for defining structures
Example of general functionalities that are provided to edit structures in the

source code editor
For the following ABAP Dictionary objects an integrated source-

based editor is provided in ADT:
Structures
For the following ABAP Dictionary objects a form-based editor is

provided in ADT:
Domains
Data elements
Working with Structures
Working with Domains
Working with Data Elements
Related Information
 Testing and Quality Checking

In the context of testing ABAP source code, the following "how to" information is provided:
How can I perform the ABAP Test Cockpit (ATC) for a class, program, or function module?
Where can I nd details about errors?
5/7/2023
How and where can I get further information about error handling?
How can I perform the ABAP Test Cockpit (ATC) for a class, program, or function
module?
In the Object Navigator, select the relevant class, program, or In the source code editor, open your class, program, or function
function module. From its context menu, choose Check + ABAP module. From the context menu, choose Run As + ABAP Test
Test Cockpit. Cockpit.
Context menu to run the ATC for a development object
For more information look here Launching ATC Check Run from the
Project Explorer
Context menu to run the ATC for a development object
Where can I nd details about errors?
How To with SE80 How To with ADT
Perform the ATC for the relevant object. To get further details about an error, open the Problems view.
To do this, choose Window + Show View + Problems from the

menu or enter "Problems" in the input eld of the Quick Access.
Example of displaying problems in accordance to their priority
Quick access to open the Problems view directly
Example of a Problems view that displays errors, warnings, and additional

information
For more information, see Working with the ATC Problems View
How and where can I get further information about error handling?
Double-click the relevant error. Double-click the relevant error in the Problems view.
Example of how to navigate to the relevant position within the source code
where the error occurrs
Example of how to display further error details For more information, see Troubleshooting for ABAP Syntax Errors
and Warnings
5/7/2023
Related Information
 Troubleshooting Tools
In the context of debugging ABAP source code, the following "how to" information is provided:
How can I set a breakpoint?
How can I start the ABAP Debugger?
How can I set quickly a breakpoint for a function module?
How can I set a breakpoint?
In the source code editor of an ABAP program, set the breakpoint In the source code editor of an ABAP program, set the breakpoint
by selecting the relevant line of code and then clicking the by clicking in the ruler in the relevant position.
Set/Delete Session Breakpoint icon in the toolbar.
Example of a breakpoint set for line 20
For more information look here Setting and Managing Breakpoints
Example of a breakpoint set for a statement in a function module
How can I start the ABAP Debugger?
5/7/2023
Set the breakpoint(s) in your program. Then choose the Debugging Set the breakpoint(s) in the ruler bar of your program. Choose F8
button from the toolbar of SE38. to run your application and check the position where you have set
the breakpoint.
Example after execution of a program where a breakpoint is set and the

ABAP Debugger is opened
Example after execution of a program where a breakpoint is set and the

ABAP Debugger is opened
ADT then opens automatically the Debug perspective.
ABAP Debugger
Using Troubleshooting Tools
How can I set quickly a breakpoint for a function module?
Open your function module in SE37. Set the breakpoint(s) and start Open your function module and set the breakpoint(s) for an
the ABAP Debugger. From the menu, choose Breakpoints + executable ABAP statement by clicking in the ruler bar at the
Breakpoint at + Breakpoint at Function Module . beginning of the row.
Menu path for setting a breakpoint for an ABAP function module
Example for setting a breakpoint in an ABAP function module in ADT
For more information, see Working with ABAP Function Groups and
Modules
Related Information
5/7/2023
Security Guide
Target Audience
System administrators
ABAP developers
Why Is Security Necessary?

With the increasing use of distributed systems for managing business data, the demands on security are also on the rise. When
using a distributed system, you need to be sure that your data and processes support your business needs without allowing
unauthorized access to critical information.
This Security Guide assists you in making the ABAP development process secure using the ABAP Development Tools (ADT).
About This Document

The Security Guide comprises the following sections:
User Authentication on Front-End Client provides an overview of the authentication aspects.
Role and Authorization Concept introduces the authorization concept that applies to ABAP Development Tools
Resource Protection on Front-End Client explains how you can protect local resources of ABAP projects
Installing Plug-ins from Third Parties points to risks caused by installing third party plug-ins
Additional Information
For more information about speci c topics, see the Quick Links as shown in the table below.
Content Quick Link on SAP Service Marketplace or SAP Community
SAP Community Security Community
 SAP NetWeaver Guide Finder Guide Finder for SAP NetWeaver and ABAP Platform
 Note
To nd the relevant guide(s), search for Security.
Related SAP Notes SAP Security Notes & News
 SAP NetWeaver SAP NetWeaver Technology Community
 User Authentication on Front-End Client

In ABAP Development Tools, you always work with ABAP projects to access development objects from back-end systems. Such a
project represents a real system connection and therefore it requires an authorized user to access the corresponding system.
Every time you work with a project, you must rst log on to the front-end client. Then, with a logon method for the SAP system,
5/7/2023
you connect to the back-end system via the project. For the logon method, also known as standard authentication, the user
enters his or her logon credentials on the front-end client in order to log on to the ABAP back-end system.
Risks
Standard authentication with explicit speci cation of logon credentials means that user data entered at the front-end client is
loaded into the main memory of the local host as clear text.
A password that is buffered locally, however, represents a potential security gap because it could be extracted in some way from
the memory by a third party.
Protection Measures
In addition to Secure Network Communication (SNC), ABAP Development Tools support the Single Sign-On (SSO) mechanism.
Using SSO, the user does not need to enter a user ID and password for authentication but can access the system directly after
the system has checked the logon ticket. Therefore, besides SNC (recommended to be enabled for security reasons), we
recommend using the SSO mechanism for authentication when working with ABAP projects on the front-end client.
 Note
The ABAP Development Tools support the measures recommended: Every time you want to create a new ABAP project for a
system connection for which the SNC is not enabled, you will be faced with a corresponding warning message in the creation
wizard.
Warning when creating an ABAP project with no SNC system connection
 Recommendation
You can use assertion tickets for communication destinations between various other systems to perform the authentication
of frequent tasks or functions. Assertion tickets provide the highest level of security when creating an RFC or HTTP
connection and easiest usability for working with an ABAP system. We therefore recommend that you use assertion tickets
to allow ABAP developers to log onto an ABAP system.
To use assertion tickets, your ABAP system administrator needs to con gure the pro le parameters of the relevant ABAP
systems.
Related Information
 Con guration Guide for Con guring the ABAP Back-end for ABAP Development Tools
 Role and Authorization Concept

The identi cation of development objects belonging to the ABAP Repository takes place in the back-end with the speci cation of
the object type and the object name.
5/7/2023
The ABAP Development Tools, however, represent a front-end client and it makes use of the HTTP-based REST architecture
when communicating with the back-end. From the viewpoint of this architecture, ABAP development objects are addressed as
resources and identi ed through URIs. A front-end request keeps a URI ready whenever a development object is accessed and it
is passed rst to a router in the back-end. The router, in turn, transfers the request to the responsible resource controller. The
latter uses the incoming URI to ensure the identi cation of the matching development object in the ABAP Repository.
The registration of resource controllers takes place with the help of BAdIs. The actual BAdI implementation is performed for a
given URI on the basis of prede ned lter values. A lter value contains the respective static URI path, which is used to gain
access to the resource in the back end (that is, to the development object).
Risks
There is a potential possibility of backdoors being introduced in the application server during the registration of resource
controllers. This could happen when speci c BAdI enhancements that were implemented for handling random, even "malicious"
URIs are registered in the system.
Protection Measures
To provide protection against such backdoors, the proven SAP NetWeaver authorization concept is brought into operation. This
allows for the assignment of authorizations to system users on the basis of prede ned roles. The system administrator,
therefore, assigns to the system users one or several roles that, in turn, are based-at a technical level-on authorization objects.
When you are assigning user authorizations for access to development objects, we strongly recommend using the standard
roles (see the table below) and authorization default values that are provided for working with ABAP Development Tools. The
standard roles are linked with the standard authorization object S_ADT_RES, which you can use to check a random incoming
URI against a prede ned URI list-that is, a white list. This authorization object, therefore, retains as an attribute the list of all
allowed URIs. A "malicious" URI would then be discovered through the authorization check.
Standard Roles
The table below shows the standard roles that should be assigned for users of the ABAP Development Tools:
Role Description
SAP_BC_DWB_ABAPDEVELOPER ABAP developer
SAP_BC_DWB_WBDISPLAY Display user
For more information, see Reference Documentation for User and Role Administration
Standard Authorization Object
Authorization Object Field Description
S_ADT_RES URI Contains the white list of all allowed URI

pre xes
Resource Protection on Front-End Client

In ABAP Development Tools (ADT), an ABAP project provides a user-speci c view of all development objects of the back-end
system.
5/7/2023
Like all other projects under Eclipse, projects, too, have a local representation of their data on the front-end and are managed in
a workspace. In other words: When you have a project, local copies of development objects also exist on the front-end. This, in
turn, means that both the metadata and the source code of development objects are also accessible outside the ABAP
Repository at the level of the local le system.
Risks
The potential dangers lie in the following areas:
Metadata and sources of development objects being spied out by third parties
ABAP source code being manipulated locally on the front-end by third parties. If external users have access to the local
workspace folder, they have the chance to manipulate the development objects on the le system level. Data changed at
this level could be then propagated into the ABAP Repository as "hidden changes". In this way, even "malicious" ABAP
source code could nd its way in to the business application system.
Protection Measures
For the protection of local project resources, we strongly recommend the following protection measure:
Create your workspace folder for local storage of project resources in such a way that it cannot be read by third parties. Use the
protection measures that are already provided at operating-system level.
 Note
Files that are located under WindowsTM in the user's private folder subtree can only be accessed by the user himself/herself,
and by any user who is a local administrator.
In particular, we recommend making use of the default workspace that has been created with the IDE installation.
Installing Plug-ins from Third Parties

Your installation of ABAP Development Tools can be enriched with additional plug-ins from various providers (3rd parties).
Risks
These plug-ins can gain control over your client installation or even your complete front-end PC.
Protection Measures
You should carefully decide on plug-ins that you are going to install. For this, only use plug-ins from trusted sources and which
are using signatures.
What's New in ABAP Core Development

ABAP Development Tools (ADT) is released to customers in combination with the Application Server ABAP 7.53 SP00 shipment.
This means, in order to use certain ADT functionalities, you need to provide the corresponding back end.
 ABAP Platform
The following table gives you an overview of the released ADT versions and ABAP back ends:
5/7/2023
Back End Shipments/Version vs. ADT Client Versions
SAP SAP SAP SAP Application Application Application ABAP

NetWeaver NetWeaver NetWeaver AS NetWeaver AS Server ABAP Server ABAP Server ABAP Development
7.4 7.5 for ABAP 7.51 for ABAP 7.52 7.53 7.54 7.55 Tools (Client)
innovation
package
- - - - - - SP00 Version 3.12
- - - - - SP00 Version 3.4
- - - - SP01 Version 3.0
- - - - SP00 Version 2.96
- - - SP01 Version 2.89
- - - SP00 Version 2.83
- - SP03 Version 2.80
- SP04 Version 2.64
- SP03 Version 2.60
- SP02 Version 2.58
- SP01 Version 2.54
- SP00 Version 2.51
SP12 Version 2.48
SP11 Version 2.44
SP10 Version 2.41
SP09 Version 2.36
SP08 Version 2.31
SP07 Version 2.28
SP06 Version 2.24
SP05 Version 2.19
SP04 Version 2.16
SP03 Version 2.13
SP02 2.7
Version 3.12
Get an overview of the most signi cant changes in ABAP core development that relate to the following:
Client: ABAP Development Tools (ADT) 3.12
5/7/2023
Back end version:  Application Server ABAP 7.55 FPS00
 Note
All the features that are highlighted with a '*' are client-speci c and are therefore available for all supported ABAP systems.
In this topic, you will nd release information about the following:
Using System Connections from the SAP Logon Pad
Working with Problems View
Working with Business Add-Ins
Working with Number Range Objects
Working with Transport Organizer
Ensuring Quality of ABAP Code
 Using System Connections from the SAP Logon Pad

Support for reading the legacy SAPLOGON.INI le format has been discontinued. The reason is that all SAP GUI for Windows
versions that are currently in maintenance also do not support this le format anymore. As of now, only the current Landscape
XML format is supported.
 Recommendation
If you still use system connections based on the SAPLOGON.INI le format, SAP recommends to migrate them to the
Landscape XML format
 For more information, see
SAP note 2107181 - SAP Logon (Pad) 7.40: Collective SAP Note regarding SAP UI Landscape format
Using System Connections from the SAP Logon Pad
SAP GUI for Windows 7.60: New Features & Lifecycle Information

The Problems View displays problems (errors and warnings) with an icon and a message text. Sometimes an additional long
text exists that can be displayed by selecting Problem Description from the context menu.
New: Now an additional decorator on the icon informs you about the existence of the long text. It simpli es reading and
understanding the problem messages.
5/7/2023
 For more information, see Troubleshooting for ABAP Syntax Errors and Warnings
Working with Business Add-Ins (BAdIs)

You can now create BAdI Enhancement Spots and de ne BAdI de nitions using the BAdI Enhancement Spot Editor.
To implement BAdI de nitions you can now create BAdI Enhancement Implementations, where you can add BAdI
Implementations using the BAdI Implementation Editor.
BAdI Enhancement Implementation Editor
Creating BAdI Enhancement Spots
Editing BAdI Enhancement Spots
5/7/2023
Creating BAdI Implementations
Editing BAdI Implementations
Working with Number Range Objects

You can now create Number Range Objects and edit them in the Number Range Object Editor.
Number Range Object Editor
Creating Number Range Objects
Editing Number Range Objects
Improved Class Creation Wizard

When creating a class, you can now add one or more interfaces within the class creation wizard.
5/7/2023
Class Creation Wizard

 For more information, see Creating ABAP Classes
Protecting a Transport Request
You can now ensure that only the owner of the request adds more users to it by protecting the request.
Protect Transport Request
 For more information, see Protecting a Transport Request.
Changing a Task Type

5/7/2023
You can now change the task type of a task that is added under a transport request.
 For more information, see Changing a Task Type.
Supporting CDS View Entities and Projection Views in Test Double Frameworks
The CDS test double framework and ABAP SQL test double framework now supports the CDS view entities and projection
views.
ABAP CDS Test Double Framework.
ABAP SQL Test Double Framework.
Testing ABAP Authority-Check Statements using Test Helper API
Until now, there was limited support for testing role-based functionality using an AUTHORITY-CHECK statement in ABAP.
Writing unit tests by con guring various users with the required roles and authorizations is complex. The ABAP Authority Check
Test Helper API is a secure API-based approach that can be used in an ABAP Unit test class.
With ABAP Authority Check Test Helper API, you can now con gure authorizations for single or multiple users, set combination
of expectations, and get comprehensive log summary of the AUTHORITY-CHECK statements.
 For more information, see Managing Dependencies on ABAP Authority Checks with ABAP Unit.
 Version 3.8
 Note
In this topic, you will nd release information about the following:
Working with Data Preview
Copying Rows as ABAP Value Statement
You can now copy all the rows to the clipboard as an ABAP value statement in Data Preview. This enables you to copy the rows
as ABAP value statement and use it in the ABAP code to work with internal tables.
5/7/2023
You can use the generated source code in the ABAP code to work with internal tables.
Copy all rows as ABAP value statement
 For more information, see Copying Rows as ABAP Value Statement.
Version 3.4
Back end version:  Application Server ABAP 7.54 SP00
 Note
In this topic, you will nd the release information about the following areas:
ABAP Form-Based Editor
Working with Relation Explorer
Working with Development Objects
 Working with ABAP Source Code Objects
5/7/2023
Installing ADT on the Open Eclipse 2019-06 (4.12) Platform
ABAP Form-Based Editor

You can now copy the title from the form-based editor to your clipboard.
 Note
This feature is available in an ADT client installed on the latest Eclipse 2019-06 platform.
Working with Relation Explorer
Exploring Business Objects
A business object consists of hierarchical connected entities. The behavior for each entity is de ned in the behavior de nition
object and implemented in the behavior classes. In the Relation Explorer, you can see structure and behavior of a certain
business object independent of the technical location. You can navigate to all the entities and the corresponding behavior
(de nition and implementation).
Sometimes you might be interested in more CDS-speci c aspects and want to see access control lists or test classes. You can
achieve this by switching the context from Business Object to Core Data Services context, as you can see in the following
animation.
5/7/2023
Switching the context in the Relation Explorer
Relation Explorer
Exploring Business Objects
Con gure the transport organizer tree
Once the transport organizer tree is con gured in an ADT instance, transport organizer view displays the content based on the
same con guration across ADT instances in any machine for the same ABAP project, client and login user.
For more information, see Con guring Tree
Compare objects of a request/task with other revisions
You can now navigate to the History view of an ABAP object directly from the transport request/task editor to view all the
previous revisions of that ABAP object. From the history view you can compare with the required revision.
5/7/2023
You can also compare the changes in an object with other systems available in your ADT directly from the request/task editor
itself.
For more information, Comparing the Change in Objects
Working with Development Objects
Using ADT Links in All Supported Operating Systems*
You can now click ADT links in all supported operating systems.
This means, when clicking an ADT link, the relevant development object is opened in ADT directly.
Before you can click ADT links, select the adt schema on the new General Link Handlers preference page in advance.
Link handlers enable you to handle custom URL schemas, such as the adt schema.
Sharing and Opening a Link to a Development Object
Link Handlers
Added support for custom URL schemes
 Working with ABAP Source Code Objects
Working with Source Code Plug-Ins
You can now create enhancement implementations to implement available enhancement options.
5/7/2023
For the object to be enhanced, you can now display enhancement options as a marker. Enhancement options that already
contain an implementation are displayed with the marker . Enhancement options without implementations are displayed with
the marker . You can right-click the relevant marker to create an enhancement implementation or to add an enhancement
implementation element to an existing implementation.
Creating Enhancement Implementation
Changing the Contact Person of ATC Findings
You can now change the contact person of ATC ndings, if you want to assign the ATC ndings to a certain developer.
To do so, select the ATC ndings in question in the ATC Problems view and choose Change Contact Person in the context menu.
Changing the contact person of an ATC finding
 For more information, see Changing the Contact Person of ATC Findings
5/7/2023
Displaying ATC Findings When Releasing Transport Requests
You can now display ATC ndings when releasing a transport request.
When releasing a transport request in the Transport Organizer view, an ATC check run is launched automatically in the
background. If the ATC check run reports ATC ndings, the Release Transport Request dialog is displayed. Choose Display ATC
Findings to display the ATC ndings in the ATC Problems view.
Displaying ATC findings when releasing a transport request
 For more information, see Launching ATC Check Implicitly
 Displaying Results from the Reference Check System
You can now display central check results from the reference check system directly in ATC Result Browser.
Displaying central check results from the reference check system
ABAP Test Double Framework
You can now con gure a call to a static method in an ABAP interface using ABAP Test Double Framework.
Analyzing SQL Statements Using the SQL Trace and the Technical Monitoring Cockpit
You can now create an SQL Trace and display it in the Technical Monitoring Cockpit. This enables you to analyze the
performance of SQL statements.
To open the SQL Trace dialog, open the context menu of an ABAP project and choose SQL Trace....
5/7/2023
Context menu from an ABAP project to open the SQL trace
From the dialog that will then be opened, you can
start and stop the SQL trace and
navigate to the Technical Monitoring Cockpit in order to analyze the SQL trace results.
 For more information, see Using the SQL Trace and the Technical Monitoring Cockpit
Installing ADT on the Open Eclipse 2019-06 (4.12) Platform

You can now install the ADT client also on the latest Eclipse 2019-06 (4.12) platform.
This ADT client version supports the following Eclipse platforms:
2019-06 (4.12)
2019-03 (4.11)
Installing ABAP Development Tools
Eclipse 4.12 - New and Noteworthy
Version 3.2
5/7/2023
 Note
In this topic, you can nd release information about:
Eclipse IDE Package
Eclipse IDE Package*
Supported Eclipse Platforms
You can now install the ADT client on the latest Eclipse 2019-03 (4.11) platform.
2018-09 (4.9)
2018-12 (4.10)
2019-03 (4.11)
 Note
Contrary to SAP's support and maintenance strategy, this ADT client version currently supports three Eclipse platform
versions temporary.
Support Strategy of ABAP Development Tools (SAP Note 1856565)
Preparation of a Distributable Eclipse IDE Package
The ADT Installation Guide now contains information on how to prepare an Eclipse IDE package, including ABAP Development
Tools, that can be used for central distribution. This includes a description on how to automate the preparation.
 For more information, see Installing ABAP Development Tools (6.3 Recommendations for the System Administrator).
Version 3.0
Here is an overview of the most signi cant changes in the context of ABAP core development that relate to the following:
 Note
The following features that are highlighted with a '*' are client-speci c and are therefore available for all supported ABAP
systems.
5/7/2023
 Ensuring Quality of ABAP Code
Recommended Quick Fixes Wizard for ATC Findings
You can now x multiple ATC ndings at once with the Recommended Quick Fixes wizard. This wizard suggests recommended
Quick Fixes for all selected ATC ndings.
Quick Fixes provide functions that enable you to resolve errors and warnings without adapting your source code manually.
Apply Recommended Quick Fixes for ATC Findings in the Recommended Quick Fixes Wizard
 For more information, see: Applying Recommended Quick Fixes for Multiple ATC Findings

You can now install the ADT client also on the latest Eclipse 2018-12 (4.10) platform.
4.8 (Photon)
2018-09 (4.9)
5/7/2023
2018-12 (4.10)
 Note
Contrary to SAP's support and maintenance strategy, this ADT client versions supports 3 Eclipse platform versions
temporary.
As of ADT 3.0, on Microsoft Windows© operating systems only the 64-bit Eclipse version is supported.
Support Strategy of ABAP Development Tools (SAP Note 1856565)
Version 2.102
 Note
systems.
Installing ADT on the Open Eclipse 4.8 (Photon) Platform
Merge Requests
You can now move all the objects and tasks under one request to another request.
For more information, see Merge Requests
Including Objects in a request Manually
You can now include objects of your choice to a request or assign objects from one request to another request.
For more information, see Including Objects in a Request Manually
Installing ADT on the Open Eclipse 4.8 (Photon) Platform

You can now install the ADT client also on the latest Eclipse 4.8 (Photon) platform.
5/7/2023
4.7 (Oxygen)
4.8 (Photon)
Eclipse Photon (pre-release milestones) - New and Noteworthy
 Version 2.96
Back end version: Application Server ABAP 7.53 SP00
 Note
systems.
Support for Customer Extensions
Working with Classic Objects in ABAP Dictionary
ABAP Unit Test Relations
You can now assign ABAP Unit tests to ABAP Repository objects which cannot have their own tests, such as CDS views and
simple transformations. This means you need to model a relation between production code and test code. This relation is then
used by the ABAP Unit framework to nd the tests when test execution is triggered on the object in question.
To do this, write a speci c @testing link as an ABAP Doc comment in front of the test method or test class.
5/7/2023
Executed foreign tests for the CDS view
For more information, see the following:
Writing ABAP Unit with Test Relations
Launching ABAP Unit with Test Relations
ABAP Unit Launch Dialog
You can now con gure your individual test execution using the ABAP Unit Launch dialog.
In the Scope section, you can select your own tests and/or any foreign tests that you want to execute. You can also de ne
restrictions such as the Risk Level and Duration. This makes, for example, the tests run faster.
In addition, you can enable coverage measurement or trace recording of the tests.
5/7/2023
ABAP Unit Launch Dialog
For more information, see: ABAP Unit Launch Dialog
Quick Fixes for ATC Findings
You can now x certain ATC ndings with Quick Fixes. These Quick Fixes provide functions that enable you to resolve errors and
warnings without adapting your source code manually.
ATC ndings that can be xed with a Quick Fix are displayed with a lightbulb icon .
There are two ways of applying Quick Fixes for ATC ndings:
Select an ATC nding in the ATC Problems view and choose Quick Fix in the context menu.
Jump to your source code at the position where the ATC has found a problem and choose Quick Fix in the context menu.
Quick Fix in the context menu of an ATC finding in the ATC Problems View
For more information, see: Applying Quick Fixes for ATC Findings
Support for Customer Extensions
Editing Source Code Plug-Ins
ADT now provides native support for customer enhancements and modi cations.
You can change existing enhancements and modi ed source code.
 Note
If you need to enhance the SAP standard, SAP recommends using customer enhancements instead of modi cations.
Enhancement implementations are enabled as follows:
Available enhancement implementations are indicated by the source code plug-in marker . The source code plug-ins are
displayed in the popup when you hover over the marker.
5/7/2023
Popup with a single enhancement implementation
From here you can now navigate to the new Enhancement Implementation Editor:
Enhancement Implementation Editor
For more information, see: Editing Source Code Plug-Ins
Modifying Development Objects in the SAP Namespace
In some situations, the enhancement capabilities are not sufficient so you need to modify the SAP standard code using
Modi cation Assistant.
Editing of modi ed source code is now supported in ADT.
Replacing the condition in the original code with a new condition
For more information, see: Modifying Development Objects Using Modi cation Assistant
Creating and Editing Lock Objects
You can now create lock objects in ADT using the creation wizard. The new lock objects can then be edited in Lock Object Editor.
5/7/2023
Lock Object Editor
For more information, see: Working with Lock Objects.
Analyzing Runtime Errors
Runtime errors can be now displayed and analyzed in ABAP Runtime Error Viewer.
5/7/2023
Runtime Error Viewer
You can open Runtime Error Viewer by clicking Show in the dialog that appears when a runtime error occurs. Alternatively you
can open it from Feed Reader.
For more information, see: Displaying ABAP Runtime Errors
Viewing and Editing the Details of a Transport Request
You can now open a transport request or a task in a native editor in ADT. Previously, the transport request details were
displayed in the embedded SAP GUI.
5/7/2023
Transport Request Editor in ADT
For more information, see: Working with Transport Organizer
 Version 2.89
Here is an overview of the most signi cant changes in ABAP core development that relate to the:
Back end:  SAP NetWeaver AS for ABAP 7.52 SP01
 Note
Following features that are highlighted with a '*' are available for all ABAP systems supported by ADT.
Working with ABAP Projects
Overriding the Detection of File Locations
If system connections are missing from the SAP Logon pad when creating ABAP projects, you can now open the ABAP
Development System Connection preference page. Here you can override the detection of le locations.
For more information, see: Using System Connections from the SAP Logon Pad
 Version 2.83
Here is an overview of the most signi cant changes in the context of ABAP core development that relate to the current ABAP
Development Tools (ADT) client and the SAP NetWeaver AS for ABAP 7.52 SP00 back-end.
 Note
5/7/2023
Debugging ABAP Code
Improved Internal Table Analysis
The ABAP debugger tools have been recently enhanced with new features for the analysis of internal tables during ABAP
debugging.
For more information, see: Analyzing Internal Tables
Debugging Dynpro Flow Logic
You now have the option to debug the ow logic of dynpro screens (PBO, PAI, …). The dynpro debugging enables stepping from
ABAP code into the screen ow logic and vice versa.
For more information, look here: Debugging Dynpro Flow Logic
Debugging Enhancement Implementations
Just like stepping into dynpro ow logic by pressing F5 it is also possible to step into enhancement implementations (implicit
and explicit).
For more information, look here: Debugging Enhancement Implementation
Non-Exclusive Debugging in ADT
The non-exclusive debugging mode which is known from the SAP GUI debugger is now also available for the ADT debugger (for
NW 7.68 / 7.52 or higher).
For more information, see: Debugging Modes
Dynamic Logpoints in ABAP
Changing Logpoint De nition
In previous ADT versions, you could only change the logpoint activation status at any time while the logpoint de nition was
unchangeable. As of ADT version 2.83, you have the option of changing the logpoint de nition as well.
For more information, see: Changing Logpoints
Resetting Logs for a Logpoint
You now have the option of deleting the accumulated log entries of a dynamic logpoint without deleting the logpoint.
For more information, see: Resetting Logs for a Logpoint
Copying Logpoints
As of ADT version 2.83, you have the option of using copy, cut and paste functions on logpoints.
For more information, see: Copying Logpoints
AMDP Debugger
5/7/2023
Inspection of Long Variable Values
If you have ever worked with long string values in AMDPs, you might have encountered an annoying restriction in the AMDP
debugger: For variable values, or more speci cally, for their string presentation, only the rst 1024 characters are shown in the
corresponding Variables view. For cell values of table variables only 256 characters are shown.
"..." at the end of the value presentation indicates that the value has been truncated
As of ADT 2.83 (and NW 7.52), it is possible to inspect the whole variable value.
For more information, see: Inspecting Long Variable Values
Expanding an ABAP Repository Tree
You now con gure how to display the structure of the development objects beneath the ABAP project in the Project Explorer.
To do this, open the context menu from the rst tree level, and chooseExpand Tree by....
From the dialog to be opened, you can choose one of the following radio buttons for sorting:
Owner (default)
Application Component
Package
Object Type
API State
Creation Year
Original Language
Source System
Show development objects directly
For more information, see: Expanding an ABAP Repository Tree
Working with ABAP Packages
Creating ABAP Packages
5/7/2023
You can now create and edit ABAP packages in the integrated form-based editor.
This enables you to
Work with packages without opening SAP GUI.
Open and display packages from different ABAP systems in parallel.
Perform and display where-used lists for packages.
The form-based editor is designed as follows:
Example of an ABAP package opened in the form-based editor
The form-based editor provides the following information about an ABAP pacakge:
1. Toolbar to perform object-speci c actions
2. General Data to get an overview of the most relevant properties
 Note
You can nd further data in the Properties view.
3. Package Properties displaying package-relating information, such as possible superpackages and package types
4. Transport Properties containing transport-relating information, such as transport layer, software component,
5. The Properties is no part of the form-based editor, but it also displays additional properties, such as package
breadcrumb, version status, creation date
 Note
5/7/2023
The package breadcrump and application component are only provided if your ABAP system is connected with an SAP
HANA database.
For more information, look here:
ABAP Package Editor
Creating ABAP Packages
Working with ABAP Source Code Objects
Launching an ABAP Program in the Console View
You can now execute an ABAP program directly in ADT and display its result in the Console view without launching the
integrated SAP GUI.
To do this, open the relevant program in the source-based editor. Choose Run ABAP Application (Console) from the
context menu.
The following information from top down is displayed:
Creation date
Object description
Pagination
Program result
 Note
Parameters are not supported. Otherwise, a runtime error is displayed.
For more information, see: Launching an ABAP Program (Console)
Working with Database Tables
You can now create, edit, and delete database tables in the integrated source code editor of your Eclipse-based IDE.
5/7/2023
Example of features that are provided in a source code editor for database tables
To store properties of a database table in the database, metadata is represented and de ned by annotations in the source-
based editor.
The source code is generated when it is read from the database. When you save or activate a structure, the source code is
converted to the existing persistence.
 Note
To edit technical settings (data class, size category, buffering, and storage type) or to create/edit indexes, open the
integrated SAP GUI.
Working with Database Tables
Database Tables
Editing ABAP Source Code

5/7/2023
Getting Support from the Content Assist when Editing AMDP Method Implementations
When editing AMDP method implementations in ABAP classes, the content assist now proposes datasources, columns, variable
declarations, and so on.
For more information,see : Using Code Completion for ABAP-Managed Database Procedures
Formatting ABAP Source Code
For more information, see: De ning ABAP Formatting Options
Linking to ABAP Repository Objects Out of the Element Information Popup and the ABAP Element Info View
To use this new language element, add the ... {@link [[[kind:]name.]...][kind:]name} ... syntax to your
comment.
Linking ABAP Repository Objects and Its Components
Displaying Details in the Element Info Popup and the ABAP Element Info View
ABAP SQL Test Double Framework

The ABAP SQL test double framework is available to manage database dependencies. This framework is an addition to the
existing ABAP unit test framework, which enables testing of ABAP SQL statements present in your ABAP code through the
normal ABAP unit test classes. For more information, see ABAP SQL Test Double Framework.
Installing ADT on the Open Eclipse 4.7 (Oxygen) Platform

You can now install the ADT client also on the latest Eclipse 4.7 (Oxygen) platform.
4.6 (Neon)
4.7 (Oxygen)
Installing ABAP Development Tools for SAP NetWeaver
Eclipse Project 4.7 M2 - New and Noteworthy
ABAP in Eclipse 2.80 bene ts from Eclipse Oxygen
 Version 2.80
Development Tools (ADT) client and the SAP NetWeaver AS for ABAP 7.51 innovation package SP03 back end.
 Note
5/7/2023
The following features that are highlighted with an '*' are available for all ABAP systems supported by ADT.
Running ATC Checks

Overriding the prede ned ATC check variant
You can start an ATC check run with the Run As ABAP Test Cockpit With... to specify an arbitrary global check variant.
As developer, you can use this option to override the prede ned ATC check variant for a speci c check run.
For more information, see: Launching ATC Check Run from the Project Explorer
 Version 2.77
This is an overview of the most signi cant changes in the context of ABAP core development that relate to the current ABAP
Development Tools (ADT) client, and the SAP NetWeaver AS for ABAP 7.51 innovation package SP02 back end.
 Note
Features highlighted with an asterisk ('*') are available for all ABAP systems supported by ADT.

The ABAP Formatter preferences page has been redesigned. Its usability has been improved, and the user interface now
provides you with greater exibility when de ning the formatting options of ABAP source code.
It now provides the following new areas:
Upper/Lower Case Conversion to de ne formatting of ABAP keywords and identi ers in lower and upper case more
transparently.
Preview to see what the result of the formatting options will look like before publishing. An example code snippet is used
and displayed for this.
De ning ABAP Formatting Options
Unit Testing with ABAP Unit

Displaying and Switching Within the ABAP Unit Test History
You can now display the previously performed test runs in the ABAP Unit Test history. This enables you to switch between
different test runs without performing them again. The advantage is that you save time and will immediately have the already
evaluated test run(s) back at your disposal.
To display the history, choose the arrow from the History... icon displayed in the toolbar for the ABAP Unit Runner view. To open
the relevant test run, double-click it in the ABAP Unit Test History.
5/7/2023
 Note
When you perform a test run, the previous result will be overwritten but not deleted.
You can precon gure to display up to the last 99 test runs. To do this, enter the relevant number in the Maximum number of
remembered test runs input eld.
For more information, see: Using the History to Switch Between Results of ABAP Unit Tests
Filtering Test Results
In the ABAP Unit Runner view, you can now restrict the number, for example, to display only unit tests that have errors.
To do this, select one or more of the following checkboxes from the bar above the result tree for the tested development object:
Icon Meaning Description
Errors To nd out where your test run has

investigated an error in your code
Warnings To nd out which test methods result in

warnings
Aborts To nd out which tests have not been

executed
Successful To nd out which test method(s) have

passed the expected behavior
 Note
If you deselect a checkbox, the corresponding test methods are hidden. This improves readability and makes it easier for you
to focus on the relevant test results.
If you right-click one of the selected checkboxes, the remaining selections are deselected. This enables you to deselect the
remaining checkboxes in one step.
For more information, see: Evaluating ABAP Unit Test Results
Displaying the Number of Test Methods
The number of test methods in a test class is now displayed at result tree level of the tested development object. This enables
you to investigate where and how many test methods exist.
The number is displayed in total for each main program and test class in blue brackets.
Display of the Duration from Test Runs
ADT now displays the total execution time of a test run in the bar above the result tree for the tested development object.
Running Parallel Test Execution
5/7/2023
You can run now different test runs in parallel. This makes it possible to trigger several test runs if another test run is already in
progress.
ADT will always overwrite the results of the last test run. Using the ABAP unit test history, you can now select and open the
relevant result.
 Version 2.73
 Note

Searching within the Element Info Popup and Element Information View*
The Element Info popup and Element Information view now provide a search input eld at the bottom. This enables you to
search for elements within the element info.
Search input field in the Element Info popup/Element Information view
The relevant search results are then highlighted in the element info. To browse through the search results, you can use
shortcuts and icons.
For more information, see: Displaying Details in the Element Info Popup and the ABAP Element Info View
Browsing within the Element Info Popup and Element Information View*
You can now use shortcuts to browse in the history and the usages in the Element Info popup and Element Information view.
For more information, see: Displaying Details in the Element Info Popup and the ABAP Element Info View
Getting Support from the Content Assist when Editing AMDP Method Implementations
When editing AMDP method implementations in ABAP classes, the content assist now proposes datasources, columns, variable
declarations, and so on.
For more information, see: Using Code Completion for ABAP-Managed Database Procedures
Breadcrumb Provides Information about Control Structures*
In the breadcrumb bar of the ABAP source code editors, information about control structures is now provided. This helps you to
orientate within a processing block and to navigate to other branches of a control structure.
5/7/2023
For more information, see: Getting Orientation in the Source Code Using Breadcrumbs
Working with ABAP Source Code Objects

Launching an ABAP Class as ABAP Application (Console)
You can now execute an ABAP class that implements the if_oo_adt_classrun interface. This class enables you to display
any kind of text and/or content of internal tables in the Console view.
Example of a Console view when launching such an ABAP class
To launch an ABAP class, you have to add the if_oo_adt_classrun ABAP interface to its de nition and implement the
relevant main method. You can then perform Run As + ABAP Application (Console) from the context menu of the source
code editor. Alternatively you can choose F9 .
For more information, see: Launching an ABAP Application (Console)

You use domains to de ne a value range. You can now create, edit, and delete domains in the integrated form-based editor of
your Eclipse-based IDE.
Help Contents
Providing "How to" Information for SE80 Experts who are Switching to ADT
If you are an SE80 expert who has started working with ADT, you will now nd the following information in the Help Contents:
Eclipse basics in the Getting Started chapter that describe the most relevant elements of the Eclipse UI in general.
FAQs in the Reference chapter that compare the "how to" information of the most relevant ABAP development activities
in environment SE80 and in ADT.
The FAQ list is divided into different development areas.
This content enables you a smooth transition from SE80 to ADT.
Eclipse Basics
FAQs for SE80 Experts Using ADT
5/7/2023
 Version 2.68
 Note

Displaying and Structuring Content Through ABAP Repository Trees
ABAP repository trees enable you to de ne your own selection of the development objects in the Project Browser. In addition,
they display for each level the number of containing objects and a short text.
 Note
This functionality requires working on SAP NetWeaver AS for ABAP 7.51 innovation package SP00 that is connected with a
SAP HANA database.
So far, the Favorite Packages and the System Library with all development objects are displayed by default in the Project
Explorer.
They are now replaced by the following default virtual trees:
Local Objects ($TMP) displays your local objects sorted in accordance to the user and object type.
System Library displays all development objects sorted in accordance to the corresponding ABAP package.
ABAP Repository Trees
Working with ABAP Dictionary Objects

Editing the Status of Documentation for Data Elements
You can now specify the documentation status of a data element to de nes whether documentation has already been written or
whether it is still required.
For more information, look here: Changing the Documentation Status
Working with ABAP Development Objects

Searching ABAP Source Code
The ABAP Source Search now also supports the IBM Db2 database type.
For more information, look here: Searching ABAP Source Code
Navigating to Development Objects from the Element Info Popup
5/7/2023
You can now open a development object directly from the position where it is displayed in the Element Info Popup.
Example of the context menu entry in the Element Info popup from where you can navigate to a development object
To do this, select the relevant usage in the Element Info Popup and open the context menu. Choose then Navigate.
For more information, look here Displaying Details in the Element Info Popup and the ABAP Element Info View
Working with Released APIs
You, as a developer, can now check which APIs are released and stable for usage – and which are not. Consequently, customer
objects that only use released APIs do not need to be adapted after the next SAP NetWeaver support package or upgrade.
Released APIs
Setting the API Release State

Using Quick Fixes and Code Completion to Format ABAP Doc Comment*
You can add formatting using code completion ( Ctrl + Space ). In addition, you can also use quick xes ( Ctrl + 1 ) to
adapt formatting to existing comments.
To perform both, position the cursor at the corresponding position or select the relevant text. Press then the shortcut and
choose the relevant formatting from the popup.
For more information, look here: Formatting ABAP Doc Comments
Debugging Support for CDS Table Functions

You have now the option to debug CDS table functions using the AMDP debugger. A table function consists of a CDS de nition
and a SQLScript procedure implementation that is used for data retrieval once the table function is accessed (for example
using OpenSQL).
Now, you cannot only debug AMDPs with ABAP Development Tools (ADT). The integrated debugger that is part of the ADT client
installation, allows you also to debug the CDS table functions within the ABAP development IDE.
For more information, look here: Working with the AMDP Debugger
Working with ABAP Push Channels
5/7/2023
Creating and De ning ABAP Push Channel Applications
ABAP Development Tools now provides a form-based editor to create and edit APC applications. Using this editor you can
con gure an APC application that enables bi-directional communication with user agents through the integration of
WebSockets or TCP Sockets.
For more information, look here Working with ABAP Push Channels
 Version 2.64
Development Tools (ADT) client and the SAP NetWeaver 7.5 SP04 back end.
 Note
The features below that are highlighted with an '*' are available for all ABAP systems supported by ADT.
Installing ADT on the Open Eclipse 4.6 (Neon) Platform

You can now install the ADT client also on the latest Eclipse 4.6 (Neon) platform.
4.5 (Mars)
4.6 (Neon)
Eclipse Neon - New and Noteworthy (Information published on non-SAP site)

Navigating Within the Element Information of Development Objects*
You can now navigate from the Element Information Popup of a usage to the Element Information Popup of another usage by
clicking its name. Note that the same functionality is also provided for the ABAP Element Info view.
Example of an Element Information popup from where you can open the corresponding information of another usage
For more information, look here Displaying Details in the Element Info Popup and the ABAP Element Info View
5/7/2023
Overriding Methods from Superclasses*
You can generate the code snippet for the method rede nition and its implementation block in one step. To do this, position the
cursor between the CLASS implementation and the ENDCLASS statement. Then trigger the code completion. As a result, a list
with all methods that can be overridden is displayed. From here you can choose the relevant method.
List that displays the superclass methods that can be overridden, triggered by code completion
 Note
The supercall is not added by default. You will have to add it to the method implementation block manually.
For more information, see Overriding Methods from Superclasses
Adding ABAP Doc Comments for Methods Using The Quick Assist
In the de nition of an ABAP class, you can document a method. When using the 
tag, the short texts between the form-based Class Builder in the backend and the ADT source code editor are synchronized
automatically.
In the de nition of an ABAP class, you can now document a method by using the Add ABAP Doc quick assist. The tag is then added in an ABAP Doc comment block. When activating, the short texts
will be synchronized with the back end.
5/7/2023
Quick fix dialog box to add the ABAP Doc comment block for synchronizing with the back end
For more information, look here
Adding ABAP Doc Comments
 Version 2.60
 Note
The features below that are highlighted with an '*' are available for all ABAP systems supported by ADT.

Changing The Color of Individual ABAP Keywords*
Now you can con gure the syntax coloring preference for each single ABAP keyword or the sequence of several ABAP keywords,
for example, "call method", used within a statement. This enables you to highlight all relevant occurrences and to improve
readability when you skim through ABAP source code objects such as ABAP classes, interfaces, programs, and so on.
To proceed, open ABAP Development Editors Source Code Editors ABAP Keyword Colors preference page. From here
you can use a set of prede ned syntax coloring con gurations provided by SAP.
 Note
To make these default con gurations visible in your ABAP source code, you also have to apply your preference.
For more information, look here Changing The Color of Individual ABAP Keywords
Prede ning a Background Color for ABAP Method Blocks*
Now you can prede ne a background color to highlight the implementation of a method in the source code editor. Then,
between the METHOD and ENDMETHOD statement, the background color of a method body is displayed in the prede ned color.
To proceed, open the General Appearance Colors and Fonts preference page and expand the ABAP Syntax Coloring
folders. From here you edit the ABAP method block entry.
5/7/2023
For more information, look here Changing the Font Color of Texts
 Version 2.58
 Note

Usability Improvements in the Creation Wizard for New ABAP Projects*
On the rst page of the creation wizard for ABAP projects, is now a tabular overview displayed. Here, you can nd all system
connections that are con gured in the SAP Logon.
From here, you have the following possibilities:
You can choose an existing system connection. Then, on the second page, all connection details are displayed. From here,
you can review or, if required, modify them.
You can con gure a new system connection for your ABAP project from scratch.
For more information, look here Creating ABAP Projects
 Version 2.54
Development Tools the (ADT) client and the SAP NetWeaver 7.5 SP01 back end.
 Note
Additional Functions in ABAP Debugger
Working with Breakpoint Conditions
When debugging ABAP code, you have now the option to specify a condition for an ABAP breakpoint. The condition is evaluated
at runtime whenever the source code position of the related breakpoint is reached. If the condition is ful lled, the debugger will
stop execution at the breakpoint.
For more information, look here: Adding Conditions to Breakpoints
Working with ABAP Dictionary Objects

Creating, Editing, and Displaying Supplementary Documentation for Data Elements
From the toolbar, you can provide additional supplementary documentation for each data element in order to provide individual
program-speci c and dynpro-speci c eld help.
5/7/2023
For more information, look here: Providing Supplementary Documentation

Using Search Patterns for Opening ABAP Development Objects
When using Ctrl + Shift + A , you can now de ne the following defaults for the search text eld:
Text combinations, for example, ADT type:class
Input from the previous search
To ll these defaults in the search text eld, de ne the following Search preferences:
Use as initial search pattern to enter a default search pattern in the input eld.
Use pattern from previous search to reuse the previously entered search string.
For more information, look here: 'Open ABAP Development Object' Dialog

Displaying the ABAP Language Version of ABAP Programs and Classes
You can now indicate for which scenario (such as Unicode program (default) and ABAP for Key Users) the syntax rules and
language elements of ABAP programs and classes need to be checked.
For more information, look here De ning the ABAP Language Version of ABAP Programs and Classes
 Version 2.51
This is an overview of the most signi cant changes in ABAP core development, that relate to the current ABAP Development
Tools (ADT) client and SAP NetWeaver 7.5 SP00 back end.
 Note
The features listed below that are highlighted with an asterisk (*) are available for all ABAP systems supported by ADT.

Creating and Editing Structures in the Source-Based Editor
You can now access, create, edit, transport, and delete structures from the ABAP Dictionary. For this purpose, the source-based
editor is provided where you can work with structures in the same way as you are used to for ABAP classes, programs, and so
on.
You have, for example, the following functionalities at your disposal:
Syntax highlighting
Code completion
Navigation
Where-used list
Code element info

5/7/2023
Automatic syntax check
Context-sensitive ABAP keyword documentation
Working with Structures
Syntax of ABAP Dictionary Objects
Creating and Editing Data Elements in the Form-Based Editor
You can now access, create, edit, transport, and delete data elements from the ABAP Dictionary. For this purpose, the form-
based editor is provided.
Working with Data Elements

Changing the ABAP Package Assignment
You can move a development object into another ABAP package in order, for example, to ship an ABAP class that was created in
your $TMP package using the productive ABAP source code.
To do this, select the object in the Project Browser and choose Change Package Assignment. Then de ne the new package.
For more information, see Changing the Package Assignment of Development Objects
Working with ABAP Classes Assigned to Multiple Transport Requests
You can edit a class that consists of several subobjects, such as a public section, method implementation, or local class includes.
You can then assign each change made to a subobject to a transport request separately.
If you want to edit an ABAP class where the changes have already been assigned to a transport request by another user, the
Link Up of Transport Request dialog opens automatically:
Example of a dialog where you select the assignment of the transport request
Here you can assign your changes to different transport requests.
For more information, look here Working with ABAP Classes Assigned to Multiple Transport Requests
5/7/2023
Using Untyped Parameters in Function Modules
If you edit an existing function module with untyped parameters, the editor automatically adds the
##ADT_PARAMETER_UNTYPED pragma to the de nition. When you perform save, the parameter is kept untyped and
unchanged in the back end – that is, the system does not explicitly add TYPE ANY or TYPE STANDARD in transaction SE37.
For more information, see De nition Part
De ning Templates for ABAP Programs
You can specify whether you want to generate your own or the standard comment block before the REPORT statement.
Creating ABAP Programs
De ning Code Templates for ABAP Programs

You can now synchronize ABAP Doc from descriptions of the Class Builder using the source-code editor in ABAP Development
Tools (ADT) and vice versa.
For more information, see Synchronizing ABAP Doc Comments
Exporting ABAP Doc Comments
You can now export source code documentation of ABAP classes and ABAP interfaces – for example, if you want to have a
backup for them for audits.
For more information, see Exporting ABAP Doc Comments
Grouping Inactive Objects for Mass Activation by Transports Requests
When you activate several development objects, the inactive objects are now automatically sorted according to the transport
requests to which the changes are assigned. As a result, the inactive objects are sorted upwards according to the names of the
transport tasks in the Activate inactive ABAP development objects dialog.
 Example
You want to test an ABAP class that refers to a class of the same transport request that was modi ed by another user.
Deselect the Group object list by transport request checkbox if you only want to perform sort for the inactive objects.
For more information, see Activating Development Objects
Displaying and Changing Object-Speci c Properties
In the General and Speci c tab of the Properties view, you can now display and change the properties of the following ABAP
development objects:
Classes
Interfaces
Function groups
5/7/2023
Function modules
Programs
Includes
Type groups
Transformations (read-only)
For more information, see Displaying Properties of Development Objects
Navigating to Development Objects Using Ctrl+Shift+A*
When performing Ctrl+Shift+A, you can now limit the number of displayed entries by entering "<". Then, only the
development objects are displayed whose name ends on the value that you entered before the "<" character.
 Example
To see all the development objects ending with "Test", use "*Test<"
For more information, see 'Open ABAP Development Object' Dialog
Working with Transformations

Creating and Editing Simple Transformation Programs
You can now create and edit simple transformations (ST) and XSL transformations in their own source-based XML editor. For
the creation function, you can use the corresponding templates.
Transformation Editor
Working with Transformations for XML

Displaying System Connection and Database Con guration
You can display the system information of an ABAP project in the System tab of the Properties view. This enables you to nd
out, for example, whether the requirements for a certain functionality are supported.
For more information, see Displaying System Connection and Database Con guration
Refactoring Aids
Surrounding with TRY CATCH
You can surround the selected block of statements with a TRY CATCH statement in order to handle raised exception(s) as a
single or multiple TRY CATCH block.
For more information, see Surrounding with TRY CATCH
Extracting a Catch Variable
You can add a local variable to the method signature. Its type refers to the raised exception of the calling method. In addition,
this local variable is added as an INTO clause to the already existing CATCH block. This enables you to handle the result of the
5/7/2023
exception in order, for example, to display it in a message.
For more information, see Extracting a Catch Variable
Extending a TRY CATCH Statement
You can add a new CATCH block to an existing TRY CATCH statement. This enables you to handle another exception in an
existing TRY CATCH statement.
For more information, look here Extending a TRY CATCH Statement
Splitting a MULTI CATCH Block
You can replace an existing MULTI CATCH block by individual CATCH blocks for each exception separately.
For more information, see Splitting a MULTI CATCH Block
Removing a TRY CATCH Statement
You can remove an entire TRY CATCH statement if you no longer want to handle the exceptions.
For more information, see Removing a TRY CATCH Statement
Generating Getters and Setters
You can now generate the getter and/or setter method stubs from an attribute in the de nition of an ABAP class in the
implementation. In addition, the corresponding importing and/or returning parameter(s) are set.
For more information, see Generating Getters and Setters
Regenerating a Constructor for Exception Classes
Exception classes have special constructor methods. If they implement the interface IF_T100_MESSAGE, the signature and
the implementation have a special logic.
You can now regenerate their constructor if you have added or removed:
the interface IF_T100_MESSAGE, or
public or protected attributes.
For more information, see Regenerating a Constructor for Exception Classes

Working with Dynamic Logpoints
Logpoints indicate to the ABAP runtime that an ABAP program is to execute a custom action at a certain point within the
program. Dynamic logpoints have been introduced in order to support logging in quality or productive systems where the source
code cannot be changed.
Using Dynamic Logpoints
5/7/2023
Additional Analysis Tools in the ABAP Pro ler

Condensed Hit List
You can now use the Condensed Hit List to nd top consumers with regard to procedure calls, such as methods, function
modules, subroutines, or other kinds of calls.
Finding Top Consumers Using the Condensed Hit List
Understanding ABAP Pro ler Settings
Aggregated Call Tree
Aggregated Call Tree shows the trace events in aggregated form. In this case, the trace events are aggregated By Call Stack
and are displayed in a tree hierarchy.
For more information, see Analyzing Trace Events in the Aggregated Call Tree
ABAP Debugger
New Debug Settings
You can now use project-speci c debug settings to change the user for which ABAP breakpoints are in effect. In the special case
where several people are using the same user name and password (group users) the new option. This project only within the
project-speci c settings allows you to handle technical con icts during debugging.
Setting ABAP Project-Speci c Debug Settings
Managing Technical Con icts During Debugging
Debugging Support for ABAP Managed Database Procedures (AMDP)

AMDP Debugger
ABAP Managed Database Procedures (AMDP) are a new feature in AS ABAP that enable developers to write database
procedures directly in ABAP. You can now debug AMDPs using ABAP Development Tools (ADT).
The integrated AMDP Debugger is used to debug the execution of DB procedures running on HANA DB and provides the
developer with the following activity options:
(De-)Activation of the AMDP debugger
Setting breakpoints
Stepping
Viewing variables and table contents
 Version 2.48
5/7/2023
Here is an overview of the most signi cant changes in the context of ABAP core development that relate to the:
Back end:  SAP NetWeaver 7.4 SP12
Installing ADT on the Open Eclipse 4.5 (Mars) Platform

You can now install the ADT client also on the latest Eclipse 4.5 (Mars) platform.
4.4 (Luna)
4.5 (Mars)
For more information, look here
Eclipse Project 4.5 M2 - New and Noteworthy
 Version 2.44
 Note
The following features that are highlighted with a '*' are available for all ABAP systems supported by ADT.

Con guring Code Completion to Automatically Insert the Full Signature*
When you perform code completion, you can now con gure the preferences to insert the full signature of a method, function
module, or form routine automatically.
 Note
This functionality is not enabled by default. To use it, you need to select the Always insert full signature on completion option
in the Code Completion preferences.
For more information, look here Inserting a Full Signature Automatically
Con guring Code Completion to Overwrite Source Code*
When you perform code completion, you can now con gure the preferences to overwrite the existing keyword or identi er with
the selected proposal from the code completion list.
 Note
5/7/2023
This functionality is not enabled by default. To use it, you need to select the Completion overwrites radio button in the Code
Completion preferences.
For more information, look here Inserting or Overwriting Source Code
 Version 2.41
 Note
The following features that are highlighted with a '*' are available for all ABAP systems supported by ADT.

Running Applications in the Same SAP GUI Window
You can open an executable object like an ABAP program in a new or in the same SAP GUI window. If you want to open it in the
same window, select the Open SAP GUI as separate window option on the SAP GUI Integration preference page. To do this,
choose the Window Preferences ABAP Development SAP GUI Integration menu.
For more information, look here Running as ABAP Development Object
Merging and Editing Changes in the Compare Editor*
Firstly, you can edit and merge versions of the same development objects in the Compare Editor.
This enables you to adopt individual or all changes, for example, from one system into another or from a previous version into
the inactive version of the object.
Secondly, if you use the new Alt Shift C shortcut, ADT automatically:
1. Evaluates the ABAP project that you selected previously for comparing code versions across ABAP projects.
2. Triggers the compare editor using the evaluated ABAP project.
For more information, look here Comparing Source Code and Comparing Across ABAP Projects (ABAP Systems)
Displaying BAdI De nitions in the Project Explorer
BAdI de nitions are now displayed underneath their enhancement spots in the Project Explorer. This enables you to open, and
directly navigate to, the selected BAdI de nition in the SAP GUI.
Using Accessibility Features in ADT
ADT now provides help content for people with a physical disability, such as restricted mobility or limited vision, or those with
special needs to use its features successfully.
For more information, look here Accessibility Features in ADT
5/7/2023
Refactoring Aids
Correcting Misspelled Variables
You can correct misspelled variables using a quick x if another variable with a similar name exists.
For more information, look here Correcting Misspelled Variables
Correcting an Interface Attribute Access Using an Interface Attribute
You can reuse existing interface members by adding the corresponding interface name and the '~' component selector.
For more information, look here Adding the Interface Name
Correcting an Interface Attribute Access by Generating an Alias
You can generate and reuse an alias from a variable that points to the ~ component selector of an interface.
For more information, look here Generating an Alias
 Version 2.36
 Note

Selecting a Main Program for Multiple-Used ABAP Includes
If you open an ABAP include that is used in several main programs, the following dialog is opened that depends on where the
include is displayed in the node structure of the Project Explorer:
If the main program is not assigned to an include and the include is displayed directly beneath the Include node, the
dialog for selecting a main program is opened as follows:
Dialog for selecting a main program
5/7/2023
Then, from the selection list, you can choose:
a speci c main program where you want to use the include.
<No main program assigned> if you want to keep it open in which main program the include should be used.
If the include node is located beneath the Project Explorer, for example, a function group include, type group, program, in
the selection eld, the corresponding object is already preselected.
If you open the Properties view, the General tab and the Speci c tab are provided. In the Speci c tab your previous selection is
displayed. Here, you can also select a main program from the dropdown list.
Specific tab in the Properties view for selecting a main program
 Note
Now, the selection is valid until you close the include editor.
For more information, look here: Selecting a Main Program for Multiple-Use ABAP Includes

Creating ABAP Projects from an Existing System Connection*
When you create an ABAP project from an existing system connection, the icon of the ABAP project in the Project Explorer is
displayed with a decorator. Because, the project is referencing a system connection in the SAP Logon Pad, a decorator is added
to the project icon . This decorator re ects the connection to the SAP Logon.
For more information, look here: Using a Prede ned System Connection from the SAP Logon
Duplicating an Existing System Connection*
You create an ABAP project from an existing ABAP project in order to modify or reuse the existing system connection.
For more information, look here: Duplicating an Existing System Connection
Jumping between ABAP Projects*
If you are, for example, working on an object in an ABAP project and debugging it at the same object in another project, you can
now directly jump between these projects. For jumping, open the object and select Open in Project from the context menu.
For more information, look here Opening in Another System
Refactoring Aids
Pull-up Members to Superclass
5/7/2023
You can move member de nitions (for example, constants, attributes, methods, types, and events) from a subclass and to its
superclass.
For more information, look here Pull-up Members to Superclass
Pull-up Members to Interface
You can move member de nitions from a class and add them to the implemented interface. To avoid invalidation of existing
usages, aliases are declared.
For more information, look here Pull-up Members to Interface
 Version 2.31
Back end: SAP NetWeaver 7.4 SP08
 Note

Switching Between Inactive and Active Versions of a Source-Based Object
You can toggle between the inactive and active version of any source-based objects such as ABAP classes, function modules, or
programs. This functionality enables you to read the inactive version that is saved by another user and not available in your
working area.
For more information, look here: Switching between Inactive and Active Versions of a Source-based Object
Linking for Displaying ABAP Source Code in a Web Browser
From the context menu in the Project Browser, you can copy the hyperlink of a development object and paste it into an email or
any document. This enables you to create a hyperlink so that the receiver can open the ABAP source code of the development
object in a Web browser.
 Note
Http links are available for the following development objects:
ABAP programs
ABAP includes
ABAP function groups
ABAP function group includes
ABAP function modules
ABAP classes
ABAP interfaces
5/7/2023
For more information, look here: Linking for Displaying ABAP Source Code in a Web Browser
Generating an Email for Sharing Hyperlinks to ABAP Source Code
You want to share a hyperlink to a development object or a part of ABAP source code through an email. To do this, you can now
select Email link in the Share Link dialog. A new email is then generated from your default email client where the hyperlink is
added.
For more information, look here where this functionality is provided for the following functions:
Linking to Open Development Objects in Another ADT Installation
Linking for Displaying ABAP Source Code in a Web Browser
Linking to Selected Parts of ABAP Source Code
Selecting a Main Program for Multiple-Use Include Programs
Typically, an include program is used by exactly one main program. If an include program is used in several main programs, you
need to select a speci c main program in order for the functionality to be executed.
You can now select a speci c main program for a multiple-use include program in the Properties view. Note that this selection is
valid until you close your Eclipse-based IDE.
Whenever a speci c functionality (for example, ABAP syntax check, navigation, and so on) is executed that requires a main
program, but none is selected, a dialog is opened. You then need to select a main program in the Properties view.
For more information, look here: Selecting a Main Program for Multiple-Use ABAP Includes
Element Info
In the Element Info view and Element Info popup, the following details are now displayed:
Texts that are provided for message classes and text elements
If a long text exists for any ABAP function module, a link to the corresponding documentation is provided:
Example of a link that refers to a long text document

Creating ABAP Projects by De ning a Manual System Connection*
You want to de ne the connection of your Eclipse-based IDE to an ABAP system directly without using the SAP Logon Pad. This
enables you to adopt certain properties like the connection type, message server, instance number, and so on.
For more information, look here: De ning a Manual System Connection
Quick Assist View*

The Quick Assist view supports you in executing refactorings and ABAP quick xes, or when generating ABAP source code. It
interacts directly with the ABAP source code editor. At every position where a quick assist can be applied, the content of the
5/7/2023
Quick Assist view is therefore automatically updated according to the selection made.
The layout of the Quick Assist view is divided into the:
Proposal overview that displays the possible quick assists at the current cursor position in the source code.
Description per proposalIn the source code editor, the following other quick assists are now provided for that provides
details about the operating steps of the quick assist that is selected in the Proposal overview.
Previous Result that displays the changes performed by the recently applied quick assist.
From the toolbar, you can execute several operations like applying the selected proposal, disabling link with editor, clearing the
result history, and so on.
Example of a Quick Assist view after executing a quick assist
For more information, look here: Quick Assist View
ABAP Quick Fixes

Creating Local ABAP Classes or ABAP Interfaces from Usage
In the source code of an ABAP program, you can now also create a local ABAP class or interface directly from the name of the
missing class or interface. The creation of global classes is already possible.
For more information, look here: Creating ABAP Classes or ABAP Interfaces from Usage
Other ABAP Quick Assists

Creating and Maintaining Text Symbols
Using a text symbol makes a development object translateable and easier to maintain.
Creating a Text Symbol in the Text Pool to add new text symbols to the text pool
Editing Text Symbols to adopt the text content or text key

5/7/2023
Correcting Inconsistencies Within Text Symbols to adopt changes between the text pool and source code editor
Switching Notations to substitute a fully-quali ed literal of a text symbol with a notation
For more information, look here: Creating and Editing Text Symbols (Quick Assists)
ABAP Searches
Expansion of the Where-Used Functionalities
Now, in the Search view, the number of matches and the development objects that contain at least one match are displayed.
The matches themselves are structured according to ABAP packages, development objects, and the subobjects where the
actual matches are highlighted.
In addition, the following functionalities are provided from the toolbar:
Set a lter for:
ABAP package(s)
Development object type(s)
Responsible user(s)
Code category
Exclusion of indirect references
Navigate to the next or previous match
Expand or collapse a main tree or a subsequent subtree
Show or hide the ABAP package hierarchy
Rerun the search function
Stop the current search
Display or clear data as well as navigate in the search result history
Pin the search view
Display the search result view as a list or tree
From the context menu of a selected development object or element, you can:
Run an ABAP unit test
Search for other usages
For more information, look here:
Where-Used Function
Searching Usages (Where-Used)
In the Search Filter input eld, you can now limit the search for the name of the responsible user provided in table TADIR, eld
AUTHOR.
5/7/2023
For more information, look here: Searching ABAP Source Code
Ensuring Quality of ABAP Code with the ABAP Test Cockpit

ABAP developers have various new options at their disposal for using ATC in ABAP Development Tools. In the current shipment,
they can use ATC in the following use cases:
For more information, look here: Checking Quality of ABAP Code with ATC
1. Running ATC checks during development
Developers run the ATC checks to nd potential bugs already during the development and launching of ATC from their
IDE.
For more information, look here: Working with ATC During Development
2. Running ATC checks during transport release
During the transport release, the ATC implicit check run for all development objects that are included in the transport
request provides the rst Q Gate (quality gate).
For more information, look here: Working with ATC During Transport Release
3. Working with central ATC results from mass regression check runs that have been scheduled in a central quality
system
In the target quality system, the mass regression check runs are scheduled and serve as the nal Q Gate before the code
changes are released.
For more information, look here: Working with Central ATC Results
4. Handling exemptions (false positives) for ATC ndings
ATC tools integrate an exemption process for false positives in order to handle ndings that cannot be cleaned up. In a
separate process, the developer requests an exemption for a nding. The quality manager then approves or rejects the
request.
For more information, look here: Requesting Exemptions for ATC Findings
 Version 2.28
 Note

Creating ABAP Projects by De ning a Manual Server Connection*
It is now possible for you to manually de ne the connection of your Eclipse-based IDE to an ABAP system. This will enable you to
adopt certain properties like the connection type, message server, instance number, and so on. For this, no existing connection
from the SAP Logon Pad is required.
5/7/2023
You can create an individual con guration in the following use cases:
You have installed ABAP Development Tools on a Mac OS X operating system.
You want to work in a user-speci ed system.
You want to connect manually because you do not have con guration les that contain value helps. Otherwise, access
through the SAP Logon Pad would be more laborious.
More on this: De ning a Manual System Connection
 Version 2.24
 Note

Getting Orientation in the Source Code Using Breadcrumbs*
The breadcrumb functionality helps you to orientate yourself and navigate within the source code of a development object. It
provides you with the same structural information as the Outline view.
Displaying siblings of an element in the breadcrumb bar
You can display the breadcrumbs bar in the source code editor of the following source code-based development objects:
5/7/2023
ABAP classes
ABAP interfaces
ABAP programs
ABAP includes
ABAP function group main inlcudes
ABAP function group inlcudes
ABAP function modules
More on this: Getting Orientation in the Source Code Using Breadcrumbs
Getting Support from the Content Assist for Non-Keywords*
Currently, in a source code-based object, the content assist function also proposes non-keywords such as element names or
type de nitions. This enables you to add the corresponding names or de nitions that are already used in this particular
development object. Note that only non-keywords that are already used in the same development object are proposed.
To activate this functionality, select: Window Preferences ABAP Development Editors Source Code Editors Typing
Also suggest non-keywords
More on this: Non-Keyword Completion
Feature Explorer
Learning More About the Features of ABAP Development Tools*
The Feature Explorer is a new interactive view. It provides a tutorial for ABAP programmers who come from the classic ABAP
Workbench and now want to start working with ADT.
Feature Explorer view that provides the entry task
The tutorial is grouped into tours in accordance with the ADT features that are most relevant for your daily work. In addition, a
link to the corresponding help content is provided if you want to learn more about a particular feature. The Feature Explorer
thus makes it easier for you to get used to working with ABAP Development Tools.
 Version 2.19
5/7/2023

Previewing a Message Long Text
In the message class editor, you can display the long text of a message that was added through the back end in an ABAP
project. For this purpose, select the Preview button in the toolbar.
The Long Text Preview window displays the:
message number and short text in the header
long text in the main frame
Example of a Long Text Preview window
Take note of the following prerequisites for executing this function:
Your ABAP project is opened in the original language.
The message is not activated as self-explanatory.
 Note
This function is also available in SAP NetWeaver 7.3 EHP1 SP10.
More on this: Previewing a Message Long Text
Refactoring Aids
Declaring Variables from Usage
5/7/2023
De ning a local variable, attribute, or parameter from its usage
More on this: Declaring Variables from Usage
Declaring Inline Variables Explicitly
Converting local inline declarations of one or several variables into explicit declarations
More on this: Declaring Inline Variables Explicitly
Extracting Parameters from Literals
Creating a new importing parameter for the current method with the literal as default value. This parameter is used instead of
the literal.
More on this: Extracting Constants from Literals
Extracting Local Variables from Expressions
Creating a local variable from an expression
More on this: Extracting Local Variables from Expressions
Converting Local Variables to Parameters
Promoting local variables to a parameter of a method
More on this: Converting Local Variables to Parameters
Assigning a Statement to a New Variable
Declaring a new variable and assigning the result of a statement to this variable
More on this: Assigning a Statement to a New Variable
Extracting Methods from Expressions
Moving an expression to a new method and replace it with the call of a new method
More on this: Extracting Methods from Expressions
Declaring Exceptions from a Raise Statement
Adding an exception to the method signature based on an existing RAISE EXCEPTION statement in the method
implementation
More on this: Propagating an Exception
ABAP Quick Fixes

Creating ABAP Function Modules from Usage
Creating an ABAP function module from the name of the missing repository object. For this purpose, the corresponding creation
wizard is opened.
More on this: Creating ABAP Function Modules from Usage

5/7/2023
Creating ABAP Includes from Usage
Creating an ABAP include from the name of the missing repository object. For this purpose, the corresponding creation wizard is
opened.
More on this: Creating ABAP Includes from Usage
Generating ABAP Source Code

Generating Class Constructor Methods
Creating an empty static class constructor method in the public section of the current ABAP class
More on this: Generating Class Constructor Methods
Generating Constructor Methods
Creating a instance method in the public section of the current ABAP class.
 Note
If the class has attributes, a dialog is opened where you can select the attributes that should be instantiated.
More on this: Generating Constructor Methods
Generating Factory Methods
Creating a static create method in the public section of the current ABAP class
 Note
If the class has attributes, a dialog is opened where you can select the attributes that should be instantiated.
More on this: Generating Factory Methods
ABAP Source Search

The SAP HANA-based ABAP Source Search enables you to nd text that is developed in source-based repository objects (like
classes, programs, function pools) of an ABAP project.
 Note
In order to enable the ABAP code search functionality, your ABAP system must use a SAP HANA database.
More on this: Searching ABAP Source Code
Enhancement with Source Code Plug-ins

Displaying Source Code Plug-ins
In the source code editor of an ABAP class, ABAP program, or an ABAP function group, you can display the source code plug-ins
of the available enhancement implementations in the enhancement popup. If there are several enhancement implementation
5/7/2023
elements available, the hierarchy of the source code plug-ins is displayed in addition.
Source code plug-in marker that highlights an enhancement option in the ruler of the source code editor
Example
The following enhancement popup is displayed if one source code plug-in is added at an enhancement option:
Enhancement popup for a single source code plug-in
More on this: Displaying Source Code Plug-ins
Debugging ABAP Code

Setting ABAP Watchpoints
When debugging ABAP code, you can use watchpoints to track the value of individual ABAP variables. The ABAP debugger stops
as soon as the value of a watched variable has changed. Furthermore, you can specify conditions for watchpoints. The debugger
then additionally checks whether this condition is ful lled.
More on this: Using Watchpoints
Changing Internal Tables
The tables view of the ABAP Debugger has been enhanced to support changing, deleting, and inserting rows in internal tables.
More on this: Analyzing Internal Tables
 Version 2.13
Here is an overview of the most signi cant changes in the context of ABAP core development scenario that relate to the:
Back end: SAP NetWeaver 7.3 EHP1 SP4 vs. SP7 and SAP NetWeaver 7.4 SP00 vs. SP03
 Note
5/7/2023

Automatic Syntax Check*
Now, the ABAP source code editor automatically checks the syntax of a development object you are currently working on.
 Note
The automatic syntax check is activated in the preferences by default.
More on this: Checking ABAP Syntax
Automatic code completion*
Now, the ABAP source code editor automatically triggers the code completion if you enter one of the following component
selectors: -, ~, -> , =>
 Note
The automatic code completion is activated in the preferences by default.
More on this: Getting Support from the Content Assist
Developer and SAP object registration
For registering a developer and manual changes to SAP objects like database procedure proxies, SAP HANA transport
container, external views, Core Date Services (CDS) entities in an ABAP system an access key is required.
More on this:
Registering SAP Objects as a Developer
Modifying Development Objects in the SAP Namespace
Refactoring Aids
Converting local variables to attributes
Moving a de nition of a local variable, type or constant to the private section of the current class. This enables you, to make the
variables available for all methods within an ABAP class. More on this: Converting Locals to Class Members
Declaring inline variables explicitly
Converting inline declarations of one or several variables to a local variable in the corresponding method de nition.More on this:
Declaring Variables from Usage
Changing visibility of members
Moving a member de nition between the public, protected and private section to change its visibility in your source code. More
on this: Changing Visibility of Members
Extracting constants
5/7/2023
In the source code editor, you can now substitute literals with constants in order to:
Create a local constant from a literal to make it available in a certain method. The corresponding literals are replaced
with the added constant.
Create a member constant by extracting a constant to make it available for all methods of an ABAP class. The
corresponding literals are replaced with the added constant.
Reuse an existing constant that has already been declared for the same value.
More on this: Extracting Constants
Extracting variables
In the source code editor, you can substitute literals with variables in order to:
Create and extract a local variable from a literal to make it available in a certain method. The corresponding literals are
replaced with the added variable.
Create and extract an attribute from a variable to make it available for all methods of an ABAP class. The corresponding
literals are replaced with the new attribute.
More on this: Extracting and Converting Variables
ABAP Quick Fixes

Creating method implementations from the method de nition
Generating the implementation part of a method from an existing declaration in the de nition part of an ABAP class
More on this: Creating Method Implementations from the Method De nition
Creating Method De nitions from Implementation Parts
Generating the declaration of a method directly out of the implementation part of the corresponding method of an ABAP class
More on this: Creating Method De nitions from Implementation Parts
Creating Implementation Parts for Unimplemented Methods
In an ABAP class, generating the implementation part of methods that are de ned in an ABAP interface as well as method
stubs of other unimplemented methods More on this: Creating Implementation Parts for Unimplemented Methods
 Note
In SAP NetWeaver 7.0 EHP3 / 7.31, you can only create the implementations for unimplemented interface methods.
In SAP NetWeaver 7.4 and subsequent releases, you can only create the method implementations in certain situations.
Creating Methods from Method Calls
In an ABAP class, generating the missing method de nition and implementation part from the method call
More on this: Creating Methods from Method Calls
Creating classes or interfaces from the source code
5/7/2023
In the source code of an ABAP program, triggering the creation of a global ABAP class or interface directly from the usage of
the missing class or interface
More on this: Creating ABAP Classes or ABAP Interfaces from Usage
Transport Organizer View

Providing source code in another system
Now, the Transport Organizer view is integrated with the basic functions of the SAP GUI-based Transport Organizer. For each
system node, it provides access to the complete object list of the logged-on user. This allows you, to perform the basic
developer operations such as running consistency checks or releasing transport requests and tasks.
Example of a folder structure in the transport organzier view that represents two transport requests
More on this: Transport Organizer
ABAP Doc
Documenting ABAP source code
ABAP doc comments are additional information that can be added or imported to ABAP classes, ABAP interfaces, ABAP
programs, or ABAP function groups. ABAP doc comments are added with ''! in the ABAP source code and can be rendered in the
ABAP element info view or in a tooltip.
Example of an ABAP Doc comment displayed in an ABAP Doc popup
More on this: Editing Comments in ABAP Source Code
ABAP Pro ler

Analyzing call sequence with the Call Timeline tool
5/7/2023
The ABAP Pro ler comes along with a Call Timeline tool, which visualizes the trace events and time consumed in form of a
diagram. In general, the appearance of the trace events in this graphical tool corresponds to those in the Call Tree tool. The
horizontal of the diagram displays the temporal sequence of each trace event measured, whereas the horizontal represents the
call depth within a call hierarchy. In contrast to the Call Tree, the trace events however are represented not as discrete tree
nodes, but as a continuous sequence. The advantage of the new tool is the graphical representation and a quick detection of
eye-catching patterns.
Displaying call stack aggregation
The ABAP Pro ler provides you with a further analysis feature, which is especially relevant for central or framework
components. Starting from the Hit List, you can Display All Executions of a performance hotspot in the list. The resulting view
displays more details for each individual trace event execution. The new property Stack Id allows you to analyze the executions
in relation to their call stack. Furthermore, the context menu action Show Stack Aggregation allows you nd out how, for each
individual stack, the trace event executions are distributed.
5/7/2023
Analyzing database accesses
Whenever the database portion of the overall runtime distribution is (unexpected) high, you may want to nd out, which
database accesses cause it to happen. The Database Accesses tool allows you to identify and analyze the top consumers during
the database accesses. It provides you with a list of tables that are used when running the application in question. In addition,
detailed information for each database access (such as, access type, buffer settings, duration of table accesses) is provided.
More on this: Analyzing Database Accesses
Debugging ABAP Code

Analyzing ABAP exceptions in the debugger
The Variables view of the Debugger now allows you to open an ABAP Exception view to analyze details of a selected ABAP
exception object.
5/7/2023

ABAP Eclipse

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

ABAP Eclipse

Uploaded by

Copyright:

Available Formats

5/7/2023

SAP - ABAP Development User Guide

Original content: https://help.sap.com/docs/ABAP_PLATFORM_NEW/c238d694b825421f940829321ﬀa326a?locale=en-

For more information, please visit the https://help.sap.com/docs/disclaimer.

 List of Development Objects with an Eclipse-based Editor

Core ABAP class SP04 SP02

ABAP function SP04 SP02

ABAP function SP04 SP02

ABAP include SP04 SP02

ABAP interface SP04 SP02

ABAP program SP04 SP02

Message class - SP04

XSLT program - - SP00

Other ABAP ABAP - - - - SP00

ABAP ABAP type - SP08

Database table - - - - SP00

Data element - - SP00

Lock objects - - - - - SP00

Table types - - - - - - SP00

Connectivity ABAP Push - - SP00

SAP HANA Database - SP02

SAP HANA - SP02

Core Data Access control - SP10

Abstract CDS - - - - - SP00

Dynamic cache - - - - - - SP00

BOPF Business SP04 SP02

Business Behavior - - - - - SP00

Service binding - - - - - - SP00

Enterprise Consumer- - SP02

RFC consumer - SP02

Web Dynpro Application SP07 SP02

Application SP07 SP02

Component SP07 SP02

Component SP07 SP02

Custom- SP07 SP02

Floorplan SP04 SP02

Interface view SP07 SP02

View SP07 SP02

Window SP07 SP02

Keyboard Shortcuts for ABAP Development

Activate inactive development object Ctrl + F3

Activate all inactive development objects Ctrl + Shift + F3

Check consistency and syntax Ctrl + F2

Close all Ctrl + Shift + W

Code completion / Content Assist Ctrl + Space

Delete line Ctrl + D

Delete next word Ctrl + Delete

Delete previous word Ctrl + Backspace

Find Next Ctrl + K

Find Previous Ctrl + Shift + K

Format source code (a.k.a. Pretty Printer) Shift + F1

Format source block (a.k.a. Pretty Printer) Ctrl + Shift + F1

Keyword completion Tab

Mark word Double-click

Mark whole line Triple-click

New ABAP development object Ctrl + N

Open quick x / quick assist dialog Ctrl + 1

Rename Alt + Shift + R

Save all Ctrl + Shift + S

Selection to upper case Ctrl + Shift + X

Selection to lower case Ctrl + Shift + Y

Open a development object in other ABAP project(s) Alt + Ctrl + P

Show the properties of the currently focused object or le Shift + Alt + P

Backward navigation to the previous opened tab Alt + Left