List of Constructor Operators

• VALUE and NEW create new data objects, where the latter returns a reference to it.
• COND and SWITCH are conditional expressions. They return different values depending on logical conditions.
• CORRESPONDING creates a new data object based on an existing one.
• REF creates a reference like GET REFERENCE OF.
• EXACT performs calculations only if they can be done without rounding errors; otherwise, an exception is raised.
• REDUCE derives a value from an internal table.
• CONV and CAST convert data types.
• FILTER creates a new internal table by filtering an existing one.

VALUE Operator - Overview

Without Arguments

Without additional arguments, the VALUE operator creates an initial data object for any data type.

Structures

VALUE structype( field1 = value1 field2 = value2 ... )

Tables

VALUE tabletype( ( field1 = value1 field2 = value2 ... ) " Row 1
                 ( ... )                                " Row 2
                 ... )

Internal Table Extension with BASE in VALUE

If you want to add rows from an existing table to a new one, you can use the keyword BASE:

data(first_table) = value tt_demo( curr = 'EUR' account = '12322' ( date = sy-datum     amount = 123 )
                                                                  ( date = sy-datum + 1 amount = 130 ) ).
out->write( name = |\nFirst Table| data = first_table ).

data(second_table) = value tt_demo( base first_table
                                    curr = 'EUR' account = '77777' ( date = sy-datum     amount = 12 )
                                                                   ( date = sy-datum + 1 amount = 11 ) ).
out->write( name = |\nSecond Table| data = second_table ).

First Table
DATE        AMOUNT  ACCOUNT  CURR
2022-09-29  123.0   12322    EUR
2022-09-30  130.0   12322    EUR

Second Table
DATE        AMOUNT  ACCOUNT  CURR
2022-09-29  123.0   12322    EUR
2022-09-30  130.0   12322    EUR
2022-09-29  12.0    77777    EUR
2022-09-30  11.0    77777    EUR

VALUE for Tables: Common Components

Values that are identical in several rows can be defined before the first row using that value:

lt_range = value #( sign = 'I' option = 'EQ' ( low = '20221031'  )
                                             ( low = '20230406'  )
                               option = 'BT' ( low = '20221102'  high = '20221104' )
                                             ( low = '20221221'  high = '20230107' )
                                             ( low = '20230530'  high = '20230609' )
                                             ( low = '20230727'  high = '20230909' ) ).

Fields filled outside must not be filled again inside the parentheses.

Table Loops with FOR in Expressions

With FOR <row> IN <table> you can loop over an internal table:

SELECT summary,
       task_id
  FROM zbc_tasks
  INTO TABLE @DATA(lt_data)
  UP TO 10 ROWS.

TYPES tt_tmp LIKE lt_data.

DATA(lt_tmp) = VALUE tt_tmp( FOR ls_data IN lt_data WHERE ( task_id < 4  )
                              ( summary = to_upper( ls_data-summary ) task_id = 42 )  ).

out->write( lt_tmp ).

• The WHERE condition is optional and must be in parentheses.
• Group processing is possible with FOR GROUPS.
• Optionally, the current loop index can be assigned with INDEX INTO <indexvariable>.

The CONV Constructor Operator

The CONV operator can be used to convert the data type of a data object.
CONV <target type>( <data object> ).

This is especially useful when you would otherwise need an additional helper variable, as in the following example:

METHOD demo_conv.
  data lv_text type char8.
  lv_text = sy-datum.
  my_method( text = lv_text ).
ENDMETHOD.

