The following is an alphabetical classification of the most important generally-released ABAP statements.

Adds two single fields.

The contents of <n> are added to the contents of <m>. The result is placed in <m>. Equivalent of
<m> = <m> + <n>.

Adds sequences of fields.

If <n1>, <n2>,..., <nz> is a sequence of fields with a uniform gap between each, the same type, and the same length, the fields are added together and the result placed in <m>. The variants allow you to restrict the fields to a partial sequence, to include <m> in the sum, or to perform the operation for a sequence of consecutive fields.

Adds components of structures.

Adds together all of the components of structures <struc1> and <struc2> that have identical names, and places the results in the corresponding components of <struc2>.

Defines class-specific alias names for an interface component in ABAP Objects.

Defines <alias> within a class as a synonym for the interface component <intf~comp>.

Appends one or more lines to the end of an index table.

Appends one line <line> or several lines of an internal table <jtab> to the index table <itab>.

Assigns a field to a field symbol.

Assigns the data object <f> to the field symbol <FS>, after which, <FS> points to the data object. The pointed brackets are part of the syntax of the field symbol.

Event keywords for defining event blocks for screen events.

User actions on selection screens or lists trigger events in the ABAP runtime environment. The event keywords define event blocks, which are called when the corresponding event occurs.

Control level change when you process extracts and internal tables in a loop.

These statements are used in control level processing with extract datasets or internal tables. Each introduces a statement block that you must conclude with the ENDAT statement. The statements between AT and ENDAT are executed whenever the corresponding control level change occurs.

Checks the authorization of a user.

The statement checks whether the user has all of the authorizations defined in the authorization object <object>. <name1>,..., <name10> are the authorization fields in the object, and <f1>,... ,<f10> are data objects in the program. The value of each data object is checked against the corresponding authorization field.

Relative positioning for output in a list.

Positions the list output either in the first column of the first line after the page header on the current page, or in the first column of the first line of a line block if you have previously used the RESERVE statement.

Starts the ABAP Debugger.

Interrupts program execution and starts the Debugger. This allows you to test your programs by halting them at any point.

Calls a customer function module.

Similar to CALL FUNCTION. The function module that it calls must be programmed and activated by a customer using the modification concept.

Calls a function module.

CALL FUNCTION <func> [EXPORTING ... f_i = a _i... ]
                     [IMPORTING ... f_i = a _i... ]
                     [CHANGING  ... f_i = a _i... ]
                     [TABLES    ... f_i = a _i... ]
                     [EXCEPTIONS... e_i = r _i... ]
              [DESTINATION <dest>]
              [IN UPDATE TASK]
              [STARTING NEW TASK]
              [IN BACKGOUND TASK].

Starts a function module, either in the same system or in an external system, depending on the type of call that you use. You can also use update function modules in transactions, and call function modules asynchronously. The remaining additions are used for the parameter interface of the function module, in which you can specify actual parameters and determine how to handle exceptions.

Calls a dialog module.

CALL DIALOG <dialog> [AND SKIP FIRST SCREEN]
                     [EXPORTING... f_i = a _i... ]  
                     [IMPORTING... f_i = a _i... ]
                     [USING itab].

Calls the dialog module <dial>. A dialog module is an ABAP program containing a chain of screens. It does not have to be called using a transaction code, and runs in the same SAP LUW as the program that called it. The additions allow you to skip the first screen in the chain and pass actual parameters to and from the parameter interface of the dialog module.

Calls a method in ABAP Objects.

CALL METHOD <meth> [EXPORTING ... <i_i> =.<f _i>... ]
                   [IMPORTING ... <e_i> =.<g _i>... ]
                   [CHANGING  ... <c_i> =.<f _i>... ]
                   [RECEIVING r = h ]
                   [EXCEPTIONS... <e_i> = r _i...     ]

Calls a static method or instance method <meth>. The additions allow you to pass parameters to and from the method and handle its exceptions.

Calls a method in OLE2 Automation.

Calls the method <m> of the OLE2 Automation object <obj>.

Calls a sequence of screens.

Calls the sequence of screens beginning with screen number <scr>. All of the screens in the chain belong to the same ABAP program. The chain ends when a screen has the next screen number 0. The additions allow you to call a single screen as a modal dialog box.

Calls a selection screen.

Calls a user-defined selection screen in a program. Selection screens are processed in the AT SELECTION-SCREEN events. The additions allow you to call a selection screen as a modal dialog box.

Calls a transaction.

Calls the transaction <tcod> while retaining the data in the calling program. At the end of the transaction, control returns to the point from which the transaction was called. The additions allow you to skip the first screen of the transaction or pass an internal table for batch input to it.

Conditional branching.

Opens a CASE control structure that must conclude with the ENDCASE statement. This allows you to branch to various statement blocks (introduced with the WHEN statement), depending on the contents of the data object <f>.

Catches runtime errors.

Conditional termination of a loop pass or a processing block.

If the logical expression <logexp> is true, the program continues at the next statement. If, however, <logexp> is false, the current loop pass terminates and the next begins. If the program is not currently processing a loop, the current processing block terminates. There are special forms of the CHECK statement for use with selection tables and in GET event blocks.

Declares a class in ABAP Objects.

This statement introduces the declaration part of a class <class>. The declaration part concludes with ENDCLASS, and contains the declarations of all components in the class. The PUBLIC addition is generated by the Class Builder, and defines a global class in the class library. The INHERITING FROM addition allows you to derive the class <class> from a superclass <superclass>. The DEFERRED addition declares the class before it is actually defined. The LOAD addition loads a class explicitly from the class library.

Implementation of a class in ABAP Objects.

Introduces the implementation part of a class <class>. This concludes with the ENDCLASS statement, and contains the implementations of all of the methods in the class.

Declares static attributes of a class or interface.

Like DATA. However, the attribute <a> is declared as a static attribute. Static attributes are independent of instances of the class. Only one copy of the attribute exists in the class, and this is shared by all instances.

Declares static methods of a class or interface.

Like METHODS. However, the method <meth> is declared as a static method. A static method can access static attributes, and may only trigger static events.

Declares static events of a class or interface.

Like EVENTS. However, the event <evt> is declared as a static event. Static events are the only events that may be triggered in a static method.

Resets a variable to its initial value.

Resets the variable <f>, which may be of any data type, to the initial value defined for that type.

Closes a file.

Closes a file <dsn> on the application server previously opened with the OPEN DATASET statement.

Closes a database cursor.

Closes a cursor opened using the OPEN CURSOR statement.

Inserts lines into an internal table in summarized form.

The statement first checks whether the internal table contains an entry with the same key. If not, it acts like INSERT. If there is already a table entry with the same key, COLLECT does not insert a new line. Instead, it adds the values from the numeric fields of the work area <line> to the values in the corresponding fields of the existing table entry.

Concludes an SAP LUW.

All database updates are written firmly to the database, and all locks are released. Triggers the database update. The AND WAIT addition allows you to pause the program until the update is complete. If you omit it, the database is updated asynchronously.

Allows communication between programs.

These statements allow you to initialize, start, and accept program-to-program communication, send and receive data between partner programs, and then terminate the connection.

Performs numeric operations.

The result of the mathematical expression in <expression> is assigned to the result field <n>. The COMPUTE keyword is optional.

Combines a series of strings into a single string.

