If you learn only one thing in ABAP, make it internal tables. They are the data structure at the core of every ABAP program that does real work. Reports use them to hold query results. Interfaces use them to pass data between systems. Fiori apps use them to prepare UI data. RAP business objects use them everywhere.

An internal table is a variable that holds multiple rows of data, where each row has the same structure. Think of it as a spreadsheet in memory — columns are fields, rows are records. It lives only inside your program, but it is where all the real processing happens.

In Chapter 6 you learned how to read data from a database. In this chapter you learn where that data goes, how to work with it, and how to feed it back out. This is the chapter that unlocks everything from here onward.

🎯 What You Will Learn in This Chapter

• What an internal table is and why it matters
• The three types: standard, sorted, hashed — and when to use each
• How to declare internal tables with TYPES and DATA
• The five fundamental operations: APPEND, INSERT, READ, LOOP, DELETE
• How to sort, modify, and empty internal tables
• Work areas vs field symbols — how to access rows efficiently
• Performance patterns and common mistakes

🧭 Which Path Should I Choose?

This chapter has the same two learner types as always, but the difference between them is smaller here than anywhere else in the series.

📘 What is an Internal Table?

An internal table is a variable that holds multiple rows, each row having the same structure. It is ABAP’s implementation of what other languages call an array, list, or in-memory table.

An internal table has three components:

Why internal tables matter

Every ABAP program that does real work follows the same pattern:

1. Read data from the database into an internal table
2. Process the data in memory — sort, filter, calculate, transform
3. Write the result back to the database, or output it to the user

That middle step — processing — is entirely done with internal tables. Without them, you would have to re-read from the database for every calculation, which is slow and inefficient.

🎯 The Three Internal Table Types

ABAP has three internal table types, each optimized for different access patterns. Choosing the right one is a mark of a skilled ABAP developer.

How to declare each type

" Standard table — the default choice
DATA lt_standard TYPE STANDARD TABLE OF zcustomer.

" Sorted table — always kept sorted by key
DATA lt_sorted TYPE SORTED TABLE OF zcustomer
  WITH UNIQUE KEY customer_id.

" Hashed table — fastest access by key
DATA lt_hashed TYPE HASHED TABLE OF zcustomer
  WITH UNIQUE KEY customer_id.

Notice the lt_ prefix — that is the naming convention for local tables. Following it makes your code readable at a glance.

📦 Work Areas — How to Hold One Row

Before you can add rows to an internal table or read from it, you need a work area — a flat structure that holds one row at a time.

" Work area matching the table structure
DATA ls_customer TYPE zcustomer.

" Internal table of the same structure
DATA lt_customers TYPE STANDARD TABLE OF zcustomer.

The ls_ prefix means “local structure” (work area) and lt_ means “local table”. Together they are the workhorses of ABAP.

Filling the work area and appending

ls_customer-customer_id   = 'C001'.
ls_customer-customer_name = 'Rahul Sharma'.
ls_customer-city          = 'Pune'.

APPEND ls_customer TO lt_customers.

Inline declaration (modern syntax)

In modern ABAP, you can declare the work area inline when reading:

LOOP AT lt_customers INTO DATA(ls_row).
  cl_demo_output=>write( ls_row-customer_name ).
ENDLOOP.

The DATA(ls_row) syntax creates the work area on the fly. It is clean and works in both Classic ABAP (newer releases) and ABAP Cloud.

➕ APPEND — Adding Rows

APPEND adds a row to the end of a standard table. It is the most-used operation for building up a table row by row.

DATA lt_customers TYPE STANDARD TABLE OF zcustomer.
DATA ls_customer TYPE zcustomer.

" Add the first customer
ls_customer-customer_id   = 'C001'.
ls_customer-customer_name = 'Rahul Sharma'.
ls_customer-city          = 'Pune'.
APPEND ls_customer TO lt_customers.

" Add the second customer
ls_customer-customer_id   = 'C002'.
ls_customer-customer_name = 'Priya Patel'.
ls_customer-city          = 'Mumbai'.
APPEND ls_customer TO lt_customers.

" Check how many rows are in the table
cl_demo_output=>write( |Total rows: { lines( lt_customers ) }| ).

➕ INSERT — Adding Rows at Specific Positions

INSERT adds a row to a specific position or follows the table’s own ordering rules.

Insert at a specific index (standard table)

INSERT ls_customer INTO lt_customers INDEX 1.

Insert into a sorted table

INSERT ls_customer INTO TABLE lt_sorted.

The sorted table automatically places the row in the correct sorted position based on its key.

Insert into a hashed table

INSERT ls_customer INTO TABLE lt_hashed.

The hashed table places the row wherever the hash algorithm determines. Position is not meaningful.

🔍 READ — Finding Specific Rows

READ TABLE retrieves one specific row without looping through all of them.

Read by index (standard and sorted tables)

READ TABLE lt_customers INTO ls_customer INDEX 2.

IF sy-subrc = 0.
  cl_demo_output=>write( |Row 2 is: { ls_customer-customer_name }| ).
ENDIF.

Read by key

READ TABLE lt_customers INTO ls_customer
  WITH KEY customer_id = 'C001'.

IF sy-subrc = 0.
  cl_demo_output=>write( |Found: { ls_customer-customer_name }| ).
ELSE.
  cl_demo_output=>write( 'Customer C001 not found.' ).
ENDIF.

🔁 LOOP — Processing All Rows

LOOP AT iterates through every row of an internal table. It is the workhorse for processing data.

Basic loop

LOOP AT lt_customers INTO ls_customer.
  cl_demo_output=>write( |{ ls_customer-customer_id }: { ls_customer-customer_name }| ).