METHOD demo_conv.
  my_method( text = CONV #( sy-datum ) ).
ENDMETHOD.

EXACT Expressions

EXACT performs assignments only when they can be done without loss (e.g., truncating strings or rounding). Otherwise, the exception class CX_SY_CONVERSION_ERROR is raised.

EXACT performs calculations only when they can be done without rounding errors. Otherwise, the exception class CX_SY_CONVERSION_ROUNDING is raised.
The rounded result can be accessed in the CATCH block.

The CORRESPONDING Constructor Operator

CORRESPONDING allows you to create a new structured data object (table or structure) from another one by copying fields with identical names.
It is similar to MOVE-CORRESPONDING.

DATA: BEGIN OF ls_task_small,
        task_id   TYPE zbc_tasks-task_id,
        summary   TYPE zbc_tasks-summary,
        new_field TYPE char10,
      END OF ls_task_small.

SELECT SINGLE *
  FROM zbc_tasks
  INTO @DATA(ls_task_original).

" MOVE-CORRESPONDING ls_task_original TO ls_task_small.
ls_task_small = corresponding #( ls_task_original ).

SAP Documentation: CORRESPONDING

CORRESPONDING with MAPPING

If the target structure has fields with different names, you can map them explicitly with MAPPING.

DATA: BEGIN OF ls_task_small,
        id    TYPE zbc_tasks-task_id,
        title TYPE zbc_tasks-summary,
      END OF ls_task_small.

SELECT SINGLE *
  FROM zbc_tasks
  INTO @DATA(ls_task_original).

ls_task_small = corresponding #( ls_task_original
                                MAPPING id    = task_id
                                        title = summary ).

CORRESPONDING with Lookup

A special form of the CORRESPONDING operator is a lookup on another internal table.
This is similar to a LEFT OUTER (Equi-) JOIN with a cardinality of :1 in SQL. That means:

• If a record is found in the lookup table, the corresponding data is transferred according to the rules of the CORRESPONDING operator.
• If no record is found, the source line remains unchanged.
• The join conditions always compare with =, and conditions are combined with AND.
• The target fields for the lookup must already exist in the original table.

DATA lt_lookup TYPE HASHED TABLE OF I_CountryText WITH UNIQUE KEY country.
DATA(lt_orig) = VALUE tt_demo( ( country = 'DE' )
                               ( country = 'US' ) ).
SELECT * FROM i_countrytext WHERE language = 'D' INTO TABLE @lt_lookup.

DATA(lt_new) = CORRESPONDING tt_demo( lt_orig FROM lt_lookup
                                              USING country = country
                                              MAPPING country_text = CountryName  ).
out->write( lt_new ).

Conditional Expressions with the COND Operator

The COND operator corresponds to a "searched CASE" or CASE WHEN expression in SQL.
Independent conditions are checked sequentially.
The first condition evaluating to TRUE determines the return value.
If none matches, the ELSE value is returned.
If ELSE is not defined, an initial value is returned.

Syntax COND

COND <Returntype>(  WHEN <Condition1> THEN <Expression1>
                   [WHEN <Condition2> THEN <Expression2>]
                   ...
                   [ELSE <ExpressionN>] )

Example

DATA(result) = COND tt_demo( WHEN sy-datum = '20220929' THEN VALUE #( ( amount = 10 curr = 'EUR'  ) )
                             WHEN sy-langu = 'D'        THEN VALUE #( ( amount = 11 curr = 'EUR'  ) )
                             ELSE                            VALUE #( ( amount = 9 curr = 'USD' ) ) ).

Filtering Internal Tables with FILTER (2/2)

Example: FILTER with Another Table

Alternatively, filtering can be done based on another internal table — equivalent to an INNER JOIN in SQL.

DATA lt_data TYPE sorted TABLE OF I_CountryText WITH UNIQUE KEY country.
DATA(lt_filter) = VALUE tt_demo( ( country = 'DE' )
                                 ( country = 'US' ) ).
SELECT * FROM i_countrytext WHERE language = 'D' INTO TABLE @lt_data.

DATA(lt_new) = filter #( lt_data in lt_filter where country = country  ).

out->write( lt_new ).

Syntax of the REDUCE Operator

Simplest Form

REDUCE <Returntype>( INIT <Variable Declarations>
                     FOR <FOR-Expression>
                     NEXT <Result Construction> ).

Advanced Options

• You can declare helper variables before the variable declaration using LET.
• Multiple variables can be declared; the first one is the return variable and must be convertible to the Returntype.
• You can loop over multiple internal tables using multiple FORs.
• In the NEXT section, you can also construct internal tables.

Clean Code Recommendations

• Do not implement overly complex logic — keep operations simple.
• Keep internal variables short and meaningful.
• Remember: for the debugger, this is a single execution step.
• Type conversion with CONV can be handy in method calls where strict type checks are enforced.
  However, it bypasses these checks, shifting potential errors from compile-time (syntax errors) to runtime (dumps).