Day 14

The write Statement

• Chapter Objectives
• Default Lengths and Formatting
  • Default Lengths
  • Packed Fields
  • Default Formatting
  • Sample Program Demonstrating Default Formatting
• Additions to the write Statement
  • Syntax for the write Statement
  • Understanding the Position Specification
  • Understanding the Length Specification
  • Working with Subfields
  • Using the under Addition
  • Using the no-gap Addition
  • Using Edit Masks
  • Using Conversion Exits
  • Working with Date Formatting
  • Using the no-zero and no-sign Additions
  • Specifying Decimals and Rounding
  • Shifting Justification
• Summary
• Q&A
  
• Workshop
  • Quiz
  • Exercise 1

Chapter Objectives

After you complete this chapter, you will be able to:

• Understand the effect of data types on output
• Use the formatting options of the write statement
• Use conversion exits and detect their presence within domains

Default Lengths and Formatting

If you do not specify any length or formatting options when you use the write statement, the system uses a default format and length based on the data type of each variable written. The following sections describe these defaults.

Default Lengths

The output length of a field is the number of characters used to display the value of that field. Output length is used by the write statement to allocate space on the output list for a field. Fields defined within a program via the data statement have a default output length as shown in Table 14.1.

Fields from the Data Dictionary have DDIC data types such as DEC, CHAR, CURR, and so on. These are all based on ABAP/4 data types and they inherit default length and format from the ABAP/4 data type. To determine the ABAP/4 data type, and thus the default output format, look up the ABAP/4 keyword documentation for the tables statement. To do this, place your cursor on a tables statement within your code and press the F1 key.

In addition, DDIC fields have their output length and number of decimals defined in the domain. These fields override the default, and are shown in Figure 14.1.

Figure 14.1 : The Output Length and Decimal Places fields override the defaults inherited from the ABAP/4 data types.

The output length and decimal places are inherited by all fields that are created from a domain. For example, in Figure 14.1, the field length is 15, indicating that 15 digits can be stored in any field that uses this domain. The output length is 20, so the output enables enough room for a decimal point, a sign, and three thousands separators.

Packed Fields

The default output length of a type p field is twice the defined field length. If decimal places are defined, the default output length is increased by 1 so that it is 2 * field length + 1. Table 14.2 shows sample default output lengths for type p fields.

Default Formatting

The default format is derived from the data type of the variable. Table 14.1 described how the output will be formatted for each ABAP/4 data type. The output of numeric fields (types p, i, and f) is right-justified with leading zeros suppressed and the rest are left-justified. Additional type-specific formatting also applies.

Default Date Formatting

Date values are output according to the Date Format setting in the User Defaults as long as the output length is 10 or greater. The default output length is 8, so you must increase it to at least 10 before the separators can be seen. Defining a variable using like (for example, like sy-datum) causes the output length to be taken from the domain.

Default Time Formatting

Time values are output in HH:MM:SS format as long as the output length is 8 or greater. The default output length is 6, so you must increase it to at least 8 before the separators can be seen. Defining a variable using like (for example, like sy-uzeit) causes the output length to be taken from the domain.

Default Numeric Formatting

The population of North America writes a number as 1,234.56. In other countries, such as those in Europe, the same number is written as 1.234,56-the use of the comma and decimal are interchanged. R/3 enables each individual user to specify one of these formats via the user profile setting Decimal Notation (from any screen, choose the menu path System->User Profile->User Defaults).

Table 14.3 shows the effect of the Decimal Notation setting on numeric output.

The default output format for floating-point (type f) variables is via scientific notation. This can be modified by using an edit mask or conversion exit.

Overflow Formatting

When dealing with numbers that are too big for the output field, the system puts an asterisk in the first column of output to indicate overflow. However, before that occurs, the system tries to output all the digits, if possible. Thousands separators are only output if there is enough room in the output field. If there isn't, they are dropped one at a time beginning from the left of the field and working to the right. If the number is positive and will fit in the output by using the sign field, the system will use it.

Sample Program Demonstrating Default Formatting

Listing 14.1 illustrates default length and formatting. It also illustrates handling of numbers that are close to overflowing the output field.

Listing 14.1  Default Formatting and Lengths

1  report ztx1401.
2  data: t1    type t            value '123456',
3        t2    like sy-uzeit     value '123456',
4        d1    type d            value '19980201',
5        d2    like sy-datum     value '19980201',
6        f1    type f            value '-1234',
7        i1    type i            value '12345678-',
8        i2    type i            value '123456789-',
9        i3    type i            value '1123456789-',
10       i4    type i            value '1123456789',
11       n1(5) type n            value 123,
12       p1(5) type p            value '123456789-',
13       c1(5) type c            value 'ABC',
14       x1(2) type x value 'A0B0'.
15
16 write: /     t1,  26 'type t: default output length = 6',
17        /(8)  t1,  26 'type t: increased output length to 8',
18        /(12) t1,  26 'type t: increased output length to 12',
19        /     t2,  26 'type t: default output length = 8 (from domain)',
20        /     d1,  26 'type d: default output length = 8',
21        /(10) d1,  26 'type d: increased output length to 10',
22        /     d2,  26 'type d: default output length = 10 (from domain)',
23        /     f1,  26 'type f: default output length = 22',
24        /     i1,  26 'type i: default output length = 11',
25        /     i2,  26 'type i: same output length, more digits',
26        /     i3,  26 'type i: same output length, even more digits',
27        /(10) i3,  26 'type i: smaller output length, negative number',
28        /(10) i4,  26 'type i: smaller output length, positive number',
29        /     n1,  26 'type n: default output length = field length',
30        /     p1,  26 'type p: default output length = 2 * length = 10',
31        /(12) p1,  26 'type p: output length increased to 12',
32        /(15) p1,  26 'type p: output length increased to 15',
33        /     c1,  26 'type c: output length = field length (left just)',
34        /     x1,  26 'type x: default output length = 2 * length = 4'.