The strings <c1> to <cn> are concatenated, and the result placed in <c>. The SEPARATED BY addition allows you to specify a string <s> to be placed between the strings.

Removes spaces from a string.

Removes all leading spaces, and replaces other series of blanks with a single space in the character field <c>. If you use the NO-GAPS addition, all of the spaces are removed.

Declares constant data objects.

The syntax is similar to DATA, except that the VALUE addition is required, and that internal tables and deep structures cannot be declared as constants. The starting value that you assign in the VALUE addition cannot be changed during the program.

Ends a loop pass.

Only possible within loops. This statement terminates the current loop pass and starts the next.

Declares a context.

CONTEXTS <c>.

Generates an implicit data type CONTEXT_<c>, which you can use to create context instances.

Defines a control.

Defines an ABAP runtime object <ctrl>. This displays data in a particular format on a screen, depending on the type <ctrl_type>. Currently, <ctrl_type> may be a table control or tabstrip control.

Converts a data into an inverted date form.

If <d1> and <d2> are date fields in the internal form YYYYMMDD, the nines complement of <d1> is placed in field <d2> and vice versa. In inverted date format, the most recent date has the smaller numerical value.

Converts a timestamp into the correct date and time for the current time zone.

As long as <tst> has type P(8) or P(11) with 7 decimal placed, and <tz> has type C(6), the time stamp <tst> will be converted to the correct date <d> and time <t> for the time zone <tz>.

Converts a text into a format that can be sorted alphabetically.

<text> must have type C and <x> must have type X. The string is then converted so that the relative order of the characters allows them to be sorted alphabetically in the current text environment.

Creates an object in ABAP Objects.

<cref> must be a reference variable, defined with reference to a class. CREATE OBJECT then creates an object of that class, to which the reference in <cref> then points.

Creates an external object in OLE2 Automation.

If <class> is a class assigned to an automation server, an initial object <obj> of this class is created.

Declares variables with a previously-declared data type.

DATA <f>... [TYPE <type>|LIKE <obj>]... [VALUE <val>].

Declares a variable <f> with the fully-defined data type <type> or the same data type as another data object <obj>. The data type <type> can be D, F, I, T, a type defined locally in the program using the TYPES statement, or a type from the ABAP Dictionary. The data object <obj> is a data object or line of an internal table that has already been defined. The VALUE addition allows you to specify a starting value.

Declares variables by completing the description of a generic type.

DATA <f>[(<length>)] TYPE <type> [DECIMALS <d>]... [VALUE <val>].

DATA <f> TYPE <itab>.

The data type <type> can be C, N, P, or X. In the <length> option, you specify the length of the field. If you do not specify the length, the default value for the data type is used. If <type> is P, you can use the DECIMALS addition to specify a number of decimal places <d>. If you do not specify a number of decimal places, it is set to none. If you do not specify a type, the system uses the default type C.

DATA <f> TYPE <itab>.

The data type <itab> is a standard internal table with generic key. The default key is automatically used in the DATA statement.

Declares variables with data types that only exist as an attribute of the variable.

DATA <f> TYPE REF TO <class>|<interface>.

Declares the variable <f> as a reference variable for the class <class> or the interface <interface>.

DATA: BEGIN OF <structure>,
       ...
        <f_i>...,
       ...
END OF <structure>.

Combines the variables <f_i> to form the structure <structure>. You can address the individual components of a structure by placing a hyphen between the structure name and the component name: <structure>-<f _i>.

DATA <f> TYPE|LIKE <tabkind> OF <linetype> WITH <key>.

Declares the variable <f> as an internal table with the table type <tabkind>, line type <linekind>, and key <key>.

Declares shared data areas in a program.

The variables <f_i> are assigned to a data area <c>, which can be defined in more than one program. These data areas use the same memory addresses for all programs that are loaded into the same internal session.

Defines a macro.

Introduces the definition of the macro <macro>. Each macro must consist of complete ABAP statement and be concluded with the END-OF-DEFINITION statement.

Deletes files on the application server.

Deletes the file <dsn> from the file system of the application server.

Deletes entries from database tables.

Deletes all of the lines from the database table <dbtab> that satisfy the WHERE condition.

DELETE <dbtab> FROM <wa>.

DELETE <dbtab> FROM TABLE <itab>.

Deletes the lines with the same primary key as the work area <wa>, or all of the lines from the database table with the same primary key as one of the lines in the internal table <itab>. The work area <wa> or the lines of the internal table <itab> must be at least as long as the primary key of the database table and have the same alignment.

Deletes data clusters from cluster database tables.

DELETE FROM DATABASE <dbtab>(<ar>) ID <key>.

Deletes the entire data cluster from the area <ar> with the name <key> from the cluster database table <dbtab>.

Deletes data clusters from the cross-transaction application buffer.

DELETE FROM SHARED BUFFER <dbtab>(<ar>) ID <key>.

Deletes the data cluster for the area <ar> with the name <key> stored in the cross-transaction application buffer for the table <dbtab>.

Deletes lines from internal tables of any type.

DELETE TABLE <itab> FROM <wa>.

DELETE TABLE <itab> WITH TABLE KEY <k₁> = <f ₁>... <k _n> = <f _n>.

Deletion using the table key: All lines with the same key are deleted. The key values are taken either from a compatible work area <wa> or specified explicitly.

DELETE <itab> WHERE <cond>.

Deletion using a condition: Deletes all table entries that satisfy the logical expression <cond>. The logical condition may consist of more than one expression. However, the first operand in each expression must be a component of the line structure.

DELETE ADJACENT DUPLICATE ENTRIES FROM <itab> [COMPARING... ].

Deletes adjacent duplicate entries, either by comparing the key fields or the comparison fields specified explicitly in the COMPARING addition.

Deletes lines from index tables.

DELETE <itab> [INDEX <idx>].

If you use the INDEX option, deletes the line with the index <idx> from the table <itab>. If you do not use the INDEX option, the statement can only be used within a LOOP … ENDLOOP construction. In this case, it deletes the current line.

DELETE <itab> [FROM <n₁>] [TO <n ₂>] [WHERE <cond>].

Retrieves values from a context instance.

DEMAND <val₁> = <f ₁>... <val _n> = <f _n> FROM CONTEXT <inst>
                                        [MESSAGES INTO <itab>].

Fills the fields <f_n> with the values <val _n> of the context instance <inst>. The MESSAGES addition allows you to control how messages from the context are handled in the program.

Determines the distance between two fields.

Writes the distance in bytes between fields <f1> and <f2> to <f3>, always including the length of the field that occurs first in memory.

Describes the attributes of a field.

DESCRIBE FIELD <f> [LENGTH <l>] [TYPE <t> [COMPONENTS <n>]]
                   [OUTPUT-LENGTH <o>] [DECIMALS <d>]
                   [EDIT MASK <m>] [HELP-ID <h>].

The attributes of the data object <f> named in the additions to the statement are placed in the corresponding variables. You can use any number of additions in a single statement.

Describes the attributes of a list.

Depending on the variant of the statement that you use, writes the number of lines, number of pages, a line of a list on a given page, or various attributes of a page to variables.

Describes the attributes of an internal table.

Depending on the additions you use, writes the number of lines occupied, the value specified for the INITIAL SIZE of the table, or the table type into a corresponding variable.

Divides one field by another.

