Day 7

Defining Data in ABAP/4, Part 1

• Chapter Objectives
• Program Buffer and the Roll Area
• Elements of ABAP/4 Syntax
• Defining Data Objects
  • Defining Literals
  • Defining Variables
• Summary
• Q&A
• Workshop
  • Quiz
  • Exercise 1

Chapter Objectives

After you complete this chapter, you should be able to

• Explain the program's roll area and its contents.
• Understand the elements of ABAP/4 syntax.
• Describe the concept of data objects and their visibility.
• Use literals and understand how to code each type.
• Define and use constants.
• Use the data statement to define variables and field strings.
• Understand ABAP/4 data types, and be able to identify the character and numeric data types.
• Understand the ABAP/4 definition of common DDIC data types.

Before proceeding, please turn to Day 2 and take a few minutes to re-read the analysis in the section "Understanding Code Syntax" now.

Program Buffer and the Roll Area

Programs are buffered on the application server in a program buffer. When a user makes a request to run a program, a search is done in the program buffer for it. If it is found, and if it has not been modified in the database, the buffered copy is used. If not, or if the copy in the database is newer, the program is reloaded.

A separate copy of the program is not made in memory for each user who executes it. Instead, all users execute the same copy of the program. The differentiating factor is a separate memory allocation called a roll area. One roll area is allocated per execution per user per program. The system uses the roll area to hold all information about the current execution of the program and all memory allocations. Information such as the variables and their values, the current program pointer, and the list output are all kept in the roll area. For example, suppose a user executes a program and a roll area is allocated. If, without waiting for it to finish, the user switches to another session and starts up the same program again, another roll area is allocated for the second execution of that program. The user has two roll areas, one for each execution of the program. If the user had instead run a different program, he would still have two roll areas, one for each program.

Elements of ABAP/4 Syntax

Each ABAP/4 program is composed of one or more statements. Each statement contains one or more words separated by at least one space. The first word of a statement is the keyword. A statement can include one or more additions, and always ends with a period.

In Listing 7.1, the keywords are select, write, and endselect. Two additions appear on the select statement: where and order by. What is normally called a clause in other languages is called an addition in ABAP/4: It is any word or group of words after the keyword that modifies the behavior of the statement.

Listing 7.1  Illustration of Basic ABAP/4 Syntax

1 select * from ztxlfa1 where lifnr > '0000001050' order by lifnr.
2     write: \ ztxlfa1-lifnr, ztxlfa1-name1, ztxlfa1-land1.
3     endselect.

A statement can begin in any column and can span any number of lines. To continue a statement on another line, break the statement between any two words. A continuation character is not needed. For example, the code in Listing 7.1 can be reformatted as shown in Listing 7.2.

Listing 7.2  This Code Is the Same as Listing 7.1, Only It Has Been Formatted Differently

1 select * from ztxlfa1
2     where lifnr > '0000001050'
3     order by lifnr.
4     write: \ ztxlfa1-lifnr,
5              ztxlfa1-name1,
6              ztxlfa1-land1. endselect.

ABAP/4 code is not case sensitive.

Defining Data Objects

Data objects are memory locations that you use to hold data while the program is running. There are two types of data objects: modifiable and non-modifiable. The types of non-modifiable data objects are literals and constants. The modifiable data objects are variables, field strings, and internal tables. A field string is the ABAP/4 equivalent of a structure. An internal table is the ABAP/4 equivalent of an array.

When the program starts, the memory allocation for each data object occurs in the roll area of the program. While the program is running, you can read the contents of a non-modifiable data object or put data into a modifiable data object and then retrieve it. When the program ends, the system frees the memory for all data objects and their contents are lost.

Data objects have three levels of visibility: local, global, and external. The visibility of a data object indicates from where in the program the data object is accessible.

Locally visible data objects are accessible only from inside the subroutine in which they are defined. Globally visible objects can be accessed from anywhere within the program. Externally visible objects are accessible from outside of the program by another program. Figure 7.1 displays these three levels of visibility pictorially.