The code in Listing 14.1 produces this output:

123456                   type t: default output length = 6
12:34:56                 type t: increased output length to 8
12:34:56                 type t: increased output length to 12
12:34:56                 type t: default output length = 8 (from domain)
19980201                 type d: default output length = 8
1998/02/01               type d: increased output length to 10
1998/02/01               type d: default output length = 10 (from domain)
-1.234000000000000E+03   type f: default output length = 22
12,345,678-              type i: default output length = 11
123456,789-              type i: same output length, more digits
1123456789-              type i: same output length, even more digits
*23456789-               type i: smaller output length, negative number
1123456789               type i: smaller output length, positive number
00123                    type n: default output length = field length
123456789-               type p: default output length = 2 * length = 10
123,456,789-             type p: output length increased to 12
   123,456,789-          type p: output length increased to 15
ABC                      type c: output length = field length (left just)
A0B0                     type x: default output length = 2 * length = 4

• Line 16 writes a type t variable using its default length of 6. There is no room for the separators, so they are not written.
• Line 17 writes the same variable using an output length of 8, which was specified on the write statement. This output length overrides the default output length and provides enough room in the output to include the separators.
• Line 18 shows that if the output field is larger than 8 characters, the time field is output left-justified within that field by default.
• Line 19 writes out a field defined like sy-uzeit. Within the domain for sy-uzeit, the Output Length field is set to 8. Therefore, the output length for field t2 is also 8, which provides enough room to write the separators as well.
• Line 20 writes out a type d field that has a default output length of 8. There is not enough room for separators, so the field does not contain separators. However, the year/month/day order is still determined from the user defaults.
• Line 21 writes out the same date field, this time increasing the output length to 10 to allow for separators.
• Line 22 writes out field d2. The length of d2 is obtained from the domain for sy-datum.
• Line 23 writes out a floating-point field showing scientific notation and a leading sign.
• Line 24 writes out an integer using the default length of 11.
• Line 25 writes out a bigger integer using the same length. The first thousands separator is dropped to enable the extra digit to be written.
• Line 26 increases the number again by one digit, causing the second separator to be dropped.
• Line 27 writes out the same number, this time decreasing the output length by 1, and the overflow indicator is seen in the first character of the output field.
• Line 28 writes the same number using the same length, but this time the number is positive. The system shifts the number right and uses the sign field to prevent overflow.
• Line 29 writes a numeric field showing that it is right-justified and padded on the left with leading zeros.
• Line 30 writes a packed decimal field showing the default output length and the dropping of separators.
• Lines 31 and 32 increase the output length to 12 and 15, showing the separators and right justification.
• Line 33 shows a character field left-justified in the output field.
• Line 34 shows the output from a hexadecimal field.

Additions to the write Statement

This section details some of the specific output specifications that can be used with the write statement.

Syntax for the write Statement

The following is the syntax for the write statement.

write [at] [/p(l)] v1[+o(sl)]
       (1)  under v2 | no-gap
       (2)  using edit mask m | using no edit mask
       (3)  mm/dd/yy   | dd/mm/yy  
       (4)  mm/dd/yyyy | dd/mm/yyyy
       (5)  mmddyy     | ddmmyy     | yymmdd
       (6)  no-zero
       (7)  no-sign
       (8)  decimals n
       (9)  round n
       (10) currency c | unit u
       (11) left-justified | centered | right-justified

where:

• v1 is a literal, variable, or field string name.
• p, l, and n are numeric literals or variables.
• p is the position specification. It identifies the output column in which the output field should begin.
• l is the length specification. It identifies the length of the output field in which the value should be written.
• o is a subfield offset specification that can contain numeric literals only.
• sl is a subfield length specification that can contain numeric literals only.
• m is an edit mask.
• c is a currency key (from table tcurc).
• u is a unit of measure (from table t006).
• n is a numeric literal or variable.

The following points apply:

• If either p or l is a variable, the word at is required.
• A slash (/) begins a new line before writing the variable value.

If no additions are specified and two write statements are executed (such as write: v1, v2.), the value of v2 appears on the same line as that of v1 separated from it by one space. If the value of v2 will not fit on the remainder of the current line, it appears on the next line. If the output length of v2 is greater than the line length, the output is truncated on the right. If the value is output right-justified (as with type p variables) before truncating it on the right, it will be shifted left as long as there are leading blanks to avoid truncating it. Separators are also removed, if necessary, to avoid truncation.

Understanding the Position Specification

Referring to the syntax given above, p specifies the output column. The output value can overwrite all or part of a preceding write. The program in Listing 14.2 illustrates the effect of a series of write statements. Table 14.4 shows the cumulative effect of each write, in sequence, to show how the output is arrived at.

Listing 14.2  A Series of write Statements to Illustrate the Effect of the Output Column Specification

1  report ztx1402.
2  data f1(4) type p value 1234.
3  write: / '----+----1----+--',
4         / '12345678901234567'.
5  skip.
6  write /1 'X'.
7  write    'YZ'.
8  write  2 'YZ'.
9  write  3 'ABC'.
10 write  4 f1.
11 write  7 f1.
12 write  'Z'.

The code in Listing 14.2 produces this output:

----+----1----+--
12345678901234567
               
XYA  1  1,234  Z