Divides the content of <n> by <m>, and places the result in <n>. The equivalent of n = n / m.

Divides matching components of structures.

Divides all matching components of the structures <struc1> and <struc2> and places the results into the corresponding components of <struc1>.

Introduces a loop.

DO [<n> TIMES] [VARYING <f> FROM <f1> NEXT <f2>].

Introduces a statement block that must conclude with ENDDO. If you omit the TIMES addition, the statement block is repeated until a termination statement such as CHECK or EXIT occurs. The TIMES addition restricts the number of loop passes to <n>. The VARYING addition allows you to process a sequence of fields the same distance apart in memory.

Loads an ABAP program or internal table into a text editor.

Loads the internal table <itab> or the program <prog> into a text editor, where you can edit it using standard editor functions.

Introduces a statement block in an IF control structure.

If the logical expression in an IF statement is false, ELSE introduces the statement block to be executed instead.

Introduces a statement block in an IF control structure.

If the logical expression in the preceding IF is false and <logexp> is true, ELSEIF introduces the statement block that will be executed.

Concludes a macro definition.

This statement concludes a macro definition introduced with DEFINITION.

Event keyword for defining an event block for a list event.

Whenever the page footer is reached while a list is being created, the runtime environment triggers the END-OF-PAGE event, and the corresponding event block is executed.

Event keyword for defining an event block for a reporting event.

Once a logical database has read all of the required lines and passed them to the executable program, the runtime environment triggers the END-OF-SELECTION event, and the corresponding event block is executed.

Concludes a statement block in control level processing.

The statement concludes a control level processing block introduced with the AT statement.

Concludes a CASE control structure.

This statement concludes a control structure introduced with the CASE statement.

Concludes a CATCH area.

ENDCATCH.

The statement concludes an exception handling area introduced with CATCH.

Concludes a class definition.

ENDCLASS.

This statement concludes a class declaration or implementation introduced with CLASS.

Concludes a DO loop.

This statement concludes a loop introduced with DO.

Concludes a Native SQL statement.

This statement concludes a Native SQL statement introduced with EXEC SQL.

Concludes a subroutine.

This statement concludes a subroutine definition introduced with FORM.

Concludes a function module.

This statement concludes a function module introduced with FUNCTION.

Concludes an IF control structure.

This statement concludes a control structure introduced using IF.

Concludes an interface definition.

This statement concludes an interface definition introduced with INTERFACE.

Concludes a loop.

This statement concludes a loop introduced with LOOP.

Concludes a method.

This statement concludes a method implementation introduced with METHOD.

Concludes a dialog module.

This statement concludes a dialog module introduced with MODULE.

Concludes a conditional statement block.

This statement concludes a conditional statement block introduced with ON CHANGE.

Concludes a PROVIDE loop.

This statement concludes a loop introduced with PROVIDE.

Concludes a SELECT loop.

This statement concludes a loop introduced with SELECT.

Concludes a WHILE loop.

This statement concludes a loop introduced with WHILE.

Defines events in classes or interfaces.

EVENTS <evt> EXPORTING.. VALUE(<e_i>) TYPE type [OPTIONAL]...

The event <evt> can be declared in the declaration part of a class or within an interface definition, and may have EXPORTING parameters that are passed to the event handler. The parameters are always passed by value.

Introduces a Native SQL statement.

Between EXEC SQL and the ENDEXEC statement, you can include a database-specific Native SQL statement. The PERFORMING addition allows you to pass a multiple-line selection line by line to a subroutine.

Terminates a loop or processing block.

Within a loop: The entire loop is terminated, and processing continues with the first statement following the loop.

Outside a loop: Terminates the current processing block.

In a reporting event: Jumps directly to the output list.

Ends a step loop.

Terminates step loop processing. A step loop is a way of displaying a table on a screen.

Terminates Native SQL processing.

This statement may occur within a subroutine called using the PERFORMING addition in the EXEC SQL statement. The entire subroutine is processed, but no more subsequent lines of the selection are processed.

Exports a data cluster.

EXPORT... <f_i> [FROM <g _i>]... | (<itab>)
       TO  MEMORY
         | DATABASE <dbtab>(<ar>) ID(<key>)
         | SHARED BUFFER <dbtab>(<ar>) ID(<key>).

The data objects <f_i> or <g _i>, or the data objects in the internal table <itab> are stored as a data cluster in the cross-program ABAP memory of the current internal session, in a cluster database table <dbtab>, or in the cross-transaction application buffer of the table <dbtab>.

Creates an extract dataset and adds lines to it.

The first EXTRACT statement in a program creates an extract dataset and adds the first entry to it. Each subsequent EXTRACT statement adds a new entry. Each extract entry contains the fields of the field group <fg> and, at the beginning, the fields of the field group HEADER as a sort key.

Uses a cursor to read entries from a database table.

If the cursor <c> is linked with a selection in a database table, FETCH writes the next line of the selection into the flat target area <target>.

Declares a field group for an extract dataset.

Declares the field group <fg>. Field groups define the line structure of an extract dataset. You can define a special field group called HEADER as the sort key. When you fill the extract dataset, the HEADER field group precedes each entry.

Declares a field symbol.

FIELD-SYMBOLS <FS> [<type>|STRUCTURE <s> DEFAULT <wa>].

Field symbols are placeholders or symbolic names for fields. The pointed brackets in the name of a field symbol are part of its syntax. The <type> addition allows you to specify a type. The STRUCTURE addition imposes a structure on the data object assigned to the field symbol.

Defines a subroutine.

FORM <subr> [USING  ... [VALUE(]<p_i>[)] [TYPE <t>|LIKE <f>]... ]
            [CHANGING... [VALUE(]<p_i>[)] [TYPE <t>|LIKE <f>]... ].

Introduces a subroutine <form>. The USING and CHANGING additions define the parameter interface. The subroutine definition is concluded with the ENDFORM statement.

Sets formatting options for list output.

FORMAT... <option_i> [ON|OFF]...

The formatting options <option_i> (color, for example) apply to all subsequent list output until they are disabled with the OFF option.

Releases memory space.

This statement deletes an internal table, a data cluster in ABAP memory, or an external object in OLE2 Automation, depending on the form of the statement used. It also releases the memory occupied by the object.

Defines a function module.

Introduces the function module <func>. This statement does not have to be entered in the ABAP Editor, but is automatically generated by the Function Builder in the ABAP Workbench. The function module definition is concluded with the ENDFUNCTION statement.

Introduces a function group.

The first statement in a function group. This statement does not have to be entered by hand, but is generated automatically by the Function Builder in the ABAP Workbench. A function group is an ABAP program that contains function modules.

Event keyword that defines event blocks for reporting events.

GET <node> [FIELDS <f₁> <f ₂>...].

Only occurs in executable programs. When the logical database has passed a line of the node <node> to the program, the runtime environment triggers the GET event, and the corresponding event block is executed. The FIELDS addition allows you to specify explicitly the columns of the node that the logical database should retrieve.

Reads an individual bit.

Reads the bit at position <n> of the hexadecimal field <f> into the field <b>.

Determines the cursor position on a screen or in an interactive list event.

GET CURSOR FIELD <f> [OFFSET <off>]
                     [LINE <lin>]
                     [VALUE <val>]
                     [LENGTH <len>].