Figure 7.1 : The visibility of a data object indicates its accessibility. If it is locally visible, it is only accessible from within a subroutine. If it is globally visible, it is accessible from any-where within a program. If it is externally visible, it is accessible from outside of the program by another program.

In Figure 7.1, the local data objects in subroutine 1A are visible only from within that subroutine. Any statement outside of it cannot access them. Similarly, the local data objects in subroutines 1B and 2A are not accessible from anywhere but within those subroutines.

Any statement in program 1, regardless of where the statement appears, can access the global data objects in program 1. Similarly, any statement in program 2 can access the global data objects in program 2.

The external data objects could be accessed from any statement in program 1 or program 2. In actuality, whether they can be or not depends on the type of external memory area used and the relationship between the two programs. The details of this are described in the sections on SPA/GPA memory and on ABAP/4 memory.

Defining Literals

A literal is a non-modifiable data object. Literals can appear anywhere in a program, and they are defined merely by typing them where needed. There are four types: character string, numeric, floating-point, and hexadecimal.

Character String Literals

Character string literals are case-sensitive character strings of any length enclosed within single quotes. For example, 'JACK' is a character string literal containing only uppercase characters. 'Caesar the cat' is a character string literal containing a mixture of upper- and lowercase characters. Your first program used the character string literal 'Hello SAP world'.

