ABAP Cloud Cheat Sheet 2025: Komplette Referenz

" Klassisch (veraltet in ABAP Cloud)
DATA lv_name TYPE string.
DATA lv_count TYPE i.

" Modern: Inline-Deklaration
DATA(lv_name) = 'Max Mustermann'.
DATA(lv_count) = 42.

" Konstanten
CONSTANTS gc_max_entries TYPE i VALUE 100.

" Field Symbols & Data References
FIELD-SYMBOLS <fs_data> TYPE any.
DATA(lo_ref) = NEW zcl_my_class( ).

" Struktur
TYPES: BEGIN OF ty_customer,
         id    TYPE i,
         name  TYPE string,
         email TYPE string,
       END OF ty_customer.

" Interne Tabelle
DATA lt_customers TYPE TABLE OF ty_customer.

" Modern: TYPE TABLE OF mit Index
DATA lt_indexed TYPE STANDARD TABLE OF ty_customer WITH DEFAULT KEY.
DATA lt_sorted  TYPE SORTED TABLE OF ty_customer WITH UNIQUE KEY id.
DATA lt_hashed  TYPE HASHED TABLE OF ty_customer WITH UNIQUE KEY id.

IF lv_status = 'ACTIVE'.
  " Code
ELSEIF lv_status = 'PENDING'.
  " Code
ELSE.
  " Code
ENDIF.

" Modern: Inline mit COND
DATA(lv_message) = COND string(
  WHEN lv_status = 'ACTIVE'  THEN 'Aktiv'
  WHEN lv_status = 'PENDING' THEN 'Ausstehend'
  ELSE 'Unbekannt'
).

CASE lv_type.
  WHEN 'A'.
    " Code
  WHEN 'B' OR 'C'.
    " Code
  WHEN OTHERS.
    " Default
ENDCASE.

" Modern: SWITCH Expression
DATA(lv_result) = SWITCH string( lv_type
  WHEN 'A' THEN 'Typ A'
  WHEN 'B' THEN 'Typ B'
  ELSE 'Unbekannt'
).

" DO-Schleife
DO 10 TIMES.
  " Code
ENDDO.

" WHILE-Schleife
WHILE lv_count < 100.
  lv_count = lv_count + 1.
ENDWHILE.

" LOOP AT (interne Tabelle)
LOOP AT lt_customers INTO DATA(ls_customer).
  " Verarbeitung
ENDLOOP.

" Modern: FOR Expression
DATA(lt_names) = VALUE string_table(
  FOR ls_cust IN lt_customers
  ( ls_cust-name )
).

" APPEND
APPEND VALUE #( id = 1 name = 'Max' ) TO lt_customers.

" INSERT
INSERT VALUE #( id = 2 name = 'Anna' ) INTO TABLE lt_customers.

" Modern: VALUE mit mehreren Zeilen
lt_customers = VALUE #(
  ( id = 1 name = 'Max'  email = 'max@example.com' )
  ( id = 2 name = 'Anna' email = 'anna@example.com' )
).

" READ TABLE klassisch
READ TABLE lt_customers INTO DATA(ls_customer)
  WITH KEY id = 1.

" Modern: Table Expression
DATA(ls_cust) = lt_customers[ id = 1 ].

" Optional: Default bei nicht gefunden
DATA(ls_opt) = VALUE #( lt_customers[ id = 999 ] OPTIONAL ).

" Default-Wert setzen
DATA(ls_def) = VALUE #( lt_customers[ id = 999 ]
  DEFAULT VALUE #( id = 0 name = 'Unbekannt' ) ).

" MODIFY klassisch
MODIFY lt_customers FROM VALUE #( id = 1 name = 'Maximilian' )
  TRANSPORTING name WHERE id = 1.

" Modern: Table Expression
lt_customers[ id = 1 ]-name = 'Maximilian'.

" DELETE klassisch
DELETE lt_customers WHERE id = 1.

