COMPLETE LIST OF ALL SAP ABAP KEYWORDS. Alphabetical Overview of all SAP ABAP Commands or Keywords. A ADD for single fields Adds two single fields. Syntax ADD TO . The contents of are added to the contents of and the results are stored in . This is equivalent to: = + . More… ADD for field sequences Adds sequences of fields in storage. Syntax ADD THEN UNTIL GIVING . ADD THEN UNTIL ACCORDING TO GIVING . ADD THEN UNTIL TO . ADD FROM TO GIVING . If , ,…, is a sequence of fields with the same distance to one another and if they have the same type and length, these fields are added and the result is stored in . Different variants allow you to limit fields to a subsequence, to include in the sum, and to perform the operation on a sequence of fields that directly follow one another. ADD-CORRESPONDING Adds subfields of structures. Syntax ADD-CORRESPONDING TO . All the subfields of the structures and having the same name are added and the results are stored in . ALIASES Defines class-specific alias names for an interface component in ABAP objects. Syntax ALIASES FOR . is defined within a class or interface as synonymous with the interface component . APPEND Appends a line or multiple lines to the end of an index table. Syntax APPEND |LINES OF TO [ASSIGNING | REFERENCE INTO ]. A line or multiple lines of an internal table are appended to index table . If you use ASSIGNING or INTO REFERENCE, field symbol refers to the appended line or the relevant data reference is stored in after the statement. ASSIGN Assigns a field to a field symbol. Syntax ASSIGN [INCREMENT ] TO [CASTING [TYPE |LIKE ] [DECIMALS ]] [RANGE ]. Data object is assigned to field symbol . now points to the data object. After the addition INCREMENT , the storage area that is offset times by a length of starting with is assigned to the field symbol. Pointed brackets are part of the syntax for field symbol names. The CASTING addition permits you to cast data objects when assigning field symbols. The RANGE addition defines the storage area in which either offset/length accesses or the INCREMENT addition are allowed. In Unicode programs, standard access is only allowed within the field limits of , but this can be extended with RANGE. In non-Unicode programs, standard access is possible up to the boundary of the data segment and can be limited with RANGE.
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
COMPLETE LIST OF ALL SAP ABAP KEYWORDS.
Alphabetical Overview of all SAP ABAP Commands or Keywords.
A
ADD for single fields
Adds two single fields.
Syntax
ADD TO .
The contents of are added to the contents of and the results are stored in . This is equivalent to: = + .
More…
ADD for field sequences
Adds sequences of fields in storage.
Syntax
ADD THEN UNTIL GIVING .
ADD THEN UNTIL ACCORDING TO GIVING .
ADD THEN UNTIL TO .
ADD FROM TO GIVING .
If , ,…, is a sequence of fields with the same distance to one another and if they have the same type and length, these fields are added and
the result is stored in . Different variants allow you to limit fields to a subsequence, to include in the sum, and to perform the operation on a
sequence of fields that directly follow one another.
ADD-CORRESPONDING
Adds subfields of structures.
Syntax
ADD-CORRESPONDING TO .
All the subfields of the structures and having the same name are added and the results are stored in .
ALIASES
Defines class-specific alias names for an interface component in ABAP objects.
Syntax
ALIASES FOR .
is defined within a class or interface as synonymous with the interface component .
APPEND
Appends a line or multiple lines to the end of an index table.
Syntax
APPEND |LINES OF TO
[ASSIGNING | REFERENCE INTO ].
A line or multiple lines of an internal table are appended to index table . If you use ASSIGNING or INTO REFERENCE, field symbol refers
to the appended line or the relevant data reference is stored in after the statement.
ASSIGN
Assigns a field to a field symbol.
Syntax
ASSIGN [INCREMENT ] TO
[CASTING [TYPE |LIKE ] [DECIMALS ]] [RANGE ].
Data object is assigned to field symbol . now points to the data object. After the addition INCREMENT , the storage area that is offset times
by a length of starting with is assigned to the field symbol. Pointed brackets are part of the syntax for field symbol names. The CASTING
addition permits you to cast data objects when assigning field symbols. The RANGE addition defines the storage area in which either
offset/length accesses or the INCREMENT addition are allowed. In Unicode programs, standard access is only allowed within the field
limits of , but this can be extended with RANGE. In non-Unicode programs, standard access is possible up to the boundary of the data
segment and can be limited with RANGE.
Syntax
ASSIGN ->* TO [CASTING ... ].
Dereferencing of the data reference in . The data object to which the data reference refers is assigned to field symbol .
AT for event blocks
Event keywords for defining event blocks for screen events.
Syntax
AT SELECTION-SCREEN…
AT LINE-SELECTION.
AT USER-COMMAND.
AT PFn.
User actions on a selection screen or on a list trigger certain events in the ABAP runtime environment. The event keywords define event
blocks that are called when events occur.
AT for group change
Change of group when processing loops of extracts and internal tables.
Syntax
AT NEW .
AT END OF .
AT FIRST.
AT LAST.
AT .
The statements are used to process group levels within a loop using an extract dataset or an internal table. They introduce statement
blocks that must be closed with ENDAT. The statements between AT and ENDAT are only executed if the corresponding group change
occurred.
AUTHORITY-CHECK
Checks user authorization.
Syntax
AUTHORITY-CHECK OBJECT ID FIELD
ID FIELD
…
ID FIELD .
There is a check if the program user has all the authorizations defined in authorization object . ,…, are the authorization fields of the
authorization object. ,… , …, are data objects of the program. The value of the data objects is checked against the authorization fields.
B
BACK
Relative position of the output in a list.
Syntax
BACK.
Positions the list output either in the first column of the first line following the page header of the current page or in connection with
RESERVE in the first column of the first line of a line block.
BREAK-POINT
Calls the Debugger.
Syntax
BREAK-POINT.
Interrupts execution of the program and goes to debugging mode. Is used as a test help. Normal program processing is interrupted when
this statement is reached and the system goes to a debugger.
C
CALL CUSTOMER-FUNCTION
Calls the customer function modules.
Syntax
CALL CUSTOMER-FUNCTION …
Similar to CALL FUNCTION. The function modules must be programmed and activated within the customer’s modification concept.
CALL FUNCTION
Calls the function modules.
Syntax
CALL FUNCTION [EXPORTING ... fi = a i... ]
[IMPORTING ... fi = a i... ]
[CHANGING ... fi = a i... ]
[TABLES ... fi = a i... ]
[EXCEPTIONS... ei = r i... ]
[DESTINATION ]
[IN UPDATE TASK]
[STARTING NEW TASK]
[IN BACKGOUND TASK].
The program calls either a function module in the same R/3 System, or one from an external system, depending on the variant of the
statement you use. You can call update modules when processing transactions. You can also call functions asynchronously. The other
additions are used to specify actual parameters for the parameter interface for the function module, , and to handle exceptions.
CALL DIALOG
Calls a dialog module.
Syntax
CALL DIALOG [AND SKIP FIRST SCREEN]
[EXPORTING... fi = a i... ]
[IMPORTING... fi = a i... ]
[USING itab].
Calls the dialog module . A dialog module is an ABAP program with a sequence of screens. It does not have to be started using a
transaction code, or run in the same SAP LUW, like the calling program. The additions are used to skip the initial screen in the sequence
and specify actual parameters for the parameter interface of the dialog module.
CALL METHOD
Calls a method in ABAP Objects.
Syntax
CALL METHOD [EXPORTING ... =.... ]
[IMPORTING ... =.... ]
[CHANGING ... =.... ]
[RECEIVING r = h ]
[EXCEPTIONS... = r i... ]
[PARAMETER-TABLE ]
[EXCEPTION-TABLE ].
[CALL METHOD]( … ).
Calls a method . The additions are used to specify actual parameters for the parameter interface for the function module and to handle
exceptions. The last two additions pass parameters dynamically in a dynamic method call. Alternatively, if the method is called statically,
the parameters can be specified using parenthesis notation (as you can when specifying parameters in a CALL METHOD statement). You
can also use functional methods with this syntax in operand positions.
CALL METHOD OF
Calls a method in OLE2 Automation.
Syntax
CALL METHOD OF .
Calls the method, , of the OLE2 Automation Object, .
CALL SCREEN
Calls a screen sequence.
Syntax
CALL SCREEN
[STARTING AT ]
[ENDING AT ].
Calls the sequence of screens that begins with the screen . All the screens in the screen sequence belong to the current ABAP program.
The screen sequence ends when the program reaches the screen numbered 0. The additions let you call a single screen in a new window.
CALL SELECTION-SCREEN
Calls a selection screen.
Syntax
CALL SELECTION-SCREEN
[STARTING AT ]
[ENDING AT ].
Calls a selection screen defined in an ABAP program. The selection screen is processed in the program in the AT SELECTION-SCREEN
event. The additions let you call a selection screen in a new window.
CALL TRANSACTION
Call a transaction.
Syntax
CALL TRANSACTION
[AND SKIP FIRST SCREEN]
[USING ].
Calls the transaction after having received data from the calling program. At the end of the transaction that has been called, the system
returns to the statement following the call in the calling report. The additions are used to skip the initial screen in the sequence or to pass a
batch input table to the transaction.
CASE
Conditional branch.
Syntax
CASE .
Opens a CASE control structure that ends with an ENDCASE statement. The CASE control structure allows you to control which statement
blocks (introduced by WHEN) are processed, based on the contents of a data object.
CATCH
Catches a class-based exception.
CATCH … [INTO ].
You can only use this statement in a TRY-ENDTRY block, where you define a handler for one or more class-based exceptions. You can
use INTO to place a reference to the exception object into the reference variable .
CATCH SYSTEM-EXCEPTIONS
Catches a catchable runtime error.
Syntax
CATCH SYSTEM-EXCEPTIONS = … = .
Introduces a CATCH area, which ends with an ENDCATCH statement. If a catchable runtime error , occurs between CATCH and
ENDCATCH, the current processing block is interrupted. The system jumps to the appropriate ENDCATCH statement and fills SY-SUBRC
with .
CHECK
Conditionally leaves a loop or processing block.
Syntax
CHECK .
If the logical expression is true, the system continues with the next statement. If it is false, processing within the loop is interrupted at the
current loop pass, and the next loop pass is performed. Otherwise the system leaves the current processing block. In conjunction with
selection tables, and inside GET events, you can use an extra variant of the CHECK statement.
CLASS Declaration
Declares a class in ABAP Objects.
Syntax
CLASS DEFINITION [PUBLIC]
[INHERITING FROM ]
[ABSTRACT]
[FINAL]
[CREATE PUBLIC|PROTECTED|PRIVATE]
[FRIENDS ...]
[DEFERRED]
[LOAD].
Introduces the declaration part of a class, . The declaration part ends with ENDCLASS and contains the declaration of all the components
of the class. The PUBLIC addition is generated only by the Class Builder. It defines a global class in the Class Library. The INHERITING
FROM addition lets you derive the class, , from a superclass, . The ABSTRACT addition defines an abstract class, which cannot be
instantiated. The FINAL addition defines a class that cannot have any subclasses. The CREATE addition specifies who can instantiate the
class. FRIENDS allows you to specify other classes or interfaces, that can access the private components of the class and instantiate
objects of the class, independently of the CREATE addition. The DEFERRED addition makes the class known to the program before it is
declared. The LOAD addition loads a class explicitly from the Class Library.
CLASS – Implementation
Implements a class in ABAP Objects.
Syntax
CLASS IMPLEMENTATION.
Introduces the implementation part of a class, . The implementation part ends with ENDCLASS and contains the implementation of all the
components of the class.
CLASS-DATA
Declares static attributes of a class or interface.
Syntax
CLASS-DATA …
Like DATA. However, the attribute is declared as a static attribute. Static attributes are not instance-specific. Their content is shared by all
instances.
CLASS-METHODS
Declares static methods of a class or interface.
Syntax
CLASS-METHODS …
Like METHODS, except that the method is declared as a static method. A static method can access static attributes and can only trigger
static events.
CLASS-EVENTS
Declares static events of a class or interface.
Syntax
CLASS-EVENTS …
Like EVENTS, except that the event is declared as a static attribute. Static events are the only type of event that can be triggered in a static
method.
CLEANUP
Tidies up after class-based exceptions.
CLEANUP.
Can only be used within a TRY-ENDTRY block, where it defines a control block. If a class-based exception is not caught with a CATCH
statement, the system executes the statements between CLEANUP and ENDTRY, before passing the exception along the call hierarchy.
CLEAR
Sets a variable to its initial value.
Syntax
CLEAR .
The variable , which can have any data type, is set to an initial value appropriate to its type.
CLOSE DATASET
Closes a file.
Syntax
CLOSE DATASET .
Closes a file opened with OPEN DATASET on the application server.
CLOSE CURSOR
Closes a database cursor.
Syntax
CLOSE CURSOR .
Closes a cursor opened with OPEN CURSOR.
COLLECT
Aggregates lines and then adds them to an internal table.
Syntax
COLLECT INTO
[ASSIGNING | REFERENCE INTO ].
The system checks whether there is already a table entry that matches the key. If there is no corresponding entry already in the table, the
COLLECT statement has the same effect as INSERT. If an entry with the same key already exists, the COLLECT statement does not
append a new line, but adds the contents of the numeric fields in the work area to the contents of the fields in the existing entry. If you use
ASSIGNING or INTO REFERENCE, field symbol refers to the inserted line or the relevant data reference is stored in after the statement.
COMMIT
Closes a SAP LUW.
Syntax
COMMIT WORK [AND WAIT]
Writes all the database changes and releases all the database locks. Triggers updating. The AND WAIT addition forces the program to wait
until the system has finished updating the database. Otherwise, updating is asynchronous.
COMMUNICATION
Enables two programs to communicate with each other.
Syntax
COMMUNICATION INIT DESTINATION ID [additions].
COMMUNICATION ALLOCATE ID [additions].
COMMUNICATION ACCEPT ID [additions].
COMMUNICATION SEND ID BUFFER [additions].
COMMUNICATION RECEIVE ID [additions].
COMMUNICATION DEALLOCATE ID [additions].
The statement initializes, creates, and accepts communication between two programs; lets these two programs send and receive data; and
then closes the connection.
COMPUTE
Performs numeric operations.
Syntax
COMPUTE = .
The result of the mathematical operation specified in is assigned to the field . The keyword COMPUTE is optional.
CONDENSE
Removes spaces from a string
Syntax
CONDENSE [NO-GAPS].
This statement removes any leading blanks from the field and replaces other sequences of blanks by exactly one blank. If the addition NO-
GAPS is specified, all blanks are removed.
CONSTANTS
Declares constant data objects.
Syntax
CONSTANTS … VALUE [ | IS INITIAL]…
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 start value specified in the VALUE addition cannot be changed during the execution of the program.
CONTINUE
Ends a loop pass.
Syntax
CONTINUE.
Only possible within loops. This statement terminates the current loop pass and starts the next
CONTEXTS
Declares a context.
Syntax
CONTEXTS .
Generates an implicit data type CONTEXT_, which you can use to create context instances
CONTROLS
Defines a control.
Syntax
CONTROLS TYPE .
Defines an ABAP runtime object . This displays data in a particular format on a screen, depending on the type Currently, may be a table
control or tabstrip control
CONVERT für Dates
Converts a data into an inverted date form.
Syntax
CONVERT DATE INTO INVERTED-DATE .
CONVERT INVERTED-DATE INTO DATE .
If and are date fields in the internal form YYYYMMDD, the nines complement of is placed in field and vice versa. In inverted date format,
the most recent date has the smaller numerical value
CONVERT for Timestamps
Converts a timestamp into the correct date and time for the current time zone
Syntax
CONVERT TIME STAMP TIME ZONE INTO DATE TIME .
CONVERT DATE TIME INTO TIME STAMP TIME ZONE .
As long as has type P(8) or P(11) with 7 decimal placed, and has type C(6), the time stamp will be converted to the correct date and time
for the time zone .
CONVERT for Text
Converts a text into a format that can be sorted alphabetically.
Syntax
CONVERT TEXT INTO SORTABLE CODE .
must have type C and 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
CREATE DATA
Creates a dynamic data object.
Syntax
CREATE DATA TYPE |LIKE .
CREATE DATA TYPE LINE OF |LIKE LINE OF .
CREATE DATA TYPE REF TO DATA|.
CREATE DATA TYPE TYPE|LIKE OF WITH .
If is a data reference variable, a data object of the specified type is created. The reference in points to this object. You can omit the TYPE
declaration in fully-typed reference variables.
CREATE OBJECT in ABAP Objects
Instantiates an object in ABAP Objects.
Syntax
CREATE OBJECT [TYPE ] [EXPORTING ... =.... ].
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 then points The reference in points to this object. If is a typed class reference variable with reference to a subclass of , or if is
an interface reference variable, whose interface is implemented in the class , you can specify the class of the instantiated object explicitly in
a TYPE addition, to establish the dynamic type of the reference variables. The EXPORTING addition specifies the non-optional
IMPORTING parameters of the instance constructor of the class of the instantiated object.
CREATE OBJECT in OLE2 Automation
Instantiates an external object in OLE2 Automation.
Syntax
CREATE OBJECT .
If is a class assigned to an automation server, an initial object of this class is created
D
DATA with Reference to Known Data Types
Declares variables with a previously-declared data type
Syntax
DATA … [TYPE |LIKE ]… [VALUE ].
Declares a variable with the fully-defined data type or the same data type as another data object . The data 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 is a data object or line of an
internal table that has already been defined. The VALUE addition specifies a starting value.
DATA with Reference to Generic Data Types
Declares variables by completing the description of a generic type
Syntax
DATA [()] TYPE [DECIMALS ]… [VALUE ].
DATA TYPE .
The data type can be C, N, P, X, STRING or XSTRING. The option sets the field length. If you omit it, the field length is set to the
appropriate initial value. If is P, you can specify the number of decimal places using the DECIMALS addition. If you omit this, the number of
decimal places is set to 0. If you do not use the TYPE addition, the system uses the default predefined generic type C.
Syntax
DATA TYPE .
The data type is a standard internal table with generic key. The default key is automatically used in the DATA statement.
DATA, Creating an Associated Data Type
Declares variables with data types that only exist as an attribute of the variable.
Syntax
DATA TYPE REF TO |.
The variable is defined as an object reference variable for the class or interface .
Syntax
DATA TYPE REF TO DATA|.
Declares the variable as a data reference variable for a data object.
Syntax
DATA: BEGIN OF ,
…
…,
…
END OF .
Combines the variables to form the structure . The individual variables within a structure are addressed in the program with a hyphen
between the structure name and component name as follows: -.
Syntax
DATA TYPE|LIKE OF WITH .
The variable is declared as an internal table with the table kind , line type , and key .
Syntax
DATA TYPE|LIKE RANGE OF |.
Declares the variable as a RANGES table. A RANGES table has the same data type as a selection table, but is not linked to input fields on
a selection screen.
DATA statement for Shared Data Areas
Declares shared data areas in a program.
Syntax
DATA: BEGIN OF COMMON PART ,
. ..
END OF COMMON PART.
The variables are assigned to a data area , 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.
DEFINE
Defines a macro.
Syntax
DEFINE .
Introduces the definition of the macro . Each macro must consist of complete ABAP statement and be concluded with the END-OF-
DEFINITION statement.
DELETE for Files
Deletes files on the application server
Syntax
DELETE DATASET .
Deletes the file from the file system of the application server.
DELETE for Database Table Entries
Deletes entries from database tables.
Syntax
DELETE FROM WHERE .
All of the lines in the database table that satisfy the conditions in the WHERE clause are deleted.
Syntax
DELETE FROM .
DELETE FROM TABLE .
This deletes the line that has the same primary key as the work area , or deletes all the lines in the database that have the same primary
key as a line in the internal table . The work area or the lines of the internal table must have at least the same length as the work area of the
database table.
DELETE for Cluster Databases
Deletes data clusters from cluster database tables.
Syntax
DELETE FROM DATABASE () ID .
Deletes the entire cluster in area with the name from the cluster database table .
DELETE for the Cross-Transaction Application Buffer
Deletes data clusters from the cross-transaction application buffer.
Syntax
DELETE FROM SHARED BUFFER () ID .
Deletes the data cluster for the area with the name stored in the cross-transaction application buffer for the table .
DELETE for Lines from an Internal Table
Deletes lines from internal tables of any type.
Syntax
DELETE TABLE FROM .
DELETE TABLE WITH TABLE KEY = … = .
Deletes using the table key. All lines with the same key are deleted. The key values are taken either from a compatible work area or
specified explicitly.
Syntax
DELETE WHERE .
Deletes using conditions. Deletes all table entries that satisfy the logical expression . The logical condition can consist of more than one
comparison. In each comparison, the first operand must be a component of the line structure.
Syntax
DELETE ADJACENT DUPLICATE ENTRIES FROM [COMPARING... ].
Deletes adjacent duplicate entries, either by comparing the key fields or the comparison fields specified explicitly in the COMPARING
addition.
DELETE for Lines from Index Tables
Deletes entries from index tables.
Syntax
DELETE [INDEX ].
If you use the INDEX addition, the line with index is deleted from the table . Without the INDEX addition, you can only use the above
statement within a LOOP. In this case, you delete the current line.
Syntax
DELETE [FROM ] [TO ] [WHERE ].
The system deletes all of the lines of whose index lies between and and who meet the conditions specified in the WHERE clause. If you do
not specify a FROM addition, the system deletes lines from the first line onwards. If you do not specify a TO addition, the system deletes
lines up to the last line. The logical condition can consist of more than one comparison. In each comparison, the first operand must be a
component of the line structure.
DEMAND
Retrieves values from a context instance.
Syntax
DEMAND = … = FROM CONTEXT
[MESSAGES INTO ].
Fills the fields with the values from the context instance . You can handle these messages in your programs by using the MESSAGES
addition.
DESCRIBE DISTANCE
Gets the distance between two fields.
Syntax
DESCRIBE DISTANCE BETWEEN AND INTO [IN BYTE|CHARACTER MODE].
Writes the number of bytes between data objects and into the variable . The length of the first field in memory is always included. In
Unicode programs, you must specify either the IN BYTE MODE or IN CHARACTER MODE addition. In non-Unicode programs, the
distance is returned in bytes.
DESCRIBE FIELD
Describes the attributes of a field.
Syntax
DESCRIBE FIELD [LENGTH [IN BYTE|CHARACTER MODE]]
[TYPE [COMPONENTS ]]
[OUTPUT-LENGTH ] [DECIMALS ]
[EDIT MASK ] [HELP-ID ].
The attributes of the data object specified by the parameters of the statement are written to the variables following the parameters. You can
use any number of the additions in the same statement. In Unicode programs, you must specify either the IN BYTE MODE or IN
CHARACTER MODE addition for LENGTH. In non-Unicode programs, the length is returned in bytes.
DESCRIBE LIST
Describes the attributes of a list.
Syntax
DESCRIBE LIST NUMBER OF LINES [INDEX ].
DESCRIBE LIST NUMBER OF PAGES [INDEX ].
DESCRIBE LIST LINE PAGE [INDEX ].
DESCRIBE LIST PAGE [INDEX ]…
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.
DESCRIBE TABLE
Describes the attributes of an internal table.
Syntax
DESCRIBE TABLE [LINES ] [OCCURS] [KIND ].
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.
DIVIDE
Divides one field by another.
Syntax
DIVIDE BY .
Divides the content of by , and places the result in . This is equivalent to: n=n/m.
DIVIDE-CORRESPONDING
Divides matching components of structures.
Syntax
DIVIDE-CORRESPONDING BY .
All the identically-named subfields of the structures and are divided and the results are stored these subfields of .
DO
Introduces a loop.
Syntax
DO [ TIMES] [VARYING FROM NEXT ].
Introduces a statement block that ends with ENDDO. If you omit the TIMES addition, the statement block is repeated until it reaches a
termination statement such as EXIT or CHECK. Use the TIMES addition to restrict the number of loop passes to . The VARYING addition
allows you to process fields the same distance apart in memory.
E
EDITOR-CALL
Loads an ABAP program or internal table into a text editor.
Syntax
EDITOR-CALL FOR …
EDITOR-CALL FOR REPORT …
Loads the internal table or the program into a text editor, where you can edit it using standard editor functions.
ELSE
Introduces a statement block in an IF control structure.
Syntax
ELSE.
If the logical expression in an IF statement is false, ELSE introduces the statement block to be executed instead.
ELSEIF
Introduces a statement block in an IF control structure.
Syntax
ELSEIF .
If the logical expression in an IF statement is false and is true, ELSE introduces the statement block to be executed instead.
END-OF-DEFINITION
Closes a macro definition.
Syntax
END-OF-DEFINITION.
This statement concludes a macro definition introduced with DEFINITION.
END-OF-PAGE
Event keywords for defining event blocks for list events.
Syntax
END-OF-PAGE.
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.
END-OF-SELECTION
Event keywords for defining event blocks for reporting events.
Syntax
END-OF-SELECTION.
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.
ENDAT
Closes a statement block in control level processing.
Syntax
ENDAT.
This statement concludes a control level processing block introduced with AT.
ENDCASE
Closes a CASE control structure.
Syntax
ENDCASE.
This statement concludes a control structure introduced with CASE.
ENDCATCH
Closes a CATCH area.
Syntax
ENDCATCH.
This statement concludes an exception handling block introduced with CATCH SYSTEM-EXCEPTIONS.
ENDCLASS
Closes a class definition.
Syntax
ENDCLASS.
This statement concludes a class declaration or implementation introduced with CLASS.
ENDDO
Closes a DO loop.
Syntax
ENDDO.
This statement concludes a loop introduced with DO.
ENDEXEC
Closes a Native SQL statement.
Syntax
ENDEXEC.
This statement ends a Native SQL statement introduced with EXEC SQL.
ENDFORM
Closes a subroutine.
Syntax
ENDFORM.
This statement concludes a subroutine definition introduced with FORM.
ENDFUNCTION
Closes a function module.
Syntax
ENDFUNCTION.
This statement concludes a function module introduced with FUNCTION.
ENDIF
Closes an IF control structure.
Syntax
ENDIF.
This statement concludes a control structure introduced with IF.
ENDINTERFACE
Closes a interface definition.
Syntax
ENDINTERFACE.
This statement concludes an interface definition introduced with INTERFACE.
ENDLOOP
Closes a LOOP.
Syntax
ENDLOOP.
This statement concludes a loop introduced with LOOP.
ENDMETHOD
Closes a method.
Syntax
ENDMETHOD.
This statement concludes a method implementation introduced with METHOD.
ENDMODULE
Closes a dialog module.
Syntax
ENDMODULE.
This statement concludes a dialog module introduced with MODULE.
ENDON
Closes a conditional statement block.
Syntax
ENDON.
This statement ends a conditional statement block introduced with ON CHANGE.
ENDPROVIDE
Closes a PROVIDE loop.
Syntax
ENDPROVIDE.
This statement concludes a loop introduced with PROVIDE.
ENDSELECT
Closes a SELECT loop.
Syntax
ENDSELECT.
This statement concludes a loop introduced with SELECT.
ENDTRY
Closes a TRY area.
Syntax
ENDTRY.
This statement concludes a control structure introduced with TRY.
ENDWHILE
Closes a WHILE loop.
Syntax
ENDWHILE.
This statement concludes a loop introduced with WHILE.
EVENTS
Defines events in classes or interfaces.
Syntax
EVENTS EXPORTING.. VALUE() TYPE type [OPTIONAL]…
The event 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.
EXEC SQL
Introduces a Native SQL statement.
Syntax
EXEC SQL [PERFORMING
].
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.
EXIT
Leaves a loop or processing block.
Syntax
EXIT.
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.
EXIT FROM STEP-LOOP
Ends a step loop.
Syntax
EXIT FROM STEP-LOOP.
Terminates step loop processing. A step loop is ais a way of displaying a table on a screen.
EXIT FROM SQL
Ends Native SQL processing.
Syntax
EXIT FROM SQL.
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.
EXPORT
Exports data clusters.
Syntax
EXPORT… [FROM ]… | ()
TO MEMORY
| DATABASE () ID()
| SHARED BUFFER () ID().
The data objects or , or the data objects in the internal table are stored as a data cluster in the cross-program ABAP memory of the current
internal session, in a cluster database table , or in the cross-transaction application buffer of the table .
EXTRACT
Creates an extract dataset and adds lines to it.
Syntax
EXTRACT .
With the first EXTRACT statement of a program, the system creates the extract dataset and adds the first extract record. In each
subsequent EXTRACT statement, the new extract record is added to the dataset. Each extract record contains exactly those fields that are
contained in the field group , plus the fields of the field group HEADER (if one exists).
F
FETCH
Uses a cursor to read entries from a database table.
Syntax
FETCH NEXT CURSOR INTO .
If the cursor is linked with a selection in a database table, FETCH writes the next line of the selection into the flat target area .
FIELD-GROUPS
Declares a field group for an extract dataset.
Syntax
FIELD-GROUPS .
This statement defines a field group . Field groups define the line structure of an extract dataset. You can also define a special field group
called HEADER: When filling the extract dataset, the system automatically prefixes any other field groups with this field group.
FIELD-SYMBOLS
Declares field symbols.
Syntax
FIELD-SYMBOLS [|STRUCTURE DEFAULT ].
Field symbols are placeholders or symbolic names for other fields. Pointed brackets are part of the syntax for field symbol names. The
addition allows you to specify the type of a field symbol. The STRUCTURE addition forces a structured view of the data objects that you
assign to the field symbol.
FIND
Searches for patterns.
Syntax
FIND
IN [SECTION OFFSET LENGTH OF]
[IGNORING CASE|RESPECTING CASE]
[IN BYTE MODE|IN CHARACTER MODE]
[MATCH OFFSET ] [MATCH LENGTH ].
The system searches the field for the pattern
. The SECTION OFFSET LENGTH OF addition tells the system to search only from the position in the length . IGNORING CASE or
RESPECTING CASE (default) specifies whether the search is to be case-sensitive. In Unicode programs, you must specify whether the
statement is a character or byte operation, using the IN BYTE MODE or IN CHARACTER MODE (default) additions. The MATCH OFFSET
and MATCH LENGTH additions set the offset of the first occurrence and length of the search string in the fields
and .
FORM
Defines a subroutine.
Syntax
FORM [USING ... [VALUE(] [)] [TYPE |LIKE ]… ]
[CHANGING... [VALUE(] [)] [TYPE |LIKE ]… ].
Introduces a subroutine
. The USING and CHANGING additions define the subroutine’s parameter interface. The subroutine end with ENDFORM.
FORMAT
Sets formatting options for list output.
Syntax
FORMAT… [ON|OFF]…
The formatting options (such as color) set in the FORMAT statement, apply to all subsequent output until they are turned off using the OFF
option.
FREE
Release space in memory.
Syntax
FREE .
FREE MEMORY ID().
FREE OBJECT .
This statement deletes an internal table, a data cluster in ABAP memory, or an external object in OLE2 Automation, depending on the
variant of the statement used.
FUNCTION
Defines a function module.
Syntax
FUNCTION .
Introduces the function module . This statement is not entered in the ABAP Editor, but is automatically generated by the Function Builder in
the ABAP Workbench. The function module definition ends with the ENDFUNCTION statement
FUNCTION-POOL
Introduces a function group.
Syntax
FUNCTION-POOL.
The first statement in a function group. This statement is not entered in the ABAP Editor, but is automatically generated by the Function
Builder in the ABAP Workbench. A function group is an ABAP program that contains function modules.
G
GET
Event keyword for defining event blocks for reporting events.
Syntax
GET [FIELDS ...].
Only occurs in executable programs. When the logical database has passed a line of the node to the program, the runtime environment
triggers the GET event, and the corresponding event block is executed. You can use the FIELDS option to specify explicitly the columns of
a node that the logical database should read.
GET BIT
Reads an individual bit.
Syntax
GET BIT OF INTO .
Reads the bit at position of the hexadecimal field into the field .
GET CURSOR
Gets the cursor position on a screen or in an interactive list event.
Syntax
GET CURSOR FIELD [OFFSET ] [LINE ]
[VALUE ] [LENGTH ].
GET CURSOR LINE [OFFSET ] [VALUE ] [LENGTH ].
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.
GET DATASET
Syntax
GET DATASET [POSITIONS ]
[ATTRIBUTE ].
Gets the attributes of a file opened using OPEN DATASET. The POSITIONS additions writes the current read/write position to the field .
The ATTRIBUTE addition writes the attributes to a structure, , of the type DSET_ATTRIBUTES.
GET LOCALE LANGUAGE
Gets the current text environment.
Syntax
GET LOCALE LANGUAGE COUNTY MODIFIER .
Returns the current language, country ID and any modifier into the corresponding variables
GET PARAMETER
Gets an SPA/GPA parameters
Syntax
GET PARAMETER ID FIELD .
Writes the value of the SPA/GPA parameter from the user-specific SAP memory into the variable .
GET PF-STATUS
Gets the current GUI status.
Syntax
GET PF-STATUS [PROGRAM ] [EXCLUDING ].
Returns the name of the current GUI status (the same as SY-PFKEY) into the variable . The PROGRAM addition writes the name of the
ABAP program to which the status belongs into the variable . The EXCLUDING addition returns a list of all currently inactive function codes
into the internal table .
GET PROPERTY
Gets a property of an OLE2 Automation object.
Syntax
GET PROPERTY OF
= .
Writes the property
of an external OLE2 Automation object to the variable .
GET REFERENCE
Gets a data reference.
Syntax
GET REFERENCE OF INTO .
Writes a data reference to an existing data object to the data reference variable .
GET RUN TIME FIELD
Measures the runtime in microseconds.
Syntax
GET RUN TIME FIELD .
The first time the statement is executed, the variable is set to zero. In each subsequent call, the runtime since the first call is written to .
GET TIME
Synchronizes the time.
Syntax
GET TIME [FIELD ].
Refreshes the system fields SY-UZEIT, SY-DATUM, SY-TIMLO, SY-DATLO, and SY-ZONLO. The FIELD addition fills the variable with the
current time.
GET TIME STAMP FIELD
Returns a time stamp.
Syntax
GET TIME STAMP FIELD .
Returns the short or long form of the current date and time, depending on whether the variable has the type P(8) or P(11). The long form
returns the time correct to seven decimal places.
H
HIDE
Stores information about list lines.
Syntax
HIDE .
While the list is being created, this statement stores the contents of the field 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 .
I
IF
Conditional branch.
Introduces a new branch.
Syntax
IF .
Opens an IF control structure that ends with an ENDIF statement. The system evaluates the logical expression , and processes different
statement blocks depending on the result.
IMPORT
Imports data clusters.
Syntax
IMPORT… [TO ]… | ()
FROM MEMORY
| DATABASE () ID()
| SHARED BUFFER () ID().
The data objects or , or the data objects in the internal table are read from data clusters, either in the cross-program ABAP memory of the
current internal session; in a cluster database table ; or in the cross-transaction application buffer of the table and written to the variables
and .
IMPORT DIRECTORY
Creates the directory of a data cluster from a cluster database.
Syntax
IMPORT DIRECTORY INTO
FROM DATABASE ()
Id .
Writes a directory of the data objects belonging to a data cluster in the cluster database to the internal table .
In the third variant, the table contains a directory of the objects stored using EXPORT TO DATABASE.
INCLUDE
Inserts an include program in another program.
Syntax
INCLUDE .
Has the same effect as copying the source code of the include program into the program. Include programs are not loaded at runtime, but
are expanded when the program is generated. Include programs must have the program type I.
INCLUDE TYPE|STRUCTURE
Includes a structure within another.
Syntax
INCLUDE TYPE |STRUCTURE [AS [RENAMING WITH SUFFIX ]].
Within a structure declared using TYPES|DATA BEGIN OF, copies a structured datatype , or a structure already available as a data object,
as part of the structure declaration. The AS addition lets you address the individual components using the name . The RENAMING addition
lets you append a suffix, , to , so that you can copy the same structure several times.
INITIALIZATION
Event keywords for defining event blocks for reporting events.
Syntax
INITIALIZATION.
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.
INSERT for Database Tables
Inserts entries from database tables.
Syntax
INSERT FROM .
INSERT FROM TABLE [ACCEPTING DUPLICATE KEYS].
Inserts one line from the work area or several lines from the internal table into the database table . The ACCEPTING DUPLICATE KEYS
addition prevents a runtime error from occurring if two entries have the same primary key. Instead, it merely discards the duplicate
INSERT for Field Groups
Defines the structure of field groups for extract datasets.
Syntax
INSERT … INTO .
Includes the fields in the field group , thus defining a line structure for an extract dataset.
INSERT for any Internal Table
Inserts lines from internal tables of any type.
Syntax
INSERT |LINES OF [FROM ] [TO ]
INTO TABLE
[ASSIGNING | REFERENCE INTO ].
Inserts a line or a set of lines from the internal table into the internal table . If is an index table, you can use the FROM and TO additions to
restrict the lines inserted. If you use ASSIGNING or INTO REFERENCE, field symbol refers to the inserted line or the relevant data
reference is stored in after the statement.
INSERT for Index Tables
Inserts entries in index tables.
Syntax
INSERT |LINES OF [FROM ] [TO ]
INTO [INDEX ]
[ASSIGNING | REFERENCE INTO ].
Inserts a line or a set of lines from the internal table into the internal table before the line with the index . If is an index table, you can use
the FROM and TO additions to restrict the lines inserted. If you omit the INDEX addition, you can only use the statement within a LOOP. A
new line containing values is inserted before the current line. If you use ASSIGNING or INTO REFERENCE, field symbol refers to the
inserted line or the relevant data reference is stored in after the statement.
INSERT for Programs
Inserts ABAP programs into the program library.
Syntax
INSERT REPORT FROM .
The lines of the internal table are added to the program library as the program .
INTERFACE
Declares a interface in ABAP Objects.
Syntax
INTERFACE [DEFERRED]
[LOAD].
Introduces an interface . The definition ends with ENDINTERFACE and contains the declaration of all the components of the interface. The
DEFERRED addition makes the interface known to the program before it is defined. The LOAD addition loads an interface explicitly from
the Class Library.
INTERFACES
Implementation or nesting of an interface in ABAP Objects.
Syntax
INTERFACES
[ABSTRACT|FINAL METHODS | ALL METHODS ABSTRACT|FINAL ]
[DATA VALUES = = ...]
.
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. Use the additions to characterize methods in interfaces as abstract or final. Their attributes can be
filled with initial values.
L
LEAVE for Screens
Leaves a screen.
Syntax
LEAVE SCREEN.
Stops processing the current screen and calls the subsequent screen. The next screen can either be defined statically in the screen
attributes or set dynamically using the SET SCREEN statement.
Syntax
LEAVE TO SCREEN .
Stops processing the current screen and calls the dynamically-defined subsequent screen *.
LEAVE for Lists During Screen Processing
Switches between screen and list processing.
Syntax
LEAVE TO LIST-PROCESSING [AND RETURN TO SCREEN ].
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
Syntax
LEAVE LIST-PROCESSING.
Allows you to switch back explicitly from list processing to screen processing.
LEAVE for Programs
Leaves an ABAP program.
Syntax
LEAVE [PROGRAM].
Stops processing the current program and returns to the point from which it was called.
Syntax
LEAVE TO TRANSACTION [AND SKIP FIRST SCREEN].
This statement ends processing of the current program and starts a new transaction, . The addition allows you to skip the initial screen of
the transaction.
LOAD-OF-PROGRAM
Event keywords for defining event blocks for a program constructor.
Syntax
LOAD-OF-PROGRAM.
When an ABAP program is loaded in an internal session, the runtime environment triggers the LOAD-OF-PROGRAM event, and the
corresponding event block is executed.
LOCAL
Protects global data against changes.
Syntax
LOCAL .
Only occurs in subroutines. When the subroutine starts, the value of is stored temporarily, and restored to the variable at the end of the
subroutine.
LOOP Through Extracts
Introduces a loop through an extract dataset.
Syntax
LOOP.
Loops through an extract dataset. The loop ends with an ENDLOOP statement. When the LOOP statement is executed, the system stops
creating the extract dataset of the program, and starts a loop through the entries in the dataset. One record from the extract dataset is read
in each loop pass. The values of the extracted fields are placed in the corresponding output fields of the field group within the loop.
LOOP THROUGH internal tables
Starts a loop through an extract dataset.
Syntax
LOOP AT INTO WHERE .
LOOP AT ASSIGNING WHERE .
LOOP AT REFERENCE INTO WHERE .
LOOP AT TRANSPORTING NO FIELDS WHERE .
Loop through any Internal Table The loop ends with an ENDLOOP statement. If the logical expression is true, each loop pass either
assigns the current line content to the work area ; assigns the current line to a field symbol ; creates a reference to the current line by ; or
does not assign the line content at all. The first operand in each part of must be a component of the internal table. Pointed brackets are part
of the syntax for field symbol names.
With index tables, you can use the additions FROM and TO to restrict the lines that are read by specifying an index range.
LOOP Through Screen Fields
Starts a loop through the table SCREEN.
Syntax
LOOP AT 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.
M
MESSAGE
Displays a message.
Syntax
MESSAGE [WITH ... ] [RAISING ].
MESSAGE ID TYPE NUMBER .
MESSAGE ().
Displays the message of message class as message type . The message type specifies 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 .
MESSAGE TYPE
This variant display a string, , directly as a message of the type .
METHOD
Introduces the implementation of a method in a class.
Syntax
METHOD .
Only occurs in the implementation part of classes. Introduces a statement block that ends with ENDMETHOD. You do not have to specify
any interface parameters, since these are defined in the method declaration.
METHODS
Declares methods in classes and interfaces.
Syntax
METHODS [FOR EVENT OF ]
IMPORTING… [VALUE(][)] TYPE [OPTIONAL]…
EXPORTING… [VALUE(][)] TYPE [OPTIONAL]…
CHANGING … [VALUE(][)] TYPE [OPTIONAL]…
RETURNING VALUE()
EXCEPTIONS … …
[ABSTRACT]
[FINAL]
[REDEFINITION].
You declare a method in the definition part of a class or in the definition of an interface: The IMPORTING, EXPORTING, CHANGING,
RETURNING, and EXCEPTIONS additions define the parameter interface and exceptions of the method. The ABSTRACT addition defines
an abstract class, which cannot be implemented in the same class. The function of a non-abstract method must be implemented using
METHOD. The FINAL addition prevents you from redefining the method in subclasses. The REDEFINITION addition redefines a method of
a superclass. The FOR EVENT addition declares an event handler method for the event of a class or interface.
MODIFY for Database Tables
Inserts or changes lines in database tables.
Syntax
MODIFY FROM .
MODIFY FROM TABLE .
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.
MODIFY for any Internal Table
Changes the content of lines in internal tables of any type.
Syntax
MODIFY TABLE FROM [TRANSPORTING ...]
[ASSIGNING | REFERENCE INTO ].
Copies the work area into the line of the internal table with the same table key as . If you use ASSIGNING or INTO REFERENCE, field
symbol refers to the modified line or the relevant data reference is stored in after the statement. You can use the TRANSPORTING addition
to specify the exact components that you want to change.
MODIFY FROM TRANSPORTING … WHERE .
Copies the work area into the line of the internal table for which the logical expression is true. In each comparison of the logical expression,
the first operand must be a component of the line structure.
MODIFY for Index Tables
Changes the content of lines in index tables.
Syntax
MODIFY FROM [INDEX ] [TRANSPORTING ...]
[ASSIGNING | REFERENCE INTO ].
Copies the work area into the line of the internal table with the index . If you omit the INDEX addition, you can only use the statement within
a LOOP. In this case, you change the current loop line If you use ASSIGNING or INTO REFERENCE, field symbol refers to the modified
line or the relevant data reference is stored in after the statement.
MODIFY for Lists
Changes a list line.
Syntax
MODIFY LINE [INDEX ] [OF CURRENT PAGE|OF PAGE
]
|CURRENT LINE
LINE FORMAT …
FIELD VALUE [FROM ] [FROM ]…
FIELD FORMAT .
Changes either line 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
MODIFY SCREEN
Changes the SCREEN table.
Syntax
MODIFY SCREEN…
Like changing an internal table. The system table SCREEN contains the names and attributes of all of the fields on the current screen.
MODULE
Introduces a dialog module.
Syntax
MODULE OUTPUT |[INPUT].
Introduces the dialog module . The OUTPUT and INPUT additions designate the module as a PBO or PAI module respectively. Each dialog
module ends with ENDMODULE.
MOVE
Assigns values.
Syntax
MOVE TO .
Assigns the contents of the data object to the variable , with automatic type conversion if necessary. Equivalent to = .
MOVE-CORRESPONDING
Assigns values between identically-named components of structures.
Syntax
MOVE-CORRESPONDING TO .
Moves the contents of the components of structure to the components of that have identical names.
MULTIPLY
Multiplies two single fields.
Syntax
MULTIPLY BY .
Multiplies the content of by , and stores the result in . This is equivalent to: m=m*n.
MULTIPLY-CORRESPONDING
Multiplies components of structures.
Syntax
MULTIPLY-CORRESPONDING BY .
All the identically-named subfields of the structures and are multiplied and the results are stored these subfields of .
N
NEW-LINE
Inserts a line break in a list.
Syntax
NEW-LINE [NO-SCROLLING|SCROLLING].
Positions the list display after the page header. The NO-SCROLLING addition prevents the new line from scrolling horizontally.
SCROLLING resets the NO-SCROLLING addition.
NEW-PAGE
Inserts a page break in a list.
Syntax
NEW-PAGE [NO-TITLE|WITH-TITLE]
[NO-HEADING|WITH-HEADING]
[LINE-COUNT]
[LINE-SIZE]
[PRINT ON|OFF].
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.
NODES
Declares an interface work area.
Syntax
NODES .
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 using NODES use a common data area. This statement is used in conjunction with logical databases.
O
ON CHANGE
Introduces a new branch.
Syntax
ON CHANGE OF [OR OR ...].
Opens an ON control structure, which ends with ENDON. The statement block is executed whenever the contents of the field or one of the
other fields has changed since the statement was last executed.
OPEN CURSOR
Opens a database cursor.
Syntax
OPEN CURSOR [WITH HOLD] FOR SELECT
FROM
[WHERE ]
[GROUP BY ]
[HAVING ]
[ORDER BY ].
Opens a cursor with type CURSOR for a SELECT statement. You can use all the clauses of the SELECT statement apart from the INTO
clause. 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.
OPEN DATASET
Opens a file.
Syntax
OPEN DATASET
[FOR INPUT|OUTPUT|APPENDING|UPDATE]
[IN BINARY MODE
|IN TEXT MODE [ENCODING (DEFAULT|UTF-8|NON-UNICODE)]