ENDLOOP.

Modern loop with inline work area

LOOP AT lt_customers INTO DATA(ls_row).
  cl_demo_output=>write( ls_row-customer_name ).
ENDLOOP.

Loop with filtering (WHERE clause)

LOOP AT lt_customers INTO ls_customer
  WHERE city = 'Pune'.
  cl_demo_output=>write( ls_customer-customer_name ).
ENDLOOP.

Accessing the loop index: sy-tabix

LOOP AT lt_customers INTO ls_customer.
  cl_demo_output=>write( |Row { sy-tabix }: { ls_customer-customer_name }| ).
ENDLOOP.

🔤 SORT — Ordering Rows

SORT reorders a standard table. Sorted and hashed tables maintain their own order automatically, so SORT applies mostly to standard tables.

Sort by a single field

SORT lt_customers BY customer_name.

Sort by multiple fields

SORT lt_customers BY city customer_name.

Sort descending

SORT lt_customers BY customer_id DESCENDING.

🗑️ DELETE — Removing Rows

DELETE removes rows from an internal table. Just like database DELETE, always specify what to remove.

Delete by index

DELETE lt_customers INDEX 1.

Delete by condition

DELETE lt_customers WHERE city = 'Mumbai'.

Delete all rows

CLEAR lt_customers.

✏️ MODIFY — Changing Existing Rows

MODIFY updates a row that already exists in an internal table. It is the internal-table equivalent of SQL UPDATE.

" Read a row into the work area
READ TABLE lt_customers INTO ls_customer
  WITH KEY customer_id = 'C001'.

IF sy-subrc = 0.
  " Modify the work area
  ls_customer-city = 'Delhi'.

  " Write it back to the same row
  MODIFY lt_customers FROM ls_customer
    TRANSPORTING city
    WHERE customer_id = 'C001'.
ENDIF.

TRANSPORTING specifies which fields to write back. If you omit it, the entire work area replaces the row.

Modify inside a LOOP (modern style)

LOOP AT lt_customers INTO ls_customer.
  ls_customer-city = 'Delhi'.
  MODIFY lt_customers FROM ls_customer.
ENDLOOP.

🛠 Full Worked Example

Let’s put everything together. This program reads customers from the database into an internal table, processes them, and outputs the results.

🔵 Paid Path (Classic ABAP in SE38)

REPORT zinttab_ch7_demo.

DATA: lt_customers TYPE STANDARD TABLE OF zcustomer,
      ls_customer  TYPE zcustomer.

" 1. Read all customers from the database
SELECT * FROM zcustomer
  INTO TABLE lt_customers.

IF sy-subrc <> 0.
  WRITE: / 'No customers found.'.
  RETURN.
ENDIF.

WRITE: / 'Total rows:', lines( lt_customers ).

" 2. Sort by city then name
SORT lt_customers BY city customer_name.

" 3. Loop and display
LOOP AT lt_customers INTO ls_customer.
  WRITE: / sy-tabix,
            ls_customer-customer_id,
            ls_customer-customer_name,
            ls_customer-city.
ENDLOOP.

" 4. Count customers in Pune
DATA(lv_pune_count) = 0.
LOOP AT lt_customers INTO ls_customer WHERE city = 'Pune'.
  lv_pune_count = lv_pune_count + 1.
ENDLOOP.
WRITE: / 'Customers in Pune:', lv_pune_count.

" 5. Read a specific customer by key
READ TABLE lt_customers INTO ls_customer
  WITH KEY customer_id = 'C001'.

IF sy-subrc = 0.
  WRITE: / 'Found C001:', ls_customer-customer_name.
ENDIF.

🟢 Free Path (ABAP Cloud in Eclipse ADT)

METHOD run.
  " Read from a CDS View into an internal table
  SELECT * FROM zi_customer
    INTO TABLE @DATA(lt_customers).

  IF sy-subrc <> 0.
    cl_demo_output=>write( 'No customers found.' ).
    cl_demo_output=>display( ).
    RETURN.
  ENDIF.

  cl_demo_output=>write( |Total rows: { lines( lt_customers ) }| ).

  " Sort by city then name
  SORT lt_customers BY city customer_name.

  " Loop and output
  LOOP AT lt_customers INTO DATA(ls_customer).
    cl_demo_output=>write( |{ sy-tabix }: { ls_customer-customer_name } ({ ls_customer-city })| ).
  ENDLOOP.

  cl_demo_output=>display( ).
ENDMETHOD.

⚡ Performance Patterns

Internal tables look simple, but the wrong pattern can be 1000x slower than the right one on large data. Here are the rules that matter.

🧠 What Just Happened Under the Hood

Understanding how ABAP manages internal tables in memory helps you write better code.

This is why choosing the right table type matters. On 10 rows, performance is invisible. On 100,000 rows, using READ on a standard table inside a loop can freeze the program for minutes.

📝 Chapter Summary

• An internal table holds multiple rows of data in memory.
• The three types are STANDARD (default), SORTED (sorted by key), and HASHED (fastest by key).
• A work area holds one row at a time. Its prefix is ls_. The table’s prefix is lt_.
• APPEND adds a row at the end of a standard table.
• INSERT adds a row at a specific position or into a sorted/hashed table.
• READ TABLE finds a specific row. Always check sy-subrc.
• LOOP AT iterates over rows. Use sy-tabix for the current index.
• SORT reorders a standard table. DELETE removes rows. MODIFY changes existing rows.
• Performance matters: use READ with a key on sorted/hashed tables, not LOOP inside LOOP.
• The internal table syntax is nearly identical in Classic ABAP and ABAP Cloud — one of the most portable skills you will ever learn.