• Lines 3 and 4 write out a ruler so that you can see the output columns.
• Line 6 writes an 'X' beginning in column 1.
• Line 7 writes 'YZ' beginning one space after the 'X'.
• Line 8 writes 'YZ' beginning in column 2. This overwrites the space and the 'Y' that was written previously.
• Line 9 writes 'ABC' beginning in column 3. This overwrites the two 'Z's, plus one space.
• Line 10 writes f1 beginning in column 4. The default output length of f1 is 8; the default format is right-justified with the last character reserved for the sign. The three leading blanks overwrite the existing output beginning in column 4.
• Line 11 writes f1 again, this time beginning in column 7.
• Line 12 writes 'Z' one space after f1. In the output, there appears to be two spaces. The first space after the 4 is the sign field for f1. Then one space is written, and then 'Z' in column 16.

Understanding the Length Specification

In the syntax description for the write statement, o specifies the output length. This is the number of characters on the output line used to hold the output value.

Position and length specifications are always optional. They can be specified using either a literal or a variable. If either one is a variable, it must be preceded by the word at. at is optional if the position and length are both literals, but it is required if either is a variable.

If a slash (/) precedes a position or length specification, there cannot be an intervening space between them. Listing 14.3 provides examples.

Listing 14.3  Illustrating the Use of the Position and Length Specifications

1  report ztx1403.
2  data: f1(4) type p value 1234,
3        p     type i value 5,
4        l     type i value 8.
5 
6  write: / '----+----1----+--',
7         / '12345678901234567'.
8  skip.
9  write /(2) 'XYZ'.
10 write /(4) 'XYZ'.
11 write      'ABC'.
12 write /5(4) f1.
13 write at /p(l) f1.

The code in Listing 14.3 produces this output:

----+----1----+--
12345678901234567
                 
XY               
XYZ  ABC         
    1234         
      1,234                 

• Line 6 writes the first two characters of 'XYZ'.
• Line 7 writes 'XYZ' using four characters of output. Default formatting is used, so the value is left-justified and padded on the right with blanks.
• Line 8 writes 'ABC' one space after the previous value. The previous value was padded on the right with one blank. Another blank is added, and then 'ABC' is written.
• Line 9 writes f1 in a field that is four characters long beginning in column 5. The system removes the separators to make the value fit into four characters.
• Line 10 writes f1 into a field that is eight characters long beginning in column 5. Variables are used, so the word at is required. Default formatting applies, so the value is right-justified with leading zeros suppressed and, because there is enough room, separators are also written.

Working with Subfields

You can specify a subfield in the write statement by using offset and length specifications immediately after the value without an intervening space. (If necessary, refer to the previous section on additions to the write statement.) You cannot use a subfield with a literal or a numeric field (types p, i, and f). Listing 14.4 provides examples.

Listing 14.4  Using Subfields

1  report ztx1404.
2  data f1(4) type c value 'ABCD'.
3 
4  write: / '----+----1----+--',
5         / '12345678901234567'.
6  skip.
7  write  / f1(2).
8  write  / f1+1(2).
9  write: /(2) f1+2(1), f1.

The code in Listing 14.4 produces this output:

----+----1----+--
12345678901234567 
                  
AB                
BC                
C  ABCD           

• Line 7 writes the first and second characters of f1.
• Line 8 writes the second and third characters of f1.
• Line 9 writes the third character of f1 beginning on a new line in a field that is two characters long. It is left-justified in that field and padded on the right with blanks. It then writes out the entire contents of f1 with an intervening blank beforehand.

Using the under Addition

Using under causes the first character of the field to be positioned in the same column as the first character of a previously written field. You cannot use under with an explicit position specification. Listing 14.5 shows examples.

Listing 14.5  Using the under Addition

1  report ztx1405.
2  tables: ztxlfa1.
3 
4  select * up to 5 rows from ztxlfa1 order by lifnr.
5      write: /1  ztxlfa1-lifnr,
6              15 ztxlfa1-land1,
7              25 ztxlfa1-name1,
8             /   ztxlfa1-spras under ztxlfa1-land1,
9                 ztxlfa1-stras under ztxlfa1-name1.
10     skip.
11     endselect.

The code in Listing 14.5 produces this output:

1000          CA        Parts Unlimited        
              E         111 Queen St.          
                                               
1010          CA        Industrial Pumps Inc.  
              E         1520 Avenue Rd.        
                                               
1020          CA        Chemical Nation Ltd.   
              E         123 River Ave.         
                                               
1030          CA        ChickenFeed Ltd.       
              E         8718 Wishbone Lane     
                                               
1040          US        Motherboards Inc.      
              E         64 BitBus Blvd.        

• Line 6 writes the land1 field beginning in column 15.
• Line 7 writes the name1 field beginning in column 25.
• Line 8 writes the spras field beginning in the same column as land1. It consequently is written beginning in column 15.
• Line 9 writes the stras field beginning in the same column as name1. It is therefore written beginning in column 25.

Using the no-gap Addition

Using no-gap suppresses the intervening gap automatically placed after a field if the following field has no column specification. Listing 14.6 illustrates the use of no-gap.

Listing 14.6  Using no-gap

1  report ztx1406.
2  data f1(4) value 'ABCD'.
3 
4  write: / f1, f1,
5         / f1 no-gap, f1,
6         / '''', f1, '''',
7         / '''', 2 f1, 6 '''',
8         / '''' no-gap, f1 no-gap, ''''.

The code in Listing 14.6 produces this output:

ABCD ABCD
ABCDABCD 
' ABCD ' 
'ABCD'   
'ABCD'   