GET CURSOR LINE <lin> [OFFSET <off>]
                      [VALUE <val>]
                      [LENGTH <len>].

At a user action on a list or screen, the statement writes the position, value, and displayed length of a field or line into the corresponding variables.

Finds out the current text environment.

Returns the current language, country ID and any modifier into the corresponding variables.

Finds out the value of a SPA/GPA parameter.

Places the value of the SPA/GPA parameter <pid> from the user-specific SAP memory into the variable <f>.

Finds out the current GUI status.

Returns the name of the current GUI status (the same as SY-PFKEY) into the variable <f>. The PROGRAM addition writes the name of the ABAP program to which the status belongs into the variable <prog>. The EXCLUDING addition returns a list of all currently inactive function codes into the internal table <itab>.

Finds out a property of an OLE2 Automation object.

Returns the property <p> of an external OLE2 Automation object to the variable <f>.

Measures the runtime in microseconds.

The first time the statement is executed, the variable <f> is set to zero. In each further call, the runtime since the first call is written to <f>.

Synchronizes the time.

Refreshes the system fields SY-UZEIT, SY-DATUM, SY-TIMLO, SY-DATLO, and SY-ZONLO. If you use the FIELD addition, the variable <f> is filled with the current time.

Returns a time stamp.

Returns the short or long form of the current date and time, depending on whether the variable <f> has the type P(8) or P(11). The long form returns the time correct to seven decimal places.

Stores information about list lines.

During list creation, this statement stores the contents of the field <f> and the current line number in the internal HIDE area. When the cursor is positioned on a line in an interactive list event, the stored value is returned to the field <f>.

Conditional branching.

Introduces a new branch.

Opens an IF control structure that must be concluded with ENDIF. The system evaluates the logical expression <logexp>, and processes different statement blocks depending on the result.

Imports a data cluster.

IMPORT... <f_i> [TO <g _i>]... | (<itab>)
       FROM  MEMORY
           | DATABASE <dbtab>(<ar>) ID(<key>)
           | SHARED BUFFER <dbtab>(<ar>) ID(<key>).

The data objects <f_i> or the objects listed in the table <itab> are written from data clusters in the cross-program ABAP memory of the current internal session, a cluster database table <dbtab>, or the cross-transaction application buffer of the table <dbtab> into the variables <f _i> or <g _i>.

Creates the directory of a data cluster from a cluster database.

IMPORT DIRECTORY INTO <itab>
       FROM DATABASE <dbtab>(<ar>)
       Id <key>.

The statement creates a directory of the data objects in a data cluster of the cluster database <dbtab> and writes it to the internal table <itab>.

In the third variant, the table <itab> contains a directory of the objects stored using EXPORT TO DATABASE.

Inserts an include program in another program.

This has the same effect as inserting the source code of the include program <incl> at the same position in the program as the INCLUDE statement. Includes are not loaded dynamically at runtime, but are automatically expanded when the program is loaded. An include must have the program type I.

Includes a structure within another.

Adopts the structure of an ABAP Dictionary structure <s> or a structured data type <t> as part of a new structure declared using DATA BEGIN OF …

Event keyword that defines an event block for a reporting event.

Only occurs in executable programs. The ABAP runtime environment triggers the INITIALIZATION event before the selection screen is processed, at which point the corresponding event block is processed.

Inserts lines into a database table.

INSERT <dbtab> FROM <wa>.

INSERT <dbtab> FROM TABLE <itab> [ACCEPTING DUPLICATE KEYS].

Inserts one line from the work area <wa> or several lines from the internal table <itab> into the database table <dbtab>. The addition ACCEPTING DUPLICATE KEYS prevents a runtime error from occurring if two entries have the same primary key. Instead, it merely discards the duplicate.

Defines the structure of field groups for extract datasets.

INSERT <f₁>... <f _n> INTO <fg>.

Includes the fields <f_i> in the field group <fg>, thus defining a line structure for an extract dataset.

Inserts lines in an internal table of any type.

INSERT <line>|LINES OF <jtab> [FROM <n₁>] [TO <n ₂>]
       INTO TABLE <itab>.

Inserts a line <line> or a set of lines from the internal table <jtab> into the internal table <itab>. If <jtab> is an index table, you can use the FROM and TO additions to restrict the lines inserted.

Inserts lines in index tables.

INSERT <line>|LINES OF <jtab> [FROM <n₁>] [TO <n ₂>]
  INTO <itab> [INDEX <idx>].

Inserts a line <line> or a set of lines from an internal table <jtab> into the internal table <itab> before the line with the index <idx>. If <jtab> is an index table, you can restrict the lines to be inserted using the FROM and TO additions. If you omit the INDEX addition, you can only use the statement within a LOOP construction. In this case, the new line is inserted before the current line.

Inserts ABAP programs into the program library.

INSERT REPORT <prog> FROM <itab>.

The lines of the internal table <itab> are added to the program library as the program <prog>.

Defines an interface in ABAP Objects.

Introduces the definition of the interface <interface>. The definition concludes with ENDINTERFACE, and contains the declaration of all of the components in the interface. You can use the DEFERRED addition to declare the interface before you actually define it. The LOAD addition loads the interface definition explicitly from the class library.

Implements interfaces in a class.

Used in a class declaration: This statement adds the components of the interface to the existing class definition.

Used in an interface definition: Forms a compound interface.

Leaves a screen.

Terminates the current screen and calls the next screen. The next screen can either be defined statically in the screen attributes or set dynamically using the SET SCREEN statement.

Terminates the current screen and calls the dynamically-defined next screen <scr>.

Switches between screen and list processing.

This statement allows you to create and display a list while processing a series of screens. The addition allows you to specify the next screen (to which you return after the list has been displayed). If you do not use the addition, screen processing resumes with the PBO of the current screen.

Allows you to switch back explicitly from list processing to screen processing.

Terminates an ABAP program.

Terminates the current program and returns to the point from which it was called.

Terminates the current program and starts a new transaction <tcod>. The addition allows you to skip the initial screen of the transaction.

Protects global data against changes.

Only occurs in subroutines. When the subroutine starts, the value of <f> is stored temporarily, and restored to the variable <f> at the end of the subroutine.

Starts a loop through an extract dataset.

Loops through an extract dataset. The loop is concluded with ENDLOOP. When the LOOP statement is executed, the system finishes creating the extract dataset, and loops through all of its entries. One entry is read in each loop pass. The values of the extracted data are placed in the output fields of the field group within the loop.

Starts a loop through an internal table.

LOOP AT <itab> INTO <wa> WHERE <logexp>.

LOOP AT <itab> ASSIGNING <FS> WHERE <logexp>.

LOOP AT <itab> TRANSPORTING NO FIELDS WHERE <logexp>.

Loops through an internal table. The loop is concluded with ENDLOOP. If the logical expression <logexp> is true, the current line contents are either placed in the work area <wa>, assigned to the field symbol <FS>, or not assigned at all. The first operand in each part of <logexp> must be a component of the internal table. The pointed brackets in the field symbol name are part of its syntax.

With index tables, you can use the additions FROM <n> and TO <n> to restrict the lines that are read by specifying an index range.

Starts a loop through the special table SCREEN.

Similar to a loop through an internal table. The system table SCREEN contains the names and attributes of all of the fields on the current screen.

Outputs a message.

