Liste der Konstruktor-Operatoren

• VALUE und NEW erzeugen neue Datenobjekte, wobei letzterer eine Referez darauf liefert.
• COND und SWITCH sind Fallunterscheidungen. Sie liefern abhängig von logsichen Bedingungen unterschiedliche Werte.
• CORRESPONDING erzeugt ein neues Datenobjekt auf Basis eines bestehenden Datenobjektes
• REF erzeugt eine Referenz wie GET REFERENCE OF
• EXACT - Führt Berechnungen nur dann durch, wenn sie ohne Rundungsfehler sind. Ansonsten wird eine Ausnahme erzeugt
• REDUCE erzeugt aus internen Tabellen einen Wert
• CONV und CAST konvertieren Datentypen
• FILTER erzeugt eine neue interne Tabelle durch Filterung auf eine bestehende interne Tabelle

VALUE Operator - Übersicht

Ohne Argumente

Ohne weitere Argumente erzeugt der VALUE Operator ein initiales Datenobjekt für alle Datentypen.

Strukturen

VALUE structype( feld1 = wert1 feld2 = wert2 ... )

Tabellen

VALUE tabletype( ( feld1 = wert1 feld2 = wert2... ) " Zeile 1 
                 ( ... )                            " Zeile 2
                 ...                              )

Interne Tabelle mit BASE in VALUE übernehmen

Falls in die neue Tabelle Zeilen einer bestehenden Tabelle hinzugefügt werden sollen, so kann man das mit dem Schlüsselwort BASE erreichen:

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 bei Tabellen: Gemeinsame Komponenten

Werte die in mehreren Zeilen identisch sind, können vor der ersten Zeile mit diesem Wert definiert werden:

    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' ) ).

Felder die ausserhalb gefüllt wurden, dürfen in den folgenden Zeilen nicht mehr innerhalb der Klammer gefüllt werden.

Tabellenschleifen mit FOR in Ausdrücken

Mit FOR <Zeile> IN <Tabelle> kann man eine Schleife über die Zeilen einer internen Tabelle erzeugen:

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 ).

• Die WHERE Bedingung ist optional. Sie muss in Klammern gesetzt werden.
• Gruppenstufenverarbeitung ist mit FOR GROUPS möglich
• Optional kann der aktuelle Index der Schleife in eine Variable mit INDEX INTO <Indexvariable> übergeben werden

Der CONV Konstruktor-Operator

Mit dem CONV Operator kann der Datentyp eines Datenobjektes konvertiert werden.
CONV <Zieldatentyp>( <Datenobjekt> ).

Das ist insbesondere dann praktisch, wenn man ansonsten eine neue Hilfsvariable bräuchte, wie in diesem Beispiel:

  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 Ausdrücke

EXACT führt Zuweisungen nur dann durch, wenn sie ohne Verlust, d.h. Abschneiden von Zeichenketten oder Rundungsfehler sind. Ansonsten wird die Ausnahmeklasse CX_SY_CONVERSION_ERROR erzeugt.

EXACT führt Berechnungen nur dann durch, wenn sie ohne Rundungsfehler ist. Ansonsten wird die Ausnahmeklasse CX_SY_CONVERSION_ROUNDING erzeugt. Das gerundete Ergebnis kann man sich im CATCH Block ausgeben lassen.

Der CORRESPONDING Konstruktor-Operator

Mit CORRESPONDING kann man aus einem strukturierten Datenobjekt, also Tabelle oder Struktur, ein anderes Datenobjekt erzeugen und dabei die Werte gleichlautender Felder übernehmen. Das erinnert an 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 Dokumentation CORRESPONDING

CORRESPONDING mit MAPPING

Falls die Zielstruktur etwas anders lautende Felder hat, so können diese mit MAPPING explizit zugewiesen werden.

    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 mit Lookup

Eine Spezialform des CORRESPONDING Operators ist ein Lookup auf eine andere interne Tabelle. Dieser entspricht weitgehend eines LEFT OUTER (Equi-) JOIN mit einer Kardinalität :1 in SQL. Das bedeutet im Einzelnen:

• Wenn ein Datensatz in der Lookup-Tabelle gefunden wird, werden die Daten aus diesem nach den bekannten Regeln des CORRESPONDING Operators übernommen.
• Wenn kein Datensatz gefunden wird, dann bleibt die Zeile der Ausgangstabelle unverändert.
• Die JOIN-Bedingungen vergleichen immer mit =, zwischen den Bedingungen steht ein AND.
• Die Zielfelder für den Lookup müssen schon in der Originaltabelle vorhanden sein.

    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 ).

Fallunterscheidungen mit dem COND Operator

Der COND Operator entspricht einem "Searched CASE" bzw. CASE WHEN- Ausdruck in SQL. Voneinander unabhängige Bedingungen werden geprüft. Die erste, die zu TRUE ausgewertet wird, bestimmt den Rückgabewert. Falls keine zutrifft, wird der ELSE Wert zurückgegeben. Ist dieser nicht definiert, wird ein initialer Wert zurückgegeben.

Syntax COND

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

Beispiel

    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' ) ) ).

Filtern von internen Tabellen mit FILTER (2/2)

Beispiel FILTER mit anderer Tabelle

Oder es wird anhand einer anderen internen Tabelle gefiltert. Das entspricht einem 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 des REDUCE Operators

Einfachster Fall

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

Ausbaustufen

• Vor der Variablen Deklaration können mit LET Hilfsvariablen deklariert werden.
• Es können mehrere Variablen deklariert werden. Die erste Variable wird als Ergebnis des REDUCE Ausdrucks verwendet und muss in den Returntype konvertierbar sein.
• Es kann mit mehreren FORauch über mehrere interne Tabellen geschleift werden.
• Im NEXT Bereich können auch wiederum interne Tabellen konstruiert werden

Clean Code Empfehlungen

• Keine zu komplexen Dinge umsetzen - Die Operation sollte überschaubar bleiben
• Interne Variablen kurz halten
• Bedenke: Für den Debugger ist das ein einzelner Schritt
• Die Typkonvertierung mit CONV kann gerade bei Methodenaufrufen, wo eine strenge Typprüfung vorgenommen wird, sehr praktisch sein. Andererseits hebelt man damit die Vorteile dieser Prüfung aus. Damit verlagert man potenzielle Fehler vom Entwicklungszeitpunkt (Syntaxfehler) zum Ausführungszeitpunkt (Dump).