Introduction
One of the most common performance issues in SAP ABAP programs occurs when developers use nested loops on large internal tables. While this approach may work for small datasets, it quickly becomes a disaster in production systems handling thousands or millions of records.This is where the Parallel Cursor in SAP ABAP plays a crucial role.
In this blog, we’ll cover:
- What the Parallel Cursor technique is
- Why it is important for performance optimization
- When and when not to use it
- A step‑by‑step example
- Real‑world performance benefits
- Best practices and common pitfalls
This guide is suitable for ABAP developers at all experience levels, especially those working on performance tuning and S/4HANA systems.
What Is Parallel Cursor in SAP ABAP?
The Parallel Cursor technique is an ABAP performance optimization method used to avoid nested loops by synchronizing two internal tables using an index rather than repetitive scanning.
Instead of reading the second internal table again and again from the beginning, Parallel Cursor ensures:
- Both tables are sorted
- The second loop starts exactly where the key match begins
- A position index (
sy-tabix) is reused
This reduces runtime complexity drastically.
Why Parallel Cursor Is Important
Traditional Nested Loop (Performance Killer)
LOOP AT itab1 INTO DATA(ls1).
LOOP AT itab2 INTO DATA(ls2)
WHERE key = ls1-key.
” processing
ENDLOOP.
ENDLOOP.
Problem:
- Time complexity: O(n × m)
- Repeated scanning of
itab2 - Extremely slow for large datasets
Parallel Cursor Approach (Optimized)
LOOP AT itab1 INTO DATA(ls1).
LOOP AT itab2 INTO DATA(ls2)
FROM lv_index.
IF ls2-key < ls1-key.
CONTINUE.
ELSEIF ls2-key > ls1-key.
lv_index = sy-tabix.
EXIT.
ELSE.
” processing
ENDIF.
ENDLOOP.
ENDLOOP.
Result:
- Time complexity close to O(n + m)
- Massive reduction in runtime
- Scalable solution
Prerequisites for Parallel Cursor
Before using Parallel Cursor, ensure:
- Internal tables are sorted by the same key
- You are looping on large datasets
- Both tables have 1:N or N:N relationships
- Table type is
STANDARD TABLEorSORTED TABLE
Do not use for:
- Very small internal tables
- Hash tables (already optimized)
- Mismatched or unsorted keys
Step‑by‑Step Parallel Cursor in ABAP Example
Scenario
You have:
IT_SALES→ Sales order headersIT_ITEMS→ Sales order items
Each sales order can have multiple items.
Step 1: Sort Both Internal Tables
SORT it_sales BY vbeln.
SORT it_items BY vbeln.
Step 2: Declare Index Variable
DATA: lv_index TYPE sy-tabix.
Step 3: Use Parallel Cursor Logic
LOOP AT it_sales INTO DATA(ls_sales).
LOOP AT it_items INTO DATA(ls_items)
FROM lv_index.
IF ls_items-vbeln < ls_sales-vbeln.
CONTINUE.
ELSEIF ls_items-vbeln > ls_sales-vbeln.
lv_index = sy-tabix.
EXIT.
ELSE.
” Business logic here
ENDIF.
ENDLOOP.
ENDLOOP.
How Parallel Cursor Works Internally in ABAP
- First table loop starts normally
- Second table loop starts from last stored index
- No backward scanning
- Matching keys processed efficiently
- Index updated only when keys diverge
This simulates two cursors running in parallel, hence the name.
Performance Comparison
| Approach | Time Complexity | Suitable for Large Data |
|---|---|---|
| Nested Loop | O(n × m) | No |
| READ TABLE + LOOP | O(n × log m) | Depends |
| Parallel Cursor | O(n + m) | Yes |
In real SAP systems, Parallel Cursor can reduce program runtime from minutes to seconds.
Common Mistakes to Avoid
- Forgetting to sort internal tables
- Using different keys for sorting
- Not resetting index variable properly
- Using Parallel Cursor on HASHED TABLE
- Assuming it works for all scenarios
Parallel Cursor vs READ TABLE
While READ TABLE ... BINARY SEARCH is excellent for 1:1 lookups, Parallel Cursor is better suited for:
- Processing groups of related records
- Header‑item relationships
- One‑to‑many logic
In many real‑world scenarios, Parallel Cursor outperforms repeated READ TABLE calls.
Does Parallel Cursor in ABAP Still Matter in S/4HANA?
Absolutely.
Even with HANA’s in‑memory processing:
- Internal table loops still consume ABAP runtime
- Bad ABAP logic cannot be fixed by HANA
- SAP still recommends optimized ABAP patterns
Parallel Cursor remains relevant, valid, and recommended.
Best Practices
Use meaningful variable names
Validate data is sorted
Measure performance before & after
Combine with clean functional logic
ABAP 7.40+ Tips (Modern Syntax) for Parallel Cursor
- Use table expressions and inline declarations for clarity.
- Consider secondary table keys to speed up lookups without extra sorts.
- Use
REDUCEorFILTERfor concise aggregations—but ensure complexity stays under control. - ABAP SQL with
GROUP BY,AGGREGATE, and proper indexes often outperforms any in-memory pattern.
Sample Code
“————————————————————-
Parallel Cursor Template
” – Driver: lt_a (e.g., headers)
” – Lookup: lt_b (e.g., items)
” Prerequisite: Both have a common key: key
“————————————————————-
DATA: lt_a TYPE STANDARD TABLE OF zty_a WITH EMPTY KEY,
lt_b TYPE STANDARD TABLE OF zty_b WITH EMPTY KEY.
” Fill lt_a and lt_b here (SELECT … INTO TABLE …)
” 1) Sort both tables by the same key
SORT lt_a BY key.
SORT lt_b BY key.
DATA: lv_idx_b TYPE sy-tabix VALUE 1,
ls_a TYPE zty_a,
ls_b TYPE zty_b.
LOOP AT lt_a INTO ls_a.
” 2) Align lookup pointer to current key or next larger
WHILE lv_idx_b <= lines( lt_b ).
READ TABLE lt_b INDEX lv_idx_b INTO ls_b.
IF ls_b-key < ls_a-key.
lv_idx_b += 1.
ELSE.
EXIT.
ENDIF.
ENDWHILE.
” 3) Process the contiguous matching range in lt_b
DATA(lv_start_b) = lv_idx_b.
DATA(lv_end_b) = lv_idx_b – 1.
WHILE lv_end_b + 1 <= lines( lt_b ).
READ TABLE lt_b INDEX lv_end_b + 1 INTO ls_b.
IF ls_b-key = ls_a-key.
lv_end_b += 1.
ELSE.
EXIT.
ENDIF.
ENDWHILE.
IF lv_end_b >= lv_start_b.
” —- Your business logic for the matching block —-
DO lv_end_b – lv_start_b + 1 TIMES.
READ TABLE lt_b INDEX lv_start_b + sy-index – 1 INTO ls_b.
” Process (ls_a, ls_b)
ENDDO.
ENDIF.
ENDLOOP.
Conclusion
The Parallel Cursor technique in SAP ABAP is a powerful and essential tool for writing high‑performance, scalable programs.
If you:
- Work with large internal tables
- Write complex loops
- Care about performance and clean architecture
Then Parallel Cursor is a skill you must master.
Also Read – SAP Career Without Coding: Roles You Can Explore
FAQs
Q1: Does the Parallel Cursor always beat a nested loop?
A: For large tables with many potential matches, yes—because it reduces repeated scans. For small data sets or when the inner table is tiny, the gain may be negligible.
Q2: Is a hashed table faster than Parallel Cursor?
A: For unique key lookups, hashed tables are typically faster and simpler. But if you need to process ranges of non-unique keys efficiently, the parallel cursor (or sorted table + range detection) shines.
Q3: What about database joins?
A: If you can express the logic in SQL, let the database do it. It often outperforms any ABAP-level technique, especially with proper indexes and selective predicates.
Q4: Can I combine Parallel Cursor with BINARY SEARCH?
A: Yes. Use binary search to find the first and last positions of a key in the lookup table, then iterate the identified range linearly.
Q5: Any memory concerns?
A: Sorting creates temporary structures, but typically the overhead is acceptable. If memory is tight, prefer DB-side processing or hashed tables.