Outputs the message <nnn> of message class <mid> as message type <x>. The message type determines how the message is displayed, and how the program reacts. The WITH addition allows you to fill placeholders in the message text. The RAISING addition in function modules and methods allows you to terminate the procedure and trigger the exception <exception>.

Introduces the implementation of a method in a class.

Only occurs in the implementation part of classes. This statement begins a statement block that must be concluded with ENDMETHOD. You do not have to specify any interface parameters, since these are defined in the method declaration.

Declares methods in classes and interfaces.

METHODS <meth>
        IMPORTING... [VALUE(]<i_i>[)] TYPE <t> [OPTIONAL]...
        EXPORTING... [VALUE(]<e_i>[)] TYPE <t> [OPTIONAL]...
        CHANGING ... [VALUE(]<c_i>[)] TYPE <t> [OPTIONAL]...
        RETURNING VALUE(<r>)
        EXCEPTIONS       ... <e_i>...

Declares a method <meth> in the declaration part of a class or in an interface definition. The additions define the parameter interface and exceptions of the method. The function of the method must be implemented using the METHOD statement.

Inserts or changes lines in database tables.

MODIFY <dbtab> FROM <wa>.

MODIFY <dbtab> FROM TABLE <itab>.

Works like INSERT for database tables if there is not yet a line in the table with the same primary key. Works like UPDATE if a line already exists with the same primary key.

Changes the contents of lines in any type of internal table.

MODIFY TABLE <itab> FROM <wa> [TRANSPORTING <f₁> <f ₂>...].

Copies the work area <wa> into the line of the internal table with the same table key as <wa>. You can use the TRANSPORTING addition to specify the exact components that you want to change.

MODIFY <itab> FROM <wa> TRANSPORTING <f₁> <f ₂>... WHERE <logexp>.

Copies the work area <wa> into the lines of the internal table for which the logical expression is true. The first operand in each comparison of the logical expression must be a component of the line structure.

Changes the contents of lines in index tables.

MODIFY <itab> FROM <wa> [INDEX <idx>] [TRANSPORTING <f₁> <f ₂>...].

Copies the work area <wa> into the line of the internal table with index <idx>. If you omit the INDEX addition, you can only use the statement within a LOOP. This changes the current line.

Changes a line of a list.

MODIFY LINE <n> [INDEX <idx>] [OF CURRENT PAGE|OF PAGE <p>]
      |CURRENT LINE
      LINE FORMAT <option1> <option2>...
      FIELD VALUE <f1> [FROM <g1>] <f2> [FROM <g2>]...
      FIELD FORMAT <f1> <options1> <f2> <options2>

Changes either line <n> on the current or specified list (or page), or the last line to be chosen. The exact nature of the change is specified in the additions.

Changes the table SCREEN.

Like changing an internal table. This statement allows you to change the attributes of fields on the current screen.

Introduces a dialog module.

Introduces the dialog module <mod>. The OUTPUT and INPUT additions designate the module as a PBO or PAI module respectively. Each module must conclude with the ENDMODULE statement.

Assigns values.

Assigns the contents of the data object <f1> to the variable <f2>, with automatic type conversion if necessary. Equivalent to <f2> = <f1>.

Assigns values between identically-named components of structures.

The contents of the components of the structure <struc1> are assigned to the identically-named components of the structure <struc2>.

Multiplies two individual fields.

The contents of <n> are multiplied by the contents of <m>, and the result is placed in <m>. Equivalent is M = m * n.

Multiplies components of structures.

Multiplies all of the identically-named components of <struc1> and <struc2> and places the results in the components in <struc1>.

Inserts a line break in a list.

Positions the list output on a new line. The NO-SCROLLING addition locks the line against horizontal scrolling. To lift the lock, use the SCROLLING addition.

Inserts a page break in a list.

Generates a new page and positions the list output after the page header. The additions control how the page header is displayed, the length and width of the page, and the print output.

Declares an interface work area.

Declares a variable with the same data type and the same name as a data type from the ABAP Dictionary. Structures in main programs and subroutines declared with nodes use a common data area. This statement is used in conjunction with logical databases.

Introduces a branch.

Opens an ON control structure, concluded with ENDON. The statement block is executed whenever the contents of the field <f> or one of the other fields <fi> has changed since the statement was last executed.

Opens a database cursor.

OPEN CURSOR [WITH HOLD] <c> FOR SELECT      <result>
                                  FROM      <source>
                                  [WHERE    <condition>]
                                  [GROUP BY <fields>]
                                  [HAVING   <cond>]
                                  [ORDER BY <fields>].

Opens a cursor <c> with type CURSOR for a SELECT statement. All of the clauses of the SELECT statement apart from the INTO clause can be used. The INTO clause is set in the FETCH statement. If you use the WITH HOLD addition, the cursor is not closed when a database commit occurs.

Opens a file.

Opens a file <dsn> on the application server. The additions determine whether the file is for reading or writing, whether the contents are to be interpreted in binary or character form, the position in the file, the location to which an operating system can be written, and allow you to execute an operating system command.

Overlays a character string with another.

All of the characters in field <c1> that occur in <str> are overlaid with the contents of <c2>. <c2> remains unchanged. If you omit the ONLY <str> addition, all positions in <c1> containing spaces are overwritten.

Converts type C variables into type P.

Packs the string <f> and places it in the field <g>. This can be reversed with the UNPACK statement.

Declares parameters for a selection screen.

Declares a variable <p>, as in the DATA statement. However, the PARAMETERS statement also creates an input field for <p> on the relevant selection screen. You can use the additions to define default values, accept lowercase input, define the field as required, check values, define a checkbox or radio button, prevent the field from being displayed on the selection screen, or modify the field.

Calls a subroutine.

PERFORM    <subr>
        |  <subr>(<prog>) [IF FOUND]
        |(<fsubr>)[IN PROGRAM (<fprog>)][IF FOUND]
        [USING  ... <p_i>... ]
        [CHANGING... <p_i>... ]
        [ON COMMIT].

Calls an internal or external subroutine <subr> or the subroutine whose name occurs in the <fsubr> field. The external program is <prog> or the name contained in <fprog>. The IF FOUND addition prevents a runtime error from occurring if the subroutine does not exist. You must use the USING and CHANGING additions to supply values to the interface parameters of the subroutine. The ON COMMIT addition delays the execution of the subroutine until the next COMMIT WORK statement.

Absolute positioning of the output on a list.

Positions the list output in column <col>.

Specifies the print format.

PRINT-CONTROL <formats> [LINE <lin>] [POSITION <col>].

Sets the print format starting either at the current list position or at line <lin> and column <col>.

Creates index lines in the spool file.

Writes the contents of the field <f> into an index line at the end of the current print line. The index line is not printed. In optical archiving, the spool system separates the lists into a data file and a description file containing the index lines.

Defines the private section of a class.

Introduces the declaration of all of the components of a class that are only visible in the class itself.

Introduces a program.

The first statement in some ABAP programs. Equivalent of REPORT.

Defines the protected section of a class.

Introduces the declaration of all of the components of a class that are only visible in the class and its subclasses.

Loops through internal tables at given intervals.

The contents of the specified fields of the internal tables <itab1> … <itabn> are placed in their header lines. Then, the processing block between PROVIDE and ENDPROVIDE is executed for each interval.

Defines the public section of a class.