• Line 4 writes f1 twice on the same line. Because there is no position specification for the second f1, a single intervening space is written before it.
• Line 5 also writes f1 twice. Using no-gap after the first causes the two values to appear in the output without an intervening space.
• Line 6 writes f1 with a single quote on either side. Intervening spaces appear without the use of no-gap.
• Line 7 writes f1 enclosed by single quotes. Position specifications cause the quotes to appear without intervening spaces.
• Line 8 uses no-gap to achieve the same output.

Using Edit Masks

Edit masks enable you to:

• Insert characters into the output
• Move the sign to the beginning of a numeric field
• Artificially insert or move a decimal point
• Display a floating-point number without using scientific notation

Anywhere within an edit mask, the underscore character (_) has special meaning. At the beginning of an edit mask, V, LL, RR, and == have special meaning. All other characters are transferred without change to the output.

Underscores within an edit mask are replaced one-by-one with the characters from the source field (the field you are writing out). The number of characters taken from the source field will be equal to the number of underscores in the edit mask. For example, if there are three characters in the edit mask, at most three characters from the source field will be output. All other characters in the edit mask are inserted into the output. You also usually need to increase the length of the output field to accommodate the extra characters inserted by the mask.

For example, the statement write (6) 'ABCD' using edit mask '_:__:_' writes A:BC:D. Characters are taken from the source field one at a time, and characters from the edit mask are inserted at the points indicated by the mask. The statement write 'ABCD' using edit mask '_:__:_' only writes A:BC because the default output length is equal to the length of the source field (4).

If there are fewer underscores in the mask than there are in the source field, the default is to take the left-most n characters from the source field, where n equals the number of underscores in the edit mask. This can also be explicitly specified by preceding the edit mask with LL. For example, write 'ABCD' using edit mask 'LL__:_' takes the left-most three characters and writes out AB:C. Using RR instead takes the right-most three characters, so write 'ABCD' using edit mask 'RR__:_' will write out BC:D.

If there are more underscores than there are source field characters, the effect of LL is to left-justify the value in the output; RR right-justifies the value (see Listing 14.7 for an example).

An edit mask beginning with a V, when applied to a numeric field (types i, p, and f), causes the sign field to be displayed at the beginning. If applied to a character field, a V is actually output.

Listing 14.7  The Effect of Various Edit Masks

1  report ztx1407.
2  data: f1(4) value 'ABCD',
3        f2    type i value '1234-'.
4 
5  write: / ' 5. ', f1,
6         / ' 6. ', (6) f1 using edit mask '_:__:_',
7         / ' 7. ', f1 using edit mask 'LL_:__',
8         / ' 8. ', f1 using edit mask 'RR_:__',
9         / ' 9. ', f2 using edit mask 'LLV______',
10        / '10. ', f2 using edit mask 'RRV______',
11        / '11. ', f2 using edit mask 'RRV___,___',
12        / '12. ', f2 using edit mask 'LLV___,___',
13        / '13. ', f1 using edit mask 'V___'.

The code in Listing 14.7 produces this output:

 5.  ABCD      
 6.  A:BC:D    
 7.  A:BC      
 8.  B:CD      
 9.  -1234     
10.  -  1234   
11.  -  1,234  
12.  -123,4    
13.  VABC      

• Line 5 outputs f1 without any edit masks.
• Line 6 outputs all four characters of f1 using colons to separate them.
• There are three underscores in the edit mask on line 7, but four characters in f1. Therefore, the first three characters of f1 are used in the edit mask.
• Line 8 takes the last three characters of f1 and applies them to the edit mask.
• There are six underscores in the edit mask on line 9, more than the four characters from f1. The value of f1 is output left-justified with a leading sign.
• On line 10, the value of f1 is output right-justified with a leading sign.
• Lines 11 and 12 show the effect of combining inserted characters with justification. The inserted characters do not move relative to the output field.
• Line 13 shows the effect of using a V with a character field. The V itself is output.

Using Conversion Exits

A conversion exit is a called routine that formats the output. An edit mask that begins with == followed by a four-character ID calls a function module that formats the output. That four-character ID is known as a conversion exit, or conversion routine. (Function modules are covered in a subsequent chapter, but, for now, think of a function module as a subroutine within another program.) The name of the function module will be CONVERSION_EXIT_XXXX_OUTPUT, where XXXX is the four-character id that follows ==. For example, write '00001000' using edit mask '==ALPHA' calls the function module CONVERSION_EXIT_ALPHA_OUTPUT. The write statement passes the value first to the function module, which changes it in any desired way and then returns the changed value, and that value is written out. This particular exit (ALPHA) examines the value to determine whether it consists entirely of numbers. If it does, leading zeros are stripped and the number is left-justified. Values containing non-numerics are not changed by ALPHA. SAP supplies about 60 conversion exits for various formatting tasks. After Chapter 19, "Modularization: Function Modules, Part 1," on function modules, you will know enough to be able to create your own conversion exits.

Conversion exits are particularly useful for complex formatting tasks that are needed in more than one program. To illustrate, the conversion exit CUNIT automatically converts the code representing a unit of measure into a description meaningful in the current logon language. For example, within R/3, the code for a crate of materials is KI. (KI is an abbreviation of kiste, the German word for "box.") However, CUNIT converts KI to the English mnemonic CR. Therefore, when logged on in English, write: '1', 'KI' using edit mask '==CUNIT'. writes 1 CR. For a user signed on in German, the output would be 1 KI. Using such a conversion exit enables a standard set of codes stored in the database to be automatically converted to be meaningful to the current logon language whenever output to a report.

Conversion Routines within a Domain