" DELETE nach Index
DELETE lt_customers INDEX 1.

" CLEAR & FREE
CLEAR lt_customers.  " Leert Tabelle (Speicher bleibt)
FREE lt_customers.   " Gibt Speicher frei

" Anzahl Zeilen
DATA(lv_lines) = lines( lt_customers ).

" Sortieren
SORT lt_customers BY name ASCENDING.

" Filtern
DATA(lt_active) = FILTER #( lt_customers WHERE status = 'ACTIVE' ).

" CORRESPONDING (Mapping)
DATA(lt_target) = CORRESPONDING #( lt_source ).

" Single Record
SELECT SINGLE id, name, email
  FROM ztab_customers
  WHERE id = @lv_id
  INTO @DATA(ls_customer).

" Mehrere Zeilen
SELECT id, name, email
  FROM ztab_customers
  WHERE status = 'ACTIVE'
  INTO TABLE @lt_customers.

" Modern: Inline mit Joins
SELECT c~id, c~name, o~order_date
  FROM ztab_customers AS c
  INNER JOIN ztab_orders AS o
    ON c~id = o~customer_id
  WHERE c~status = 'ACTIVE'
  INTO TABLE @DATA(lt_result).

" Aggregation
SELECT customer_id, COUNT( * ) AS order_count
  FROM ztab_orders
  GROUP BY customer_id
  INTO TABLE @DATA(lt_stats).

" INSERT
INSERT ztab_customers FROM @ls_customer.

" UPDATE
UPDATE ztab_customers
  SET status = 'INACTIVE'
  WHERE id = @lv_id.

" DELETE
DELETE FROM ztab_customers WHERE id = @lv_id.

" MODIFY (INSERT oder UPDATE)
MODIFY ztab_customers FROM @ls_customer.

" Änderungen sichern
COMMIT WORK.

" Änderungen zurücknehmen
ROLLBACK WORK.

" Struktur
DATA(ls_data) = VALUE ty_customer(
  id    = 1
  name  = 'Max'
  email = 'max@example.com'
).

" Tabelle
DATA(lt_data) = VALUE ty_customer_table(
  ( id = 1 name = 'Max' )
  ( id = 2 name = 'Anna' )
).

" BASE: Vorhandene Daten erweitern
lt_data = VALUE #( BASE lt_data
  ( id = 3 name = 'Peter' )
).

" Einfaches Mapping
DATA(ls_target) = CORRESPONDING #( ls_source ).

" Mit MAPPING
DATA(ls_mapped) = CORRESPONDING #( ls_source MAPPING
  target_field = source_field
).

" DEEP: Nested Strukturen
DATA(ls_deep) = CORRESPONDING #( DEEP ls_source ).

" COND (IF-Alternative)
DATA(lv_discount) = COND decfloat16(
  WHEN lv_amount > 1000 THEN lv_amount * '0.1'
  WHEN lv_amount > 500  THEN lv_amount * '0.05'
  ELSE 0
).

" SWITCH (CASE-Alternative)
DATA(lv_category) = SWITCH string( lv_age
  WHEN 0  THEN 'Baby'
  WHEN 1 TO 12 THEN 'Kind'
  WHEN 13 TO 17 THEN 'Jugendlicher'
  ELSE 'Erwachsener'
).

" Einfacher Filter
DATA(lt_active) = FILTER #( lt_customers WHERE status = 'ACTIVE' ).

" Filter mit IN-Bedingung
DATA(lt_premium) = FILTER #( lt_customers USING KEY id
  WHERE id IN lt_premium_ids ).

" Summe berechnen
DATA(lv_total) = REDUCE i( INIT sum = 0
  FOR ls_order IN lt_orders
  NEXT sum = sum + ls_order-amount ).

" String concatenieren
DATA(lv_names) = REDUCE string( INIT text = ||
  FOR ls_cust IN lt_customers
  NEXT text = text && ls_cust-name && ', ' ).

