Improve ABAP Code Performance: Practical Techniques and Examples

In SAP systems, performance is a critical factor that directly affects the user experience. Especially when working with large data volumes, how optimized your code is and how efficiently it utilizes system resources determines the overall performance.

In this post, we'll go over practical methods to improve performance in ABAP code with real-life examples.

Avoid Unnecessary SELECT Statements - Prefer CDS Views

Each SELECT statement is a database call. Unnecessary queries slow down the system.

Bad Example:

LOOP AT products INTO DATA(product).

  SELECT SINGLE * FROM mara WHERE matnr = product-matnr.

ENDLOOP.

In this example, a separate query is executed for each product and it leads to poor performance.

Good Example:

  SELECT * FROM i_product

    FOR ALL ENTRIES IN @products

    WHERE Product = @products-Product

    INTO TABLE @DATA(result).

Using FOR ALL ENTRIES along with released CDS views leads to fewer queries and faster results!

Fetch Only the Fields You Need

Only select the fields you actually need from the database. This reduces memory usage and speeds up data transfer.

Bad Example:

SELECT * FROM i_product INTO TABLE @result.

Good Example:

SELECT Product, ProductExternalID, ProductType FROM i_product INTO TABLE @result.

Optimize Your LOOPs

LOOP AT blocks are among the most resource-heavy operations in ABAP.

Poorly structured loops — especially nested ones — can drastically affect performance.

Bad Example:

LOOP AT purchase_orders INTO DATA(purchase_order).

  LOOP AT purchase_order_items INTO DATA(purchase_order_item)

    WHERE ebeln = purchase_order-ebeln.

    " processing

  ENDLOOP.

ENDLOOP.

Good Example:

SORT purchase_order_items BY ebeln.

LOOP AT purchase_orders INTO DATA(purchase_order).

  IF line_exists( purchase_order_items[ ebeln = purchase_order-ebeln ] ).

    " processing

  ENDIF.

ENDLOOP.

Use FIELD-SYMBOLS and ASSIGN

FIELD-SYMBOLS allow reference-based access to data, avoiding unnecessary copying and improving performance.

LOOP AT products ASSIGNING FIELD-SYMBOL(<product>).

  <product>-mtart = 'FERT'.

ENDLOOP.

This is especially effective when dealing with large structures or internal tables.

Code Shortening with New Syntax = Cleaner & Faster Code

The new ABAP syntax not oççnly makes your code cleaner and more readable, it’s often more efficient too.

APPEND VALUE #( product = '1000001' ) TO products.

No need for DATA, CLEAR, or MOVE statements anymore.

Use Binary Search with Internal Tables

When working with large internal tables, using binary search with READ TABLE is much faster but the table must be sorted.

SORT products BY product.

READ TABLE products WITH KEY product = '1000001' BINARY SEARCH.

However, modern ABAP provides more elegant and readable alternatives:

DATA(result) = products[ product = '1000001' ].

This syntax looks clean, but it doesn’t perform a binary search in the background.
If performance is critical and the dataset is large, define a SORTED TABLE like this:

TYPES: BEGIN OF ty_product,

         product TYPE matnr,

         name    TYPE maktx,

       END OF ty_product.

TYPES: tt_products TYPE SORTED TABLE OF ty_product

                    WITH UNIQUE KEY product.

DATA(products) = VALUE tt_products(

  ( product = '1000001' name = 'Keyboard' )

  ( product = '1000002' name = 'Mouse'    )

).

DATA(result) = products[ product = '1000001' ].

Benefits

• Improved readability
• Automatic binary search thanks to SORTED TABLE
• No need for READ TABLE
• Modern, clean, and high-performing

Clean Up Unused Data

After working with large internal tables, freeing up memory helps improve performance.

Bad Example:

LOOP AT products INTO DATA(product).
product_detail-number = product-ProductID.
product_detail-name   = product-Product.
append product_detail TO product_details.

ENDLOOP.
DELETE ADJACENT DUPLICATES FROM product_details COMPARING number.

Good Example:

product_details = CORRESPONDING #( products DISCARDING DUPLICATES MAPPING number = ProductID name = Product ).

Duplicate records not only waste memory, but also complicate business logic.

FREE sales_data.

CLEAR resets content, but FREE releases memory completely — crucial for large internal tables. 

Use SQL Trace (ST05) and Runtime Analysis (SAT)

If you want to identify where your code is slowing down, SAP offers powerful tools to help with performance analysis.

• ST05 (SQL Trace) lets you monitor database-level queries and see how long each one takes, helping you detect inefficient or slow-performing SQL statements.
• SAT (Runtime Analysis), or SE30 in older systems, provides detailed insights into which lines of code consume the most time during execution, making it easier to pinpoint performance bottlenecks.
• In addition, the Extended Check (Transaction code: SLIN) focuses more on code quality than performance. It analyzes your ABAP code for structural and logical issues—such as excessive use of global variables, missing CHECK statements, or inefficient SELECT usage.

Using these three tools together gives you a well-rounded view of both performance and code quality, helping you build more robust and efficient ABAP applications.

Conclusion

Performance isn't just a technical detail — it's a key success metric that directly affects user satisfaction and system efficiency.

In this article, we explored:

• The power of modern ABAP approaches
• Benefits of using released CDS views
• Comparisons between classic and new syntax
• Practical techniques to boost in-code performance

Always ask yourself:
“Does it just work, or does it work at its best?”

By adopting modern ABAP techniques, you can build faster, cleaner, and future-proof solutions. Contact our SAP ABAP Consultants for more detailed information.