A conversion exit can also be placed into the Convers. Routine field in a domain. The exit is inherited by all fields that use that domain, and will be automatically applied when the value is written out. Figure 14.2 shows that domain ztxlifnr uses the conversion routine ALPHA.

Figure 14.2 : Notice the contents of the Convers. Routine field.

Therefore, whenever ztxlfa1-lifnr is written, the value first passes through the function module CONVERSION_EXIT_ALPHA_OUTPUT, which strips leading zeros from numeric values.

A conversion exit within a domain can be turned off by specifying using no edit mask on the write statement.

Listing 14.8 illustrates the use of conversion exits.

Listing 14.8  Using Conversion Exits

1  report ztx1408.
2  tables: ztxlfa1, ztxmara.
3  data: f1(10) value '0000001000'.
4 
5  write: / f1,
6         / f1 using edit mask '==ALPHA'.
7 
8  skip.
9  select * from ztxlfa1 where lifnr = '00000010000'
10                          or lifnr = 'V1'
11                       order by lifnr.
12     write: / ztxlfa1-lifnr,      "domain contains convers. exit ALPHA
13            / ztxlfa1-lifnr using no edit mask.
14     endselect.
15
16 skip.
17 select single * from ztxmara where matnr = 'M103'.
18 write: /      ztxmara-matnr,
19          (10) ztxmara-brgew,
20               ztxmara-gewei.      "domain contains convers. exit CUNIT
21 set locale language 'D'.
22 write: /      ztxmara-matnr,
23          (10) ztxmara-brgew,
24               ztxmara-gewei.      "domain contains convers. exit CUNIT

The code in Listing 14.8 produces this output:

0000001000                      
1000                            
                                
1000                            
0000001000                      
V1                              
V1                              
                                
M103                  50.000  CR
M103                  50.000  KI

• Line 5 writes the value from f1.
• Line 6 writes the same value but applies conversion exit ALPHA. Before being written, f1 is passed to the function module CONVERSION_EXIT_ALPHA_OUTPUT, which detects that the value is entirely numeric and strips off leading zeros and left-justifies it.
• Line 9 retrieves two records from ztxlfa1and and writes the lifnr field twice for each.
• The domain for ztxlfa1-lifnr contains the conversion exit ALPHA, so line 12 writes lifnr using that conversion exit.
• Line 13 writes lifnr out, but turns off the conversion exit. This causes the actual value in the table to be written out.
• Line 17 selects a single record from ztxmara.
• Line 20 writes gewei (unit of weight) using conversion exit CUNIT in the domain.
• Line 21 changes the text environment to German. This is equivalent to logging on in German.
• Line 24 writes the same gewei value, but this time CUNIT displays the German mnemonic.

Displaying Existing Conversion Exits

To display the existing conversion exits, use the following procedure.

Start the ScreenCam "How to Display Existing Conversion Exits" now.

1. From the Development Workbench screen, choose the menu path Overview->Repository Infosys. The ABAP/4 Repository Information System screen is displayed.
2. Click on the plus (+) beside Programming. The tree expands.
3. Click on the plus (+) beside Function Library. The tree expands.
4. Double-click on the line Function Modules. The ABAP/4 Repository Information System: Function Module screen is displayed.
5. In the Function Module field, enter CONVERSION_EXIT_*_OUTPUT (the field is scrollable; you can enter more characters into it than it can display).
6. Press the Execute button on the Application toolbar. The Function Modules screen is displayed. All of the conversion exits that can be used on the write statement will be listed here.

Working with Date Formatting

Date formatting specifications, for the most part, do not do what you think they will. Most pull their format from the Date Format specification in the user defaults (menu path System->User Profile->User Defaults).

Table 14.5 contains a description of the effect of each.

Listing 14.9 illustrates the use of the date format specifications.

Listing 14.9  Using Date Format Specifications

1  report ztx1409.
2  data: f1 like sy-datum value '19981123',
3        begin of f2,
4            y(4),
5            m(2),
6            d(2),
7            end of f2,
8        begin of f3,
9            d(2),
10           m(2),
11           y(4),
12           end of f3,
13       begin of f4,
14           m(2),
15           d(2),
16           y(4),
17           end of f4.
18
19 write: / f1,            "user profile sets format
20        / f1 mm/dd/yyyy, "user profile sets format
21        / f1 dd/mm/yyyy, "user profile sets format
22        / f1 mm/dd/yy,   "user profile fmt, display with 2-digit year
23        / f1 dd/mm/yy,   "user profile fmt, display with 2-digit year
24        / f1 mmddyy,     "user profile fmt, 2-digit year, no separators
25        / f1 ddmmyy,     "user profile fmt, 2-digit year, no separators
26        / f1 yymmdd,     "yymmdd format, no separators
27        / f1 using edit mask '==IDATE',
28        /(11) f1 using edit mask '==SDATE'.
29
30 f2 = f1.
31 move-corresponding f2 to: f3, f4.
32 write: /(10) f3 using edit mask '__/__/____', "dd/mm/yyyy format
33        /(10) f4 using edit mask '__/__/____'. "mm/dd/yyyy format

The code in Listing 14.9 produces this output:

1998/11/23   
1998/11/23   
1998/11/23   
98/11/23     
98/11/23
981123       
981123       
981123       
1998NOV23    
1998/NOV/23  
23/11/1998   
11/23/1998   