" Transformation
DATA(lt_ids) = VALUE int4_table(
  FOR ls_customer IN lt_customers
  ( ls_customer-id )
).

" Mit Bedingung
DATA(lt_active_names) = VALUE string_table(
  FOR ls_cust IN lt_customers
  WHERE ( status = 'ACTIVE' )
  ( ls_cust-name )
).

" Nested FOR
DATA(lt_flat) = VALUE ty_table(
  FOR ls_group IN lt_groups
  FOR ls_item IN ls_group-items
  ( ls_item )
).

" Einfach
DATA(lv_greeting) = |Hallo { lv_name }!|.

" Mit Formatierung
DATA(lv_price) = |Preis: { lv_amount CURRENCY = lv_currency }|.
DATA(lv_date) = |Datum: { lv_timestamp TIMESTAMP = ISO }|.

" Ausrichtung und Padding
DATA(lv_padded) = |{ lv_text WIDTH = 20 ALIGN = LEFT PAD = '.' }|.

" Länge
DATA(lv_len) = strlen( lv_text ).

" Substring
DATA(lv_sub) = substring( val = lv_text off = 0 len = 5 ).

" Suchen & Ersetzen
DATA(lv_pos) = find( val = lv_text sub = 'test' ).
DATA(lv_replaced) = replace( val = lv_text sub = 'alt' with = 'neu' ).

" Upper/Lower Case
DATA(lv_upper) = to_upper( lv_text ).
DATA(lv_lower) = to_lower( lv_text ).

" Trimmen
DATA(lv_trimmed) = condense( lv_text ).

" Modern: String Template statt CONCATENATE
DATA(lv_full_name) = |{ lv_first_name } { lv_last_name }|.

" SPLIT
SPLIT lv_text AT ',' INTO TABLE DATA(lt_parts).

CLASS zcl_customer DEFINITION PUBLIC FINAL CREATE PUBLIC.
  PUBLIC SECTION.
    METHODS:
      constructor
        IMPORTING iv_id TYPE i,
      get_name
        RETURNING VALUE(rv_name) TYPE string,
      set_status
        IMPORTING iv_status TYPE string.

  PRIVATE SECTION.
    DATA:
      mv_id     TYPE i,
      mv_name   TYPE string,
      mv_status TYPE string.
ENDCLASS.

CLASS zcl_customer IMPLEMENTATION.
  METHOD constructor.
    mv_id = iv_id.
  ENDMETHOD.

  METHOD get_name.
    rv_name = mv_name.
  ENDMETHOD.

  METHOD set_status.
    mv_status = iv_status.
  ENDMETHOD.
ENDCLASS.

" NEW Operator
DATA(lo_customer) = NEW zcl_customer( iv_id = 1 ).

" Methodenaufruf
DATA(lv_name) = lo_customer->get_name( ).
lo_customer->set_status( 'ACTIVE' ).

INTERFACE zif_processor.
  METHODS process
    IMPORTING iv_data TYPE string
    RETURNING VALUE(rv_result) TYPE string.
ENDINTERFACE.

CLASS zcl_impl DEFINITION.
  PUBLIC SECTION.
    INTERFACES zif_processor.
ENDCLASS.

CLASS zcl_impl IMPLEMENTATION.
  METHOD zif_processor~process.
    rv_result = |Verarbeitet: { iv_data }|.
  ENDMETHOD.
ENDCLASS.

TRY.
    DATA(lv_customer) = lt_customers[ id = lv_id ].
  CATCH cx_sy_itab_line_not_found INTO DATA(lx_error).
    " Fehlerbehandlung
    DATA(lv_msg) = lx_error->get_text( ).
ENDTRY.

" Mehrere Exceptions
TRY.
    " Code
  CATCH cx_sy_arithmetic_error.
    " Division durch 0
  CATCH cx_sy_conversion_error.
    " Konvertierungsfehler
  CATCH cx_root INTO DATA(lx_any).
    " Alle anderen