Introduces the declaration of all components of a class that are visible in the class, its subclasses, and for all users.

Triggers a GET event.

Only occurs in logical databases. Branches the program flow according to the structure of the logical database.

Triggers an exception.

Only occurs in function modules and methods. Terminates the procedure and triggers the exception <except>.

Triggers an event in ABAP Objects.

Only occurs in methods. The event <evt> is triggered, and this calls all of the handler methods registered for it.

Declares a RANGES table.

Declares a RANGES table for the field <f>. RANGES tables have the same data type as a selection table, but they do not have input fields on a selection screen.

Reads a file.

READ DATASET <dsn> INTO <f> [LENGTH <len>].

Reads the contents of the file <dsn> on the application server to the variable <f>. The number of bytes transferred can be written to <len>.

Reads a line from any internal table.

READ TABLE <itab>  FROM <wa>
                  |WITH TABLE KEY <k1> = <f1>... <kn> = <fn>
                  |WITH KEY = <f>
                  |WITH KEY <k1> = <f1>... <kn> = <fn>
      INTO <wa> [COMPARING <f1> <f2>... |ALL FIELDS]
                [TRANSPORTING <f1> <f2>... |ALL FIELDS|NO FIELDS]
     |ASSIGNING <FS>.

This statement reads either the line of the internal table with the same key as specified in the work area <wa>, the line with the key specified in the TABLE KEY addition, the line that corresponds fully to <f>, or the one corresponding to the freely-defined key in the KEY addition. The contents of the line are either written to the work area <wa>, or the line is assigned to the field symbol <FS>. If you assign the line to a work area, you can compare field contents and specify the fields that you want to transport.

Reads a line of an index table.

READ TABLE <itab> INDEX <idx> INTO <wa>... | ASSIGNING <FS>.

Reads the line with the index <idx>. The result is available as described above.

Reads the contents of a line from a list.

READ LINE  <n> [INDEX <idx>] [OF CURRENT PAGE|OF PAGE <p>]
          |CURRENT LINE
          [FIELD VALUE <f1> [INTO <g1>]... <fn> [INTO <gn>]].

Reads either the line <n> on the current or specified list or page, or the last line to have been selected by the user. The addition specifies the fields that you want to read, and the target fields into which they should be placed. The entire line is always placed in the system field SY-LISEL, and the HIDE area is filled for the line.

Reads ABAP programs from the program library.

READ REPORT <prog> INTO <itab>.

Copies the lines of the program <prog> into the internal table <itab>.

Receives results from an asynchronous function module call.

Occurs in special subroutines to receive IMPORTING and TABLES parameters from function modules called using the STARTING NEW TASK addition.

Initializes an internal table.

Resets the internal table <itab> to its initial value, that is, deletes all of its lines.

Initializes a control.

The control <ctrl> defined in the CONTROLS statement is reset with the initial values specified for screen <scr>.

Terminates a GET processing block.

Stops processing the current line of the node of the logical database. If you specify <dbtab>, the logical database reads the next line of the node <dbtab>, otherwise the next line of the current node.

Replaces strings in fields with another string.

This statement searches the first occurrence of the first <l> characters of the search pattern <str1> in field <c> and replaces them with the string <str2>.

Introduces a program.

This is the first statement within certain ABAP programs. <rep> can be any name you choose. The addition MESSAGE-ID specifies a message class to be used in the program. The DEFINING DATABASE addition defines the program as the database program of the logical database <ldb>. The other options are formatting specifications for the default list of the program.

Conditional page break in a list.

Executes a page break on the current page if less than <n> lines are free between the current line and the page footer.

Undoes the changes in a SAP LUW.

Undoes all changes within a database LUW to the beginning of the LUW. The registered update modules are not executed, and the record entry is deleted from table VBLOG.

Scrolls in a list.

SCROLL LIST FORWARD|BACKWARD [INDEX <idx>].

SCROLL LIST TO FIRST PAGE|LAST PAGE|PAGE <pag>
            [INDEX <idx>] [LINE <lin>].

SCROLL LIST LEFT|RIGHT [BY <n> PLACES] [INDEX <idx>].

SCROLL LIST TO COLUMN <col> [INDEX <idx>].

Positions the current list or the list level <idx> in accordance with the additions specified. You can scroll by window, page, columns, or to the left- or right-hand edge of the list.

Searches for a string.

Searches the field <f> or the table <itab> for the string in field <g>. The result is placed in the system field SY-FDPOS. The additions allow you to hide intermediate characters, search from and to a particular position, and convert the found string into uppercase.

Reads data from the database.

SELECT <result>
  INTO <target>
  FROM <source>
  [WHERE <condition>]
  [GROUP BY <fields>]
  [HAVING <cond>]
  [ORDER BY <fields>].

The SELECT statement consists of a series of clauses, each of which fulfils a certain task:

Defines the structure of the selection.

SELECT [SINGLE]|[DISTINCT]
       * | <s_i> [AS <a _i>]... <agg>( [DISTINCT] <s _j>) [AS <a _j>]...

The selection can be a single line SINGLE or a series of lines. You can eliminate duplicate lines using the DISTINCT addition. To select the entire line, use *, otherwise, you can specify individual columns <s_i>. For individual columns, you can use aggregate functions <agg>, and assign alternative column names <a _i>.

Defines the target area into which the selection from the SELECT clause is to be placed.

...  INTO [CORRESPONDING FIELDS OF] <wa>
   | INTO|APPENDING [CORRESPONDING FIELDS OF] TABLE <itab>
                                             [PACKAGE SIZE <n>]
   | INTO (<f₁>, <f ₂>,...)

The target area can be a flat work area <wa>, an internal table <itab>, or a list of fields <f_i>. If you use the CORRESPONDING FIELDS addition, data is only selected if there is an identically-named field in the target area. If you use APPENDING instead of INTO, the data is appended to an internal table instead of overwriting the existing contents. PACKAGE SIZE allows you to overwrite or extend the internal table in a series of packages. The data type of the target area must be appropriate for the selection in the SELECT clause.

Specifies the database tables from which the data in the selection in the SELECT clause is to be read.

... FROM [<tab> [INNER]|LEFT [OUTER] JOIN] <dbtab> [AS <alias>]
                               [ON <cond>]
         [CLIENT SPECIFIED]
         [BYPASSING BUFFER]
         [UP TO <n> ROWS]

You can read a single table <dbtab> or more than one table, using inner and outer joins to link tables with conditions <cond>, where <tab> is a single table or itself a join condition. You can specify individual database tables either statically or dynamically, and you can replace their names with an alternative <alias>. You can bypass automatic client handling with the CLIENT SPECIFIED addition, and SAP buffering with BYPASSING BUFFER. You can also restrict the number of lines read from the table using the UP TO <n> ROWS addition.

Restricts the number of lines selected.

... [FOR ALL ENTRIES IN <itab>] WHERE <cond>

The condition <cond> may contain one or more comparisons, tests for belonging to intervals, value list checks, subqueries, selection table queries or null value checks, all linked with AND, OR, and NOT. If you use the FOR ALL ENTRIES addition, the condition <cond> is checked for each line of the internal table <itab> as long as <cond> contains a field of the internal table as an operand. For each line of the internal table, the lines from the database table meeting the condition are selected. The result set is the union of the individual selections resulting from each line.

Groups lines in the selection