• Line 2 defines f1 like sy-datum. The output length in the domain for sy-datum is 10, so separators will be displayed when the value of f1 is written out.
• Lines 19, 20, and 21 all do the same thing: They write f1 using the format specified in the user's profile.
• Lines 22 and 23 both do the same thing: They write f1 using the format specified in the user's profile, but using a two-digit year.
• Lines 24 and 25 both do the same thing: They write f1 using the format specified in the user's profile using a two-digit year, but without separators.
• Line 27 formats the date using the conversion exit IDATE. The output of IDATE is yyyymmmdd format.
• Line 28 formats the date using the conversion exit SDATE. The output of SDATE is yyyy/mmm/dd format.
• Lines 30 through 33 show how to create your own output format. If you were to do this in real life, it would be better to put this code into a conversion exit and then name the conversion exit on the write statement. Not only would you be able to simplify your code, but it would also be available to you and all other programmers for instant application in any program.

Using the no-zero and no-sign Additions

The no-zero addition suppresses leading zeros when used with type c or type n variables. In the case of a zero value, the output is all blanks.

The no-sign addition, when used with variables of type i, p, or f, suppresses the output of the sign character. In other words, negative numbers will not have a sign and will appear as if they were positive.

Listing 14.10 illustrates the use of these two additions.

Listing 14.10  Using no-zero and no-sign

1  report ztx1410.
2  data: c1(10) type c value '000123',
3        n1(10) type n value 123,
4        n2(10) type n value 0,
5        i1     type i value '123-',
6        i2     type i value 123.

7  write: / c1,         20 'type c',
8         / c1 no-zero, 20 'type c using no-zero',
9         / n1,         20 'type n',
10        / n1 no-zero, 20 'type n using no-zero',
11        / n2,         20 'type n: zero value',
12        / n2 no-zero, 20 'type n: zero value using no-zero',
13        / i1,         20 'type i',
14        / i2 no-sign, 20 'type i using no-sign'.

The code in Listing 14.10 produces this output:

000123             type c                          
   123             type c using no-zero            
0000000123         type n                          
       123         type n using no-zero            
0000000000         type n: zero value              
                   type n: zero value using no-zero
       123-        type i                          
        123        type i using no-sign            

Specifying Decimals and Rounding

Two statements perform rounding:

• decimals
• round

Three statements are used to specify the number of decimal places in the output:

• decimals
• currency
• unit

Using the decimals and round Additions

The decimals n addition can be used to increase or decrease the number of decimal places displayed in the output list. If you decrease the number of decimal places, the value is rounded before being written to the list. The source variable value is not changed, only the output appears differently. If you increase the number of decimals, zeros are appended to the end of the value. Negative values of n move the decimal to the right, effectively multiplying the number by factors of 10 and then rounding before display.

The round n addition causes the output to be scaled by factors of 10 and then rounded before display. This has the same effect as multiplying by 10**n. Positive n values move the decimal to the left, and negative values move it to the right. This is useful, for example, when you want to output values to the nearest thousand.

The difference between decimals and round is that decimals changes the number of digits seen after the decimal point to n and then performs rounding. round moves the decimal point left or right by n, maintaining the number of digits after the decimal, and then performs rounding to the number of decimal digits displayed.

Listing 14.11 illustrates the use of decimals and round.

Listing 14.11  Using the decimals and round Additions

1  report ztx1411.
2  data f1 type p decimals 3 value '1575.456'.
3  write: / f1,                    20 'as-is',
4         / f1 decimals 4,         20 'decimals 4',
5         / f1 decimals 3,         20 'decimals 3',
6         / f1 decimals 2,         20 'decimals 2',
7         / f1 decimals 1,         20 'decimals 1',
8         / f1 decimals 0,         20 'decimals 0',
9         / f1 decimals -1,        20 'decimals -1',
10        / f1 round 4,            20 'round 4',
11        / f1 round 3,            20 'round 3',
12        / f1 round 2,            20 'round 2',
13        / f1 round 1,            20 'round 1',
14        / f1 round 0,            20 'round 0',
15        / f1 round -1,           20 'round -1',
16        / f1 round -2,           20 'round -2',
17        / f1 round 3 decimals 1, 20 'round 3 decimals 1',
18        / f1 round 3 decimals 3, 20 'round 3 decimals 3'.

The code in Listing 14.11 produces this output:

1,575.456   as-is             
      1,575.4560   decimals 4        
       1,575.456   decimals 3        
        1,575.46   decimals 2        
         1,575.5   decimals 1        
           1,575   decimals 0        
             158   decimals -1       
           0.158   round 4           
           1.575   round 3           
          15.755   round 2           
         157.546   round 1           
       1,575.456   round 0           
      15,754.560   round -1          
     157,545.600   round -2          
             1.6   round 3 decimals 1
           1.575   round 3 decimals 3

On line 8, the decimals 0 addition does not round up because the fractional part of the number is less than .5.

Using the currency and unit Additions

The additions currency and unit are an alternate way of indicating the position of the decimal point for a type p field. They cannot be used with the decimals addition.

Using the currency Addition

When you write out a currency amount, you should also use the currency addition. Such amounts are usually retrieved from a type CURR field in a database table.

Use currency instead of decimals to specify the number of decimal places for currency amount fields. Unlike decimals, on which you specify the number of decimal places, you instead specify a currency code, such as USD (U.S. Dollars), ITL (Italian Lira), or JPY (Japanese Yen). The system then looks up that currency code in table TCURX to determine the number of decimal places that should be used to display the value. If the currency code is not found in TCURX, a default of two decimal places is used.

The currency code is usually also stored either in the same database table or another, related one. For example, the currency key for type CURR fields (saldv, solll, and habnl) in table ztxlfc3 is stored in the field ztxt001-waers. You can find this out by double-clicking on any of these fields. For example, if you double-click on ztxlfc3-saldv, you will see the Display Field ZTXLFC3-SALDV screen shown in Figure 14.3.
Figure 14.3 : A double-click on field saldv in table ztxlfc3 displays this screen.

The reference table and reference field indicate that ztxt001-waers contains the currency key.

The table ztxt001 itself contains the attributes of all company codes; its primary key is bukrs. If you take the value from ztxlfc3-bukrs and look up the single row in ztxt001 that matches, waers will contain the currency key. Listing 14.12 illustrates.

Listing 14.12  Using the currency Addition

1  report ztx1412.
2  tables: ztxlfc3.

3  data: f1 type p decimals 1 value '12345.6'.
4
5  write: / f1,
6         / f1 currency 'USD', 'USD',      "US Dollars
7         / f1 currency 'ITL', 'ITL'.      "Italian Lira
8 
9  skip.
10 select * from ztxlfc3 where gjahr = '1997'
11                       and saldv >= 100
12                       order by bukrs.
13     on change of ztxlfc3-bukrs.
14         select single * from ztxt001 where bukrs = ztxlfc3-bukrs.
15         endon.
16     write: / ztxlfc3-saldv currency ztxt001-waers, ztxt001-waers.
17     endselect.

The code in Listing 14.12 produces this output:

        123,456
       1,234.56  USD
        123,456  ITL

            100.00  USD
            100.00  USD 
            100.00  USD 
            100.00  USD 
           100,000  ITL 
            25,050  ITL 
           100,000  ITL 
           100,000  JPY 
           300,000  JPY 
            250.50  CAD 
            200.00  CAD 
          1,000.00  CAD 
            100.00  CAD 

• Line 5 writes the value of f1 as-is.
• Line 6 writes the same value, but first it looks up 'USD' in table TCURX to determine the number of decimal places. The value 'USD' is not in that table, so the output is formatted using the default (two decimal places).
• When line 7 is executed, table TCURX indicates that ITL has no decimal places and so formats the value without any decimals.
• Line 10 selects records from table ztxlfc3 in company code order (bukrs).
• Line 13 is triggered each time the company code changes.
• Line 14 looks up the company code in table ztxt001 to find the currency for that company. The currency key is available in field ztxt001-waers.
• Line 16 writes the balance carried forward using the number of decimal places indicated by the currency key in field ztxt001-waers.

Using the unit Addition

The unit addition is used to specify the number of decimals displayed for a quantity field. Units, such as cm (centimeters) or lb (pounds), determine the number of decimal places displayed. The code, such as '%' (percent) or 'KM' (kilometers) is specified after unit is looked up automatically in table t006. The fields decan and andec then determine how many decimal places are displayed. They both contain a numeric value.

decan specifies the number of zero-valued decimal values to truncate. It removes trailing zeros; it will never truncate nonzero decimal places. It also never increases the number of decimal places displayed. For example, if the value is 12.30 and decan is 1, the output will be 12.3. If the value is 12.34 and decan is 1, the output will be 12.34.

andec appends zeros after decan has been applied. The number of decimal digits displayed must be a multiple of andec. If necessary, andec will pad the value on the right with zeros. If andec is zero, no zeros are appended. For example, if the value is 12.34 after decan has been applied, and the value of andec is 3, there must be 0, 3, 6, or 9 (or any other multiple of 3) decimal digits. The output value will therefore be padded with zeros to become 12.340. If the value after decan is 12.3456, the output will be 12.345600. If the value after decan is 12.30 and andec is 2, the output will be 12.30.

Table 14.6 contains more examples of the effects of decan and andec on the output format.

The unit addition is typically used with fields of type QUAN that are stored in the database. Each field must have a reference field of type UNIT. The unit of measurement for the value in the QUAN field is stored there. Figure 14.4 shows that the reference field for ztxmara-brgew is ztxmara-gewei.

Figure 14.4 : If you double-click on the ztxmara-brgew field, you will see a screen indicating the reference table and field.

Listing 14.13 illustrates the use of this addition.

Listing 14.13  Using the unit Addition

1  report ztx1413.
2  tables: ztxmara, t006.
3  data: f1 type p decimals 4 value '99.0000',
4        f2 type p decimals 4 value '99.1234',
5        f3 type p decimals 4 value '99.1200',
6        f4 type p decimals 1 value '99.1'.
7 
8  write: / f1,           'as-is',
9         / f1 unit 'ML', 'ml - milliliters decan 3 andec 3',
10        / f1 unit '%',  '%  - percent     decan 2 andec 0',
11        / f1 unit '"',  '"  - inches      decan 0 andec 3',
12        /,
13        / f2,           'as-is',
14        / f2 unit '%',  '%',
15        / f3,           'as-is',
16        / f3 unit '%',  '%',
17        / f4,           'as-is',
18        / f4 unit '%',  '%'.
19
20 skip.
21 write: /12 'brgew as-is',
22        31 'with units',
23        48 'ntgew as-is',
24        67 'with units',
25        79 'units',
26        85 'decan',
27        91 'andec'.
28 uline.
29 select * from ztxmara.
30     select single * from t006 where msehi = ztxmara-gewei.
31     write: /(5) ztxmara-matnr,
32              ztxmara-brgew,
33              ztxmara-brgew unit ztxmara-gewei,
34              ztxmara-ntgew,
35              ztxmara-ntgew unit ztxmara-gewei,
36              ztxmara-gewei,
37           85 t006-decan,
38           91 t006-andec.
39     endselect.

