ABAP Keyword Documentation →  ABAP − Reference →  Program Flow Logic →  Expressions and Functions for Conditions →  log_exp - Logical Expressions →  rel_exp - Comparison Expressions →  rel_exp - Comparison Rules →  rel_exp - Comparing Elementary Data Types →  rel_exp - Comparison Type of Calculation Expressions 

rel_exp - Comparison Type of String Expressions

String expressions can be used as operands in comparison expressions with the following:

• comparison operators for all data types

• comparison operators for character-like data types

It is possible to compare a string expression with a single operand of any elementary data type or with another string expression. With regard to the conversion of the elementary expression by string, two cases can be distinguished:

• If a string expression is compared with an individual operand in a generic logical expression, the comparison type is string. The individual operand is implicitly regarded as an embedded expression of a string template and formatted as a text string before the comparison in accordance with the associated predefined format.

• If a string expression on the right-hand side of a WHERE condition is used in a processing statement for internal tables, the comparison type results from the combination of string with the type on the left-hand side. Both sides are converted to the comparison type as required.

Other versions: 7.31 | 7.40 | 7.54

Notes

• A string expression cannot be specified as the operand of a predicate expression.

• The result of the formatting of an individual operand differs from the result of a simple conversion for some data types. An example is the type decfloat34.

• The results of general logical expressions and logical expressions in WHERE conditions for internal tables may differ for comparisons with string expressions, since both the formatting and the comparison type play a role.

Example

This example demonstrates the effect of different comparison types. The first comparison is true, since the character-like operand is converted to the type of the numeric operand (in accordance with the rule for comparing character-like data types) and the number value is compared. However, the second comparison is also true, since the numeric operand is formatted as a text string and the internal representation of the code page used is compared-

ASSERT `02` > 1. 
ASSERT |02| < 1.

Example

The example demonstrates the effect of different formatting and different rules. All comparisons are true. An elementary operand of type decfloat34 is compared with a text string and a string expression. For the comparison with the text string, the left-hand side is also converted to the type string and the values of both sides are the same. For the comparison with the chain, the left-hand side is formatted differently and the values of both sides are different. The third comparison shows explicitly how the elementary operand is handled during the comparison with the chain. In contrast, the WHERE conditions LOOP statements convert both sides to the numeric comparison type decfloat34. The output shows the difference between simple conversion and formatting as an embedded expression.

DATA decf TYPE decfloat34 VALUE '0.00000004'. 
DATA itab LIKE TABLE OF decf. 
APPEND decf TO itab. 

ASSERT decf       =  CONV string( decf ). 
ASSERT decf       <> CONV string( decf ) && ``. 
ASSERT |{ decf }| <> CONV string( decf ) && ``. 

LOOP AT itab TRANSPORTING NO FIELDS 
             WHERE table_line = CONV string( decf ). 
ENDLOOP. 
ASSERT sy-subrc = 0. 

LOOP AT itab TRANSPORTING NO FIELDS 
            WHERE table_line = CONV string( decf ) && ``. 
ENDLOOP. 
ASSERT sy-subrc = 0. 

cl_demo_output=>display( 
  |CONV string( decf ):\t{ CONV string( decf ) }\n| && 
  |{ `|{ decf }|` }:\t\t{ decf }| ).