... GROUP BY <s₁> <s ₂>

Groups lines with the same contents in the specified columns. Uses aggregate functions for all other columns in each group. All columns listed in the SELECT clause that do not appear in the GROUP BY addition must be specified in aggregate expressions.

Restricts the number of line groups.

... HAVING <cond>

Like the WHERE clause, but can only be used in conjunction with a GROUP BY clause. Applies conditions to aggregate expressions to reduce the number of groups selected.

Sorts the lines in the selection.

... ORDER BY PRIMARY KEY |... <s_i> [ASCENDING|DESCENDING]...

Sorts the selection in ascending or descending order according to the primary key or the contents of the fields listed.

Declares selection criteria for a selection screen.

Declares a selection table <sel> for the field <f>, and also places input fields on the corresponding selection screen. The additions allow you to set a default value, accept input in lowercase, define a required field, suppress or modify the display on the selection screen, restrict the selection table to a line or a selection to a single field, or prevent input from being passed to a logical database.

Formats a selection screen.

SELECTION-SCREEN SKIP [<n>].

SELECTION-SCREEN ULINE [[/]<pos(len)>] [MODIF ID <key>].

SELECTION-SCREEN COMMENT [/]<pos(len)> <comm> [FOR FIELD <f>]
                                              [MODIF ID <key>].

SELECTION-SCREEN BEGIN OF LINE.
 ...
SELECTION-SCREEN END OF LINE.

SELECTION-SCREEN BEGIN OF BLOCK <block>
                                [WITH FRAME [TITLE <title>]]
                                [NO INTERVALS].
 ...
SELECTION-SCREEN END OF BLOCK <block>.

SELECTION-SCREEN FUNCTION KEY <i>.

SELECTION SCREEN PUSHBUTTON [/]<pos(len)> <push>
                            USER-COMMAND <ucom> [MODIF ID <key>].

Allows you to insert blank lines, lines and comments, group input fields together in lines and blocks, and create pushbuttons.

Defines selection screens.

SELECTION-SCREEN BEGIN OF <numb> [TITLE <tit>] [AS WINDOW].
 ...
SELECTION-SCREEN END OF <numb>.

Defines a selection screen with the screen number <numb>. All PARAMETERS, SELECT-OPTIONS, and SELECTION-SCREEN statements within the SELECTION-SCREEN BEGIN OF … END OF block belong to the selection screen <numb>. The TITLE addition allows you to define a title for the selection screen. The AS WINDOW addition allows you to define the selection screen as a modal dialog box.

Defines selection screen versions.

SELECTION-SCREEN BEGIN OF VERSION <dynnr>
 ...
  SELECTION-SCREEN EXCLUDE <f>.
 ...
SELECTION-SCREEN BEGIN OF VERSION <dynnr>.

Only in logical databases. The statement hides fields that otherwise appear on the standard selection screen.

Provides special functions in conjunction with logical databases.

SELECTION-SCREEN DYNAMIC SELECTIONS | FIELD SELECTION
                 FOR NODE|TABLE <node>.

Can only be used in logical databases. Declares a node as accepting dynamic selections or field selections.

Sets an individual bit.

SET BIT <n> OF <f> [TO <b>].

Sets t he bit at position <n> of hexadecimal field <f> to 1 or the value of the field <b>. <b> must be 0 or 1.

Allows blank lines in lists.

SET BLANK LINES ON|OFF.

Prevents blank lines created in WRITE statements from being suppressed in list output.

Sets the output format

SET COUNTRY <c>.

Sets the output formats for numeric and date fields for the country with the ID <c>.

Sets the cursor on the screen.

SET CURSOR FIELD <f> [OFFSET <off>]
                     [LINE <lin>].

SET CURSOR LINE <lin> [OFFSET <off>].

SET CURSOR <col> <line>.

Sets the cursor either to a particular position in a field, line, or column of a line.

Affects the extended program check.

SET EXTENDED CHECK ON|OFF.

Switches the extended program check (SLIN) on or off, suppressing the corresponding messages.

Registers event handlers in ABAP Objects.

SET HANDLER... <h_i>... [FOR <ref>|FOR ALL INSTANCES].

If you do not use the FOR addition, the handler is set for all static events. Use the FOR addition to register handlers for instance events.

Sets a screen attribute.

SET HOLD DATA ON|OFF.

Sets the screen attribute "Hold data" from the program.

Sets the display language.

SET LANGUAGE <lg>.

All text symbols are refreshed with the contents of the text pool in language <lg>.

Sets the left-hand boundary for horizontal scrolling.

SET LEFT SCROLL-BOUNDARY [COLUMN <col>].

Sets the current output position or the position <col> as the left-hand edge of the scrollable area on the current list page.

Sets the text environment.

SET LOCALE LANGUAGE <lg> [COUNTRY <c>] [MODIFIER <m>].

Sets the text environment for alphabetical sorting according to the language <lg>, country <c>, and any further modifier <m>.

Sets the margin of a print page.

SET MARGIN <x> [<y>].

Sends the current list page to the spool system with a margin of <x> columns from the left-hand edge and <y> rows from the top edge of the page.

Sets a SPA/GPA parameter.

Copies the value of the field <f> into the SPA/GPA parameter <pid> in the user-specific SAP memory.

Sets the GUI status.

SET PF-STATUS <stat> [EXCLUDING <f>|<itab>]
                     [IMMEDIATELY] [OF PROGRAM <prog>].

Sets the GUI status <stat> for the subsequent screens. The EXCLUDING addition allows you to deactivate functions dynamically. The IMMEDIATELY addition sets the GUI status of the list currently displayed. The OF PROGRAM addition allows you to use a GUI status from another program.

Sets a property of an OLE2 Automation object.

Sets the property <p> of an external OLE2 Automation object to <f>.

Controls the runtime analysis.

SET RUN TIME ANALYZER ON|OFF.

The runtime analysis only measures the runtime of the statements in the block between SET RUN TIME ANALYZER ON and OFF.

Sets the clock accuracy for runtime analysis.

SET RUN TIME CLOCK RESOLUTION HIGH|LOW.

Sets the accuracy of the runtime to low accuracy with long measurement interval or high accuracy with shorter measurement interval.

Sets the next screen.

SET SCREEN <scr>.

Temporarily overwrites the statically-defined next screen with <scr>. <scr> is processed after the current screen.

Sets the screen title.

SET TITLEBAR <t> [OF PROGRAM <prog>] [WITH <g1 >... <g9>].

Sets the title <t> for the subsequent screens. The OF PROGRAM addition allows you to use a title from another program. The WITH addition fills any placeholders in the title.

Switches on local update.

SET UPDATE TASK LOCAL.

Updates are processed in the current work process.

Triggers a list event.

SET USER-COMMAND <fc>.

Triggers a list event with the function code <fc> and calls the corresponding event block.

Shifts strings.

SHIFT <c> [BY <n> PLACES] [LEFT|RIGHT|CIRCULAR].

Shifts the field <c> by one or <n> places. The additions allow you to specify the direction, and how the empty spaces are dealt with.

Creates blank lines on the output list.

Creates <n> blank lines after the current line in a list. If you omit <n>, inserts one line.

Absolute positioning for output on a list.

Positions the list output in line <lin>.

Sorts an extract dataset.