The code in Listing 14.13 produces this output:

         99.0000  as-is                                                
          99.000  ml - milliliters decan 3 andec 3                     
           99.00  %  - percent     decan 2 andec 0                     
              99  "  - inches      decan 0 andec 3                     
                                                                       
         99.1234  as-is                                                
         99.1234  %                                                    
         99.1200  as-is                                                
           99.12  %                                                    
            99.1  as-is                                                
            99.1  %                                                    
                                                                       
       brgew as-is    w/units   ntgew as-is  w/units  units decan andec
---------------------------------------------------------------------
M100       102.560    102.560       100.000      100  M3     0     3   
M101        10.100     10.100        10.000       10  PAL    0     0   
M102         1.000          1         0.000        0  ROL    0     0   
M103        50.000         50         0.000        0  CR     0     0   

• Line 8 writes f1 without using the units addition.
• Line 9 uses the unit ML (milliliters). A lookup is automatically done in table t006 for ML. That row contains decan 3, and andec 3. decan 3 causes zeros after the third decimal place to be dropped. andec 3 causes the number of decimals to be a multiple of three. At this point, it already is, so the output is displayed using three decimals.
• Line 10 formats f1 using the unit % (percent), which has decan 2 and andec 0. decan 2 dictates that trailing zeros after the second decimal should be dropped. andec 0 indicates that there is no further modification, and so two decimal places are output.
• Line 11 uses the " unit (inches). decan 0 indicates that all decimal zeros should be truncated. andec 3 indicates that the number of decimals should be padded with zeros to three decimal places.
• Lines 13 through 18 format f2 through f4 using the unit %.
• On line 14, decan 2 indicates trailing zeros after the second decimal digit should be truncated. There aren't any, so nothing is truncated. andec 0 indicates no further padding, therefore the output is formatted using four decimal digits.
• On line 16, decan 2 truncates the trailing zeros.
• On line 18, decan 2 does not do anything because there are no trailing zeros to truncate. andec is 0, so no zeros are appended to the end.
• Line 29 selects all records from table ztxmara.
• For each, line 30 selects the record from t006 that contains the unit in ztxmara-gewei. Please note that this is not normally done. It is only done here to show you the values of decan and andec.
• On lines 32 through 35, the values gewei and ntgew are written out in two ways. First they are written out as-is, and then they are written using the unit addition to show the before-and-after.
• Lines 37 and 38 write out the decan and andec values that were used to format each row.

Shifting Justification

Using left-justified, centered, and right-justified, you can shift the output value within the space allotted for the output field. Listing 14.14 illustrates.

Listing 14.14  Using the Justification Additions to the write Statement

1  report ztx1414.
2  data: f1(6) value 'AB'.
3  write: /     '....+....1',
4         /     '1234567890',
5         /     f1,
6         /     f1 left-justified,
7         /     f1 centered,
8         /     f1 right-justified,
9         /     '....+....1....+....2....+....3....+....4',
10        /     '1234567890123456789012345678901234567890',
11        /(40) f1 left-justified,
12        /(40) f1 centered,
13        /(40) f1 right-justified.

The code in Listing 14.14 produces this output:

....+....1                               
1234567890                               
AB                                       
AB                                       
  AB                                     
    AB                                   
....+....1....+....2....+....3....+....4 
1234567890123456789012345678901234567890 
AB                                       
                   AB                    
                                      AB

• Lines 3, 4, 9, and 10 write out a ruler so that you can see the column numbers in the output.
• Line 5 writes f1 using default length and formatting. Default formatting for a type c variable dictates left-justification, so the output appears left-justified within its default output length (6).
• Line 6 produces the same output because it also specifies left-justification.
• Line 7 centers the value within the default output length of 6.
• Line 8 right-justifies the value within the default output length of 6.
• Lines 11, 12, and 13 specify an output length of 40. The value is then left-justified, centered, and right-justified within that length.

Summary

• If you do not specify any format or length specification on the write statement, the default format and length of the field are used. These defaults originate in the ABAP/4 data types. DDIC fields are based on ABAP/4 data types, and they thereby inherit the default format and length. In addition, format specifications such as number of decimal places and output length can also be specified in the domain; these override the inherited values.
• Date and time fields are displayed with separators if there is enough room in the output field for them. If there is not, the separators are completely dropped. In numeric field, thousands separators are dropped one at a time, beginning at the left of the field and moving right, in order to display more digits. Even the sign field is used if it is blank.
• For most date format specifications, user defaults define at least in part how date fields should be formatted. Of all of the date format specifications, only yymmdd completely overrides the user defaults.
• An edit mask can be used to insert characters into the output. It can also invoke a conversion exit that can format the value using ABAP/4 code. A conversion exit is like a reusable container that contains code to format a field.
• Use no-zero to suppress leading zeros in type n and type c fields.
• Use no-sign to remove the trailing sign field from the display.
• Use decimals to specify the number of decimal places that should be displayed.
• Use round to indicate the position of the decimal point in the value.
• Use currency to specify the number of decimal places for currency amount fields. It looks up the currency code in table tcurx to determine the number of decimals. If the code is not found, a default of two decimal places is used.
• Use unit to format quantity fields. The unit is looked up in table t006. decan determines the number of decimal zeros to remove, and andec determines the number of zeros to add. Non-zero decimal digits are never removed.
• Use left-justified, centered, and right-justified to justify the value within the length of the output field.

Q&A

Workshop

The Workshop provides 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

1. What do you have to do to make sure changes to user defaults take effect?
2. What happens when an edit mask beginning with a V is applied to a numeric field or character field?
3. What variable types can the no-sign addition be used with to make a negative number appear as if it were positive?

Exercise 1

Write a program that produces the following output:

....+....1....+....2....+....3....+....4
First                                  December
               January
                              First

---

© Copyright, Macmillan Computer Publishing. All rights reserved.