Because a character string literal is enclosed by quotes, you cannot use a single quote by itself in the value of the literal. To represent a single quote, you must use two consecutive single quotes. For example, the statement write 'Caesar''s tail'. will write Caesar's tail, but the statement write 'Caesar's tail' will cause a syntax error because it contains a single quote by itself. The statement write ''''. will cause a single quote to be written to the output page because the two consecutive quotes within quotes are translated to a single quote. Lastly, write: '''', 'Hello Caesar', ''''. will write ' Hello Caesar '.

Here are some examples of invalid character string literals and the correct way to code them. "Samantha" is incorrect; it should be enclosed in single quotes, not double quotes, and thus should be coded 'Samantha'. In 'Never ending, the trailing quote is missing and thus should be coded 'Never ending'. 'Don't bite' should contain two consecutive single quotes; it should be coded 'Don''t bite'.

Numeric Literals

Numeric literals are hard-coded numeric values with an optional leading sign. They are not usually enclosed in quotes. However, if a numeric literal contains a decimal, it must be coded as a character string enclosed within single quotes. If it is not, the syntax error Statement x is not defined. Please check your spelling. will occur. Table 7.1 shows the right and wrong ways to code literals.

For example, 256 is a numeric literal, as is -99. '10.5' is a numeric literal that contains a decimal point, so it is enclosed by single quotes. A literal can be used as the default value for a variable, or it can be used to supply a value in a statement. Examples of invalid literals are: 99- (trailing minus sign), "Confirm" (enclosed in double quotes), and 2.2 (contains a decimal but is not enclosed in quotes).

Floating-Point Literals

Floating-point literals are specified within single quotes as '<mantissa>E<exponent>'. The mantissa can be specified with a leading sign and with or without decimal places, and the exponent can be signed or unsigned, with or without leading zeros. For example, '9.99E9', '-10E-32', and '+1E09' are valid floating-point literals.

Hexadecimal Literals

A hexadecimal literal is specified within single quotes as if it were a character string. The permissible values are 0-9 and A-F. There must be an even number of characters in the string, and all characters must be in uppercase.

Examples of valid hexadecimal literals are '00', 'A2E5', and 'F1F0FF'. Examples of invalid hexadecimal literals are 'a2e5' (contains lowercase characters), '0' (contains an uneven number of characters), "FF" (enclosed in double quotes), and x'00' (should not have a preceding x).

Table 7.1 covers the right and wrong way of coding numeric and hexadecimal literals.

Defining Variables

Two statements are commonly used to define variables in an ABAP/4 program:

• data
• parameters

Using the data Statement to Define Variables

Using data statement, variables can be declared for the program. Variables defined in the data statement are assigned to a data type and can also have defaults.

Syntax for the data Statement

The following is the syntax for defining a variable using the data statement:

data v1[(l)] [type t] [decimals d] [value 'xxx'].

or

data v1 like v2 [value 'xxx'].

where:

• v1 is the variable name.
• v2 is the name of a variable previously defined in the program, or is the name of a field that belongs to a table or structure in the Data Dictionary.
• (l) is the internal length specification.
• t is the data type.
• d is the number of decimal places (used only with type p).
• 'xxx' is a literal that supplies a default value.

Listing 7.3 shows examples of variables defined with the data statement.

Listing 7.3  Examples of Variables Defined with the DATA Statement

1 data f1(2) type c.
2 data f2 like f1.
3 data max_value type i value 100.
4 data cur_date type d value '19980211'.

Variable names can be 1 to 30 characters long. They can contain any characters except
( ) + . , : and must contain at least one alphabetic character.

SAP recommends that variable names should always begin with a character and they should not contain a dash. A dash has special meaning (see field strings below). Instead of a dash, you should use an underscore ( _ ).

The following points also apply to the data statement:

• The default length depends on the data type. (Default lengths are listed in Table 7.2.)
• The default data type is c (character).
• The default initial value is 0, except for data type c, which is blank.
• The value addition only accepts a literal or constant (see below); you cannot use a variable to supply a default value.
• When using the like addition, the variable being defined obtains its length and data type from the referenced variable. You cannot specify them on the same statement with like.
• When using the like addition, the value is not obtained from the referenced variable. You can specify the value addition to give the variable a default value. If you do not, it is assigned a default initial value of 0 (or blank for a character data type).

The data statement can appear anywhere in a program. The definition for a variable must physically come before the statements that access it. If you place a data statement after executable code, the statements above it cannot access the variables it defines. For an example, see Listing 7.4.

Listing 7.4  Example of a Variable That Is Incorrectly Accessed Before It Is Defined

1 report ztx0704.
2 data f1(2) value 'Hi'.
3 write: f1, f2.
4 data f2(5) value 'there'.

The variable F2 is defined on line 4, and the write statement on line 3 is trying to access it. This will generate a syntax error. The data statement on line four should be moved before line 3.

ABAP/4 Data Types

There are two main categories of data in ABAP/4: character and numeric. Variables receive special treatment by the ABAP/4 processor based on their category that goes beyond the usual treatment given by other languages. Therefore, it is especially important for you to be able to recognize and distinguish between the character and numeric data types.

Character Data Types

The character data types are shown in Table 7.2. Notice that they include type n. Internal lengths are given in bytes. A dash in the Max length column appears for fixed length data types.

The Default Initial Value column indicates the value given to the variable by default if you do not specify one using the value addition.

Internal Representation of Variables

Numeric text variables are called numeric character variables and hold unsigned positive integers. Each digit occupies one byte, and internally each is stored as a character. This is a character data type. It can only contain the characters 0-9.

Use numeric text to hold numbers that are used as unique identifiers, such as document numbers, account numbers, and order numbers. Also, use it for variables that hold a numeric extracted from a character data type. For example, if you were to extract the two-character month from a date field and needed a variable to store it, you should use a type n field.

Date and time are fixed length data types. You should not specify a length on the data statement for them. Values for date and time variables are always stored internally as YYYYMMDD and HHMMSS, respectively. The current date is available in the system field sy-datum and the current time in sy-uzeit.

Absolute time values that have millisecond precision are not used in R/3. However, relative time values are available to millisecond precision. To obtain these, use the get run time statement and store them using data type i. See the chapter on runtime analysis for more details.

Numeric Data Types

The numeric data types are shown in Table 7.3. A dash in the Max Length column indicates the length cannot be changed. An asterisk indicates the attribute is machine-dependent.

All of the variables in Table 7.3 are signed. In floating-point variables, the exponent is also signed.

Use integers for variables that will be involved in simple computations or when no decimal points are required. Variables such as counters, indexes, positions, or offsets are good examples.

A decimal variable stores (L*2)-1 digits, where L is the length of the variable in bytes. Decimal values are stored two digits per byte, except the end byte, which contains a single digit and a sign. The decimal point itself is not stored; it is an attribute of the definition. For example, data f1(4) type p defines a variable f1 that is four bytes long and can hold seven digits (plus a sign), as shown in Figure 7.2. data f2(3) type p decimals 2 defines a variable f2 that is three bytes long and can hold five digits (plus a sign). The definition data f3 type p defines a variable f3 capable of holding 15 digits because the default length for type p is 8.

Figure 7.2 : Packed decimal values are stored two digits per byte. The end byte is an exception; it stores a single digit and the sign. The decimal point is not stored and so does not take up any space in the field; it is part of the definition.

Floating-point variables are always approximate. They can be used for calculations requiring very large values or many decimal places. Precision up to 15 decimal places is possible, but this is hardware-dependent.

Mapping DDIC Data Types to ABAP/4 Data Types

Data types in the Data Dictionary are built from the ABAP/4 data types. Table 7.4 shows common Data Dictionary data types and their corresponding ABAP/4 data definitions. L is the length specified in the domain. For a complete list, view the F1 help for the tables statement.

Using the parameters Statement to Define Variables

A parameter is a special type of variable that is defined using the parameters statement. parameters is a lot like the data statement, but when you run the program, the system will display the parameters as input fields on a selection screen before the program actually begins to execute. The user can enter or modify their values and then press the Execute button to begin program execution. You can use both parameters and data in the same program. The rules for parameter names are the same as for variable names, except for the following:

• The maximum length is 8 characters instead of 30.
• In addition to literals and constants, you can also use a variable to supply default a default value.

Syntax for the parameters Statement

The following code is the syntax for defining a variable using the parameters statement.

parameters p1[(l)] [type t] [decimals d] ...

or

parameters p1 like v1 ...
... [default 'xxx'] [obligatory] [lower case] [as checkbox] [radiobutton
    group g].

where:

• p1 is the parameter name.
• v1 is the name of a previously defined variable or parameter, or is the name of a field that belongs to a table or structure in the Data Dictionary.
• (l) is the internal length specification.
• t is the data type.
• d is the number of decimal places (used only with type p).
• 'xxx' is a literal or previously defined variable that supplies a default value.

Listing 7.5 shows examples of parameters defined with the parameters statement.

Listing 7.5  Examples of Parameters Defined Using the PARAMETERS Statement

1 parameters p1(2) type c.
2 parameters p2 like p1.
3 parameters max_value type i default 100.
4 parameters cur_date type d default '19980211' obligatory.
5 parameters cur_date like sy-datum default sy-datum obligatory.

A sample program using parameters is given in Listing 7.6, and the input screen it generates appears in Figure 7.3. Please run this report now.

Figure 7.3 : When you run report ztx0706, the parameters first appear on a selection screen. Obligatory parameters are indicated with question marks. To begin processing, the user must press the Execute button on the Application toolbar.

Listing 7.6  Example of a Program That Accepts Input Parameters Using the PARAMETERS Statement

1  report ztx0706.
2  parameters: p1(15) type c,
3              p2  like p1 obligatory lower case,
4              p3  like sy-datum default sy-datum,
5              cb1 as checkbox,
6              cb2 as checkbox,
7              rb1 radiobutton group g1 default 'X',
8              rb2 radiobutton group g1,
9              rb3 radiobutton group g1.
10  write: / 'You entered:',
11         / '  p1 =', p1,
12         / '  p2 =', p2,
13         / '  p3 =', p3,
14         / '  cb1=', cb1,
15         / '  cb2=', cb2,
16         / '  rb1=', rb1,
17         / '  rb2=', rb2,
18         / '  rb3=', rb3.

The additions to the parameters statement are described in Table 7.5.

The following points also apply to the parameters statement:

When the selection screen is shown, obligatory fields contain a question mark. These indicate to the user which fields must be filled in before continuing.

• The default data type is c (character).
• The default value is 0, except for data type c, which is blank.
• The value addition accepts a literal, a sy variable, or a variable previously defined in the program.
• When using the like addition, the parameter being defined obtains its length and data type from the referenced variable. You cannot specify them on the same statement with like.
• When using the like addition, the value is not obtained from the referenced variable. You can specify the value addition to give the parameter a default value. If you do not, it is assigned a default initial value of 0 (or blank for a character data type).
• Like data, the parameters statement can appear anywhere in a program, but the definition must physically come before the statements that access it.
• Parameters appear on a selection screen in the same order that they are defined in the program.
• All parameters statements, no matter where they appear in the program, are collected together by the ABAP/4 interpreter and displayed on the selection screen
  at the same time. Even if you put a parameter statement in the middle of the program, that parameter will still be displayed on the selection screen before the program executes.
• The parameters are displayed in an SAP standard format. To modify their appearance, for example, to move the input field left or move the label right, use the selection-screen statement, described in Day 21.

Using the Addition: lower case

All values entered into a parameter are translated into uppercase by default. To turn off this translation, use the addition lower case. This addition only applies to character fields.

Using the Addition: as checkbox

A check box has only two states: ticked and clear. You use them when you want to present the user with an on/off or true/false type of choice. You can use more than one check box on a screen. If you have multiple check boxes on a screen, they operate completely independently from each another.

To display a parameter as a check box, use the addition as checkbox. You cannot specify a data type or length; it will default to type c and length 1. The parameter will contain a capital X if the check box is ticked; it will contain a blank if the check box is clear. If the check box should initially contain a tickmark, use a default value of capital X. Run program ztx506 to see the check box.

Space and capital X are the only valid values. No other values are valid for a check box.

Using the Addition: radiobutton group g

Like check boxes, a radio button also has two states: selected and not selected. Unlike check boxes, radio buttons never operate alone, they operate only in groups. You can have any number of radio buttons in a group, but only one can be selected at a time. They are used when you need to present the user with a list of alternatives in which only one option can be chosen.

To display a parameter as a radio button, use the addition radiobutton group g. You cannot specify a data type or length; it will default to type c and length 1. g is an arbitrary group name one to four characters long. You can have more than one group in a program.

The parameter will contain a capital X if the radio button is selected; it will contain a blank if it is not selected. To be initially selected, the radio button should contain a default value of capital X. No other values are valid for a radio button. Try it by running program ztx006.

Parameter Input Field Labels

On the selection screen to the left of each parameter's input field is a label. By default, the label is the same as the name of the parameter. You can set these labels manually. For parameters defined like Data Dictionary fields, you can retrieve the label automatically from the data element.

Changing Parameter Labels

Start the ScreenCam "How to Change Input Field Labels" now.

To change a parameter's input field label:

1. Begin at the ABAP/4 Editor: Edit Program screen.
2. Choose the menu path Goto->Text Elements. The ABAP/4 Text Elements screen is displayed. In the Program Field is your current program name.
3. Select the Selection Texts radio button.
4. Press the Change button. The ABAP/4 Text Elements: Change PARAMETERS/SELECT-OPTIONS screen is displayed. Here, you can manually enter labels in the Text column.
5. Type field labels in the Text column.
6. For a parameter defined like a DDIC field, you can retrieve labels from the data element. To retrieve a label from the data element for a single field, position your cursor on the field and choose the menu path Utilities->Copy DD Text. The medium-length field label from the data element appears, the Text field is protected, and the Type field changes to contain the characters DDIC. At the bottom of the window the message Dictionary texts transferred for selection xxx appears.
7. To remove protection from a single field, position your cursor on the field and choose the menu path Utilities->No DD Text. The Text field becomes unprotected and the characters DDIC disappear from the Type field. At the bottom of the window the message Text for xxx no longer transferred from Dictionary. appears.
8. To retrieve field labels for all parameters that are defined like DDIC fields, choose the menu path Utilities->Copy DD Texts. Field labels for all DDIC fields are retrieved and protected. Any existing values in the Text column are overwritten. At the bottom of the window the message All selection texts transferred from Dictionary appears.
9. Press the Save button on the Application toolbar. At the bottom of the window, the message Text elements for program xxxxx in language E accepted appears.
10. Press the Back button on the Application toolbar twice to return to your program.

If you want to override the DDIC label for some fields but not others, type your labels in the Text column and then choose the menu path Utilities->Supplement DD Texts. All blank Text fields will be filled from the Data Dictionary, leaving the values you entered alone.

If the label changes in the DDIC, the label onscreen is not automatically updated. To update it, you must go to the ABAP/4 Text Elements: Change PARAMETERS/SELECT-OPTIONS screen and choose either menu path Utilities->Copy DD Text or Utilities->Copy DD Texts.

Effect of Parameter Definitions: type Versus like

Always use the like addition to define a parameter. When you use it, the parameter acquires the following attributes from the Data Dictionary:

• F1 help is acquired from the Documentation button in the data element.
• F4 help is acquired if your parameter is like one that has a check table.

A field label is acquired from the data element.

In addition to the advantages provided by the above,

• A field label obtained from the Data Dictionary is guaranteed to be consistent with the field label presented by other programs for the same field (provided they also obtain them from the DDIC). This eliminates the confusion of having two fields that are labeled differently refer to the same data.
• Modifications to the data type or length in the DDIC are automatically reflected by your program.

In view of all of these advantages, you should always use the like addition to define a parameter. This applies even to check boxes and radio buttons. If necessary, you should create a structure in the DDIC so that you can use like and at a minimum, provide F1 help. Note that F1 help is available even for radio buttons and check boxes.

Effect of a Check Table on a Parameter

If you define a parameter using like st-f1, and st-f1 has a check table, a down arrow appears at the end of the input field when you run the program. You can press the down arrow to obtain a list of valid values for that field. However, the value entered into a parameter input field is not validated against the check table. Validation only occurs for dialog screens such as those you have seen in transaction se16. The user can type any value into the input field and it will be passed to the program when he presses the Execute button.

Summary

• Programs are buffered in a program buffer on the application server. There is only one copy, so a roll area is necessary for each execution. The roll area contains the values of program variables and the current program pointer.
• An ABAP/4 program is composed of statements, each of which begins with a keyword and ends with a period. Statements can begin in any column and can span several lines.
• A data object is a memory location that contains data during the runtime of the program. The non-modifiable data objects are literals and constants. The modifiable data objects are variables, field strings, and internal tables. Data objects are allocated in the roll area of the program and are freed when the program ends.
• Data objects have three levels of visibility: local, global, and external. The visibility of a data object indicates from where the data object is accessible.
• Literals are data that is hard-coded in your program. Constants can be used to replace literals, thereby making the program easier to maintain.
• Data types are segregated into two broad categories: character and numeric. The character data types are c, n, d, t, and x; the numeric data types are i, p, and f.
• Variables can be defined using the data and parameters statements. The difference is that when the program is executed, the system displays an input field for each parameter on a selection screen. The user can enter values or change default values.
• Values entered into parameter input fields are by default converted to uppercase. To stop the conversion, use the addition lower case.
• You can change the parameter input field labels via the menu path Goto->Text Elements.

Q&A

Workshop

The Workshop provides you two ways for you to affirm what you've learned in this chapter. The Quiz section poses questions to help you solidify your understanding of the material covered and the Exercise section provides you with experience in using what you have learned. You can find answers to the quiz questions and exercises in Appendix B, "Answers to Quiz Questions and Exercises."

Quiz

What is wrong with these literals, if anything? (There can be more than one error in each, and some do not have errors.) Write the correct definitions.

1. Character string literal: "Don't bite."
2. Floating-point literal: '+2.2F03.3'
3. Numeric literal: -99
4. Hexadecimal literal: x'0000f'
5. Numeric literal: 9.9-
6. Floating-point literal: '1.1E308'
7. Hexadecimal literal: 'HA'
8. Character string literal: ''''
9. Character string literal: '''"'''

What is wrong with these data definitions? (There can be more than one error in each, and some do not have errors.) Write the correct definitions.

1. data first-name(5) type c.
2. data f1 type character.
3. data f1 (20) type c.
4. data 1a(5) type i.
5. data per-cent type p value 55.5.
6. data f1(2) type p decimals 2 value '12.3'.

Exercise 1

Write a program using parameters for Figure 7.4.

Figure 7.4 : .

---

© Copyright, Macmillan Computer Publishing. All rights reserved.