SORT [ASCENDING|DESCENDING] [AS TEXT] [STABLE]
    ... BY <f_i> [ASCENDING|DESCENDING] [AS TEXT]...

Ends creation of the extract dataset in the program and sorts it. If you omit the BY addition, the extract is sorted by the key specified in the HEADER field group. The BY addition allows you to specify a different sort key. The other additions specify whether you want to sort in ascending or descending order, and whether strings should be sorted alphabetically.

Sorts internal tables.

SORT <itab> [ASCENDING|DESCENDING] [AS TEXT] [STABLE]
           ... BY <f_i> [ASCENDING|DESCENDING] [AS TEXT]...

Sorts the internal table <itab>. If you omit the BY addition, the table is sorted by its key. The BY addition allows you to specify a different sort key. The remaining additions allow you to specify whether you want to sort in ascending or descending order, and whether strings should be sorted alphabetically.

Splits a character string.

Searches the field <c> for the character <del> and places the partial fields before and after <del> into the target fields <c1> … <cn>, or into a new line of the internal table <itab>.

Event keyword that defines an event block for a reporting event.

After the selection screen has been processed, the runtime environment triggers the START-OF-SELECTION event and processes the corresponding event block.

Defines static variables.

Like DATA. Retains the value of a local variable beyond the runtime of the procedure in which it occurs.

Exits a reporting event.

Can only occur in event blocks for reporting events. Leaves the block and jumps to END-OF-SELECTION.

Calls an executable program.

SUBMIT <rep> [AND RETURN] [VIA SELECTION-SCREEN]
                          [USING SELECTION-SET <var>]
                          [WITH <sel> <criterion>]
                          [WITH FREE SELECTIONS <freesel>]
                          [WITH SELECTION-TABLE <rspar>]
                          [LINE-SIZE <width>]
                          [LINE-COUNT <length>].

Calls the program <rep>. If you omit the AND RETURN addition, the current program is terminated, otherwise, the data from the current program is retained, and processing returns to the calling program when <rep> has finished running. The other additions control the selection screen and set attributes of the default list in the called program.

Subtracts two single fields.

The contents of <n> are subtracted from the contents of <m> and the result placed in <m>. Equivalent of m = m - n.

Subtracts components of structures.

Subtracts the contents of the components of <struc1> from identically-named components in <struc2> and places the results in the components of <struc2>.

Calculates sums of groups.

SUM.

Can only be used in loops through internal tables. Calculates the sums of the numeric fields in all lines of the current control level and writes the results to the corresponding fields in the work area.

Fills context instances with values.

SUPPLY <key₁> = <f ₁>... <key _n> = <f _n> TO CONTEXT <inst>.

Fills the key fields <key_n> of the context instance <inst> with the values <f _n>.

Prevents the current screen from being displayed.

Can only occur in a PBO dialog module. The screen is not displayed, but its flow logic is still processed.

Declares an interface work area.

Declares a structure with the same data type and name as a database table, a view, or a structure from the ABAP Dictionary. Structures declared using TABLES in main programs and subroutines use a common data area.

Event keyword for defining an event block for a list event.

Whenever a new page begins while a standard list is being created, the runtime environment triggers the TOP-OF-PAGE event and the corresponding event block is executed. The addition DURING LINE-SELECTION has the same function, but for detail lists.

Writes data to a file.

TRANSFER <f> TO [LENGTH <len>].

Writes the field <f> to the file <dsn> on the application server. The LENGTH addition specifies the length <len> of the data you want to transfer.

Converts characters in strings.

TRANSLATE <c>  TO UPPER|LOWER CASE
              |USING <r>.

The characters of the string <c> are converted into upper- or lowercase, or according to a substitution rule specified in <r>.

Introduces a type group.

The first statement in a type group. You do not have to enter this statement in the ABAP Editor - instead, it is automatically inserted in the type group by the ABAP Dictionary. A type group is an ABAP program containing type definitions and constant declarations that can then be used in several different programs.

Declares the types and constants of a type group to a program.

After this statement, you can use all of the data types and constants defined in the type group <tpool> in your program.

Defines a simple field type.

TYPES <t>[(<length>)] [TYPE <type>|LIKE <obj>] [DECIMALS <dec>].

Defines the internal data type <t> in the program with length <len>, reference to the ABAP Dictionary type <type> or a data object <obj>, and, where appropriate, with <dec> decimal places.

TYPES <t> TYPE REF TO <class>|<interface>.

Defines the internal data type <t> in the program with reference to the class <class> or the interface <interface>.

Defines aggregated types.

TYPES: BEGIN OF <structure>,
        ...
         <t_i>...,
        ...
       END OF <structure>.

Combines the data types <t_i> to form the structure <structure>. You can address the individual components of a structure in a program using a hyphen between the structure name and the component name as follows: <structure>-<t _i>.

TYPES <t> TYPE|LIKE <tabkind> OF <linetype> [WITH <key>].

Defines the local data type <t> in the program as an internal table with the access type <tabkind>, the line type <linetype>, and the key <key>.

Places a horizontal line on the output list.

ULINE [AT [/][<pos>][(<len>)]].

Without additions, generates a new line on the current list and fills it with a horizontal line. The additions allow you to insert a line break and specify the starting position and length of the line.

Converts variables from type P to type C.

Unpacks the packed field <f> and places it in the string <g> with leading zeros. The opposite of PACK.

Modifies lines in database tables.

UPDATE <dbtab> SET  <s_i> = <f>
                   |<s_i> = <s _i> + <f>
                   |<s_i> = <s _i> - <f> [WHERE <cond>].

Sets the value in <s_i> to <f>, increases it by <f>, or decreases it by <f> for all selected lines. The WHERE addition determines the lines that are updated. If you omit the WHERE addition, all lines are updated.

UPDATE <dbtab> FROM <wa>.

UPDATE <dbtab> FROM TABLE <itab>.

Overwrites the line with the same primary key as <wa> with the contents of <wa>, or all lines with the same primary key as a line in the internal table <itab> with the corresponding line of itab. The work area <wa> or the lines of the table <itab> must have at least the same length and the same alignment as the line structure of the database table.

Introduces a statement block in a CASE control structure.

WHEN <f₁> [OR <f ₂> OR...] | OTHERS.

Introduces a loop.

WHILE <logexp> [VARY <f> FROM <f1> NEXT <f2>].

Introduces a statement block that is concluded with ENDWHILE. The statement block between WHILE and ENDWHILE is repeated for as long as the expression <logexp> is true, or until a termination statement such as CHECK or EXIT occurs. The VARY addition allows you to process fields that are a uniform distance apart within memory.

Displays a list as a modal dialog box.

Can only be used in list processing. The current detail list is displayed as a modal dialog box. The top left-hand corner of the window is positioned at column <x1> and line <y1>. The bottom right-hand corner is positioned at column <x2> and line <y2> (if specified).

Creates list output.

The contents of the field <f> are formatted according to their data type and displayed on the list. The additions before the field allow you to specify a line break, the starting position, and the length of the field. The additions after the field allow you to display checkboxes, symbols, icons, and lines. The <format> addition can contain various other formatting options. The QUICKINFO addition allows you to assign a quickinfo <g> to the field.

Assigns strings.

Converts the contents of the data object <f1> to type C and assigns the resulting string to the variable <f2>. You can use the same formatting options available in the WRITE statement.