ENDTRY.

TRY.
    " Code mit Ressourcen
  CATCH cx_error.
    " Error handling
  CLEANUP.
    " Ressourcen freigeben (immer ausgeführt)
    lo_resource->close( ).
ENDTRY.

CLASS zcx_my_exception DEFINITION
  PUBLIC
  INHERITING FROM cx_static_check
  FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    METHODS constructor
      IMPORTING textid TYPE sotr_conc OPTIONAL.
ENDCLASS.

" Verwenden
IF lv_invalid.
  RAISE EXCEPTION TYPE zcx_my_exception.
ENDIF.

" READ
READ ENTITIES OF zi_travel
  ENTITY Travel
    FIELDS ( TravelId AgencyId Status )
    WITH VALUE #( ( TravelId = lv_id ) )
  RESULT DATA(lt_travel).

" CREATE
MODIFY ENTITIES OF zi_travel
  ENTITY Travel
    CREATE FIELDS ( AgencyId CustomerId BeginDate )
    WITH VALUE #( (
      %cid = 'CID_1'
      AgencyId = '000001'
      CustomerId = '000010'
      BeginDate = cl_abap_context_info=>get_system_date( )
    ) ).

" UPDATE
MODIFY ENTITIES OF zi_travel
  ENTITY Travel
    UPDATE FIELDS ( Status )
    WITH VALUE #( ( TravelId = lv_id Status = 'A' ) ).

" DELETE
MODIFY ENTITIES OF zi_travel
  ENTITY Travel
    DELETE FROM VALUE #( ( TravelId = lv_id ) ).

" COMMIT
COMMIT ENTITIES.

" Action ausführen
MODIFY ENTITIES OF zi_travel
  ENTITY Travel
    EXECUTE acceptTravel FROM VALUE #( ( TravelId = lv_id ) )
  RESULT DATA(lt_result).

@AbapCatalog.sqlViewName: 'ZVCUSTOMER'
@AccessControl.authorizationCheck: #CHECK
@EndUserText.label: 'Customer View'

define view Z_Customer
  as select from ztab_customers
{
  key id           as CustomerId,
      name         as CustomerName,
      email        as Email,
      @Semantics.amount.currencyCode: 'Currency'
      credit_limit as CreditLimit,
      currency     as Currency
}

define view Z_CustomerOrders
  as select from ztab_customers as c
  association [0..*] to ztab_orders as _Orders
    on c.id = _Orders.customer_id
{
  key c.id,
      c.name,
      c.email,

      _Orders // Expose association
}

@Analytics.dataCategory: #CUBE
@Analytics.query: true
@VDM.viewType: #CONSUMPTION

define view Z_SalesAnalytics
  as select from ztab_sales
{
  @Analytics.dimension: true
  product_id,

  @Aggregation.default: #SUM
  @Semantics.amount.currencyCode: 'Currency'
  revenue,

  currency
}

" Inline-Deklarationen
DATA(lv_result) = calculate_value( ).

" VALUE Constructor
DATA(lt_data) = VALUE ty_table( ( id = 1 ) ).

" String Templates
DATA(lv_msg) = |Fehler: { lv_error_code }|.

" Table Expressions
DATA(ls_customer) = lt_customers[ id = lv_id ].

" Method Chaining
DATA(lv_final) = lo_object->method1( )->method2( )->get_result( ).

" Veraltete Deklaration
DATA lv_result TYPE string.
lv_result = calculate_value( ).

" CONCATENATE statt String Template
CONCATENATE 'Fehler:' lv_error_code INTO lv_msg SEPARATED BY space.

" Unnötige Hilfsvariablen
DATA ls_customer TYPE ty_customer.
READ TABLE lt_customers INTO ls_customer WITH KEY id = lv_id.