GitHub Copilot for ABAP: Boost Productivity with AI

Bottom-right in VS Code: Copilot icon
- Green = Active
- Red = Error (check sign-in)

" Implement validation to check if customer exists in I_Customer
METHOD validateCustomer FOR VALIDATE ON SAVE
  IMPORTING keys FOR Travel~validateCustomer.

  " Read travel data
  READ ENTITIES OF zi_travel IN LOCAL MODE
    ENTITY Travel
      FIELDS ( CustomerId )
      WITH CORRESPONDING #( keys )
    RESULT DATA(lt_travel).

  " Get all customer IDs
  DATA(lt_customer_ids) = VALUE string_table(
    FOR travel IN lt_travel ( travel-CustomerId )
  ).

  " Check if customers exist
  SELECT Customer
    FROM I_Customer
    FOR ALL ENTRIES IN @lt_customer_ids
    WHERE Customer = @lt_customer_ids-table_line
    INTO TABLE @DATA(lt_existing_customers).

  " Report errors for non-existing customers
  LOOP AT lt_travel INTO DATA(ls_travel).
    IF NOT line_exists( lt_existing_customers[ table_line = ls_travel-CustomerId ] ).
      APPEND VALUE #(
        %tky = ls_travel-%tky
        %element-CustomerId = if_abap_behv=>mk-on
      ) TO failed-travel.

      APPEND VALUE #(
        %tky = ls_travel-%tky
        %element-CustomerId = if_abap_behv=>mk-on
        %msg = new_message_with_text(
          severity = if_abap_behv_message=>severity-error
          text     = |Customer { ls_travel-CustomerId } does not exist|
        )
      ) TO reported-travel.
    ENDIF.
  ENDLOOP.
ENDMETHOD.

-- CDS View for Sales Orders with customer name and total amount
-- Include association to customer

@AccessControl.authorizationCheck: #CHECK
@EndUserText.label: 'Sales Orders with Customer Data'

define view entity ZI_SalesOrderWithCustomer
  as select from I_SalesOrder as Order
  association [0..1] to I_Customer as _Customer
    on Order.SoldToParty = _Customer.Customer
{
  key Order.SalesOrder,
      Order.SalesOrderType,
      Order.SalesOrganization,
      Order.SoldToParty,
      Order.CreationDate,

      @Semantics.amount.currencyCode: 'TransactionCurrency'
      Order.TotalNetAmount,

      @Semantics.currencyCode: true
      Order.TransactionCurrency,

      Order.OverallSDProcessStatus,

      // Customer data via association
      _Customer.CustomerName,
      _Customer.CityName,
      _Customer.Country,

      // Expose association
      _Customer
}

" Unit test for validateCustomer method
" Test case: Customer does not exist → should fail

CLASS ltc_validate_customer DEFINITION FINAL FOR TESTING
  DURATION SHORT RISK LEVEL HARMLESS.

  PRIVATE SECTION.
    DATA mo_env TYPE REF TO if_cds_test_environment.
    METHODS:
      setup,
      teardown,
      test_customer_not_exists FOR TESTING,
      test_customer_exists FOR TESTING.
ENDCLASS.

CLASS ltc_validate_customer IMPLEMENTATION.

  METHOD setup.
    mo_env = cl_cds_test_environment=>create_for_multiple_cds(
      i_for_entities = VALUE #(
        ( i_for_entity = 'ZI_Travel' )
        ( i_for_entity = 'I_Customer' )
      )
    ).

    " Insert test customer
    mo_env->insert_test_data(
      i_data = VALUE i_customer(
        ( Customer = '000042' CustomerName = 'Test Customer' )
      )
    ).
  ENDMETHOD.

  METHOD test_customer_not_exists.
    " Arrange: Travel with non-existing customer
    MODIFY ENTITIES OF zi_travel
      ENTITY Travel
        CREATE FIELDS ( CustomerId )
        WITH VALUE #( ( %cid = 'T1' CustomerId = '999999' ) )
      FAILED DATA(failed).

    " Act: Commit triggers validation
    COMMIT ENTITIES
      RESPONSE OF zi_travel
      FAILED DATA(commit_failed)
      REPORTED DATA(commit_reported).

    " Assert: Should fail
    cl_abap_unit_assert=>assert_not_initial(
      act = commit_failed-travel
      msg = 'Validation should fail for non-existing customer'
    ).

    cl_abap_unit_assert=>assert_bound(
      act = commit_reported-travel[ 1 ]-%msg
      msg = 'Error message should be present'
    ).
  ENDMETHOD.

  METHOD test_customer_exists.
    " Arrange: Travel with existing customer
    MODIFY ENTITIES OF zi_travel
      ENTITY Travel
        CREATE FIELDS ( CustomerId )
        WITH VALUE #( ( %cid = 'T1' CustomerId = '000042' ) )
      FAILED DATA(failed).

    " Act
    COMMIT ENTITIES
      RESPONSE OF zi_travel
      FAILED DATA(commit_failed).

    " Assert: Should succeed
    cl_abap_unit_assert=>assert_initial(
      act = commit_failed-travel
      msg = 'Validation should pass for existing customer'
    ).
  ENDMETHOD.

  METHOD teardown.
    ROLLBACK ENTITIES.
    mo_env->destroy( ).
  ENDMETHOD.

ENDCLASS.

VS Code:
- Ctrl+Shift+I (Windows/Linux)
- Cmd+Shift+I (Mac)
- Or: Sidebar → Chat icon

Explain this ABAP code:
[Select and send code]

DATA(lt_result) = FILTER #( lt_data WHERE status = 'A' ).

This line uses ABAP's inline FILTER expression to create a filtered
internal table. It:

1. Takes source table lt_data
2. Filters rows where status field equals 'A'
3. Assigns result to lt_result (type inferred automatically)

This is equivalent to:
LOOP AT lt_data INTO DATA(ls_row) WHERE status = 'A'.
  APPEND ls_row TO lt_result.
ENDLOOP.

But more concise and performant (single-pass operation).

Refactor this to use modern ABAP syntax:

LOOP AT lt_orders INTO ls_order.
  IF ls_order-status = 'O'.
    ls_order-priority = 'HIGH'.
    MODIFY lt_orders FROM ls_order.
  ENDIF.
ENDLOOP.

" Modern ABAP with inline declaration and modify expression:
MODIFY lt_orders FROM VALUE #(
  FOR order IN lt_orders WHERE ( status = 'O' )
  ( CORRESPONDING #( order ) priority = 'HIGH' )
).

" Or even more concise with COND:
lt_orders = VALUE #(
  FOR order IN lt_orders
  ( CORRESPONDING #( order )
    priority = COND #( WHEN order-status = 'O' THEN 'HIGH'
                       ELSE order-priority ) )
).

Why does this fail?

SELECT * FROM i_salesorder
  WHERE TotalNetAmount > @lv_threshold
  INTO TABLE @lt_orders.

Error: "Field TotalNetAmount unknown"

The error occurs because field names in CDS views are case-sensitive
in the ABAP SQL syntax.

Fix: Check the actual field name in I_SalesOrder CDS view.
It's likely "TotalNetAmount" in the view definition, but you need
to use it exactly as defined.

Try:
SELECT * FROM I_SalesOrder
  FIELDS SalesOrder, TotalNetAmount, TransactionCurrency
  WHERE TotalNetAmount > @lv_threshold
  INTO TABLE @lt_orders.

Also note: Use explicit FIELDS clause for clarity and performance.

" Specific + Context
" Create a RAP determination that calculates TotalPrice
" as BasePrice * Quantity * (1 - Discount/100)
" Trigger: on modify when Quantity or BasePrice changes

" With example
" Convert this SELECT to use path expressions:
" SELECT * FROM vbak
"   INNER JOIN kna1 ON vbak~kunnr = kna1~kunnr
"   WHERE vbak~vbeln = @lv_order.

" Name constraints
" Write a validation that checks:
" 1. BeginDate not in past
" 2. EndDate after BeginDate
" 3. Max duration 365 days
" Use message class ZTRAVEL

" Specify technology
" Implement OData V4 action 'approve' for Travel entity
" Input: ApprovalNote (string)
" Output: Updated Travel with Status='A'
" Use RAP Business Object pattern

" Too vague
" Write some validation

" Too complex (in one prompt)
" Build a complete RAP application with Travel, Booking, Customer,
" including all CRUD, validations, determinations, actions, OData service,
" Fiori UI, and deployment to BTP

" Without context
" Fix this code:
SELECT * FROM table WHERE field = value.
" → Copilot doesn't know: Which table? What error?

" Unclear requirement
" Make this better
" → What does "better" mean? Performance? Readability?

" Validation for [ENTITY]: [VALIDATION_NAME]
" Business rules:
" 1. [RULE_1]
" 2. [RULE_2]
" Trigger: on save, fields [FIELD_LIST]
" Error message: [MESSAGE_TEXT]
METHOD [methodName] FOR VALIDATE ON SAVE
  IMPORTING keys FOR [Entity]~[validationName].

-- CDS View: [VIEW_NAME]
-- Purpose: [DESCRIPTION]
-- Data source: [SOURCE_TABLE/VIEW]
-- Include:
--   - Fields: [FIELD_LIST]
--   - Association to: [RELATED_ENTITIES]
--   - Filter: [WHERE_CONDITION if any]

" Unit test for [METHOD_NAME]
" Test case: [SCENARIO]
" Arrange: [SETUP_DESCRIPTION]
" Act: [ACTION_DESCRIPTION]
" Assert: [EXPECTED_RESULT]

" Legacy code:
REPORT z_sales_report.

TABLES: vbak.

SELECT-OPTIONS: s_vbeln FOR vbak-vbeln.

START-OF-SELECTION.
  SELECT vbak~vbeln vbak~erdat vbak~kunnr kna1~name1 vbak~netwr
    FROM vbak
    INNER JOIN kna1 ON vbak~kunnr = kna1~kunnr
    WHERE vbak~vbeln IN @s_vbeln
    INTO TABLE @DATA(lt_orders).

  cl_salv_table=>factory(
    IMPORTING r_salv_table = DATA(lo_alv)
    CHANGING  t_table      = lt_orders ).

  lo_alv->display( ).

Convert this classic ABAP report to:
1. CDS View with UI annotations
2. RAP Query (read-only)
3. OData V4 service
4. Fiori Elements UI
Target: ABAP Cloud compatible

-- 1. CDS View
@AccessControl.authorizationCheck: #CHECK
@EndUserText.label: 'Sales Report'
@Metadata.allowExtensions: true

@UI: {
  headerInfo: {
    typeName: 'Sales Order',
    typeNamePlural: 'Sales Orders'
  }
}

define view entity ZC_SalesReport
  as select from I_SalesOrder as Order
  association [0..1] to I_Customer as _Customer
    on Order.SoldToParty = _Customer.Customer
{
      @UI.lineItem: [{ position: 10 }]
      @UI.selectionField: [{ position: 10 }]
  key Order.SalesOrder,

      @UI.lineItem: [{ position: 20 }]
      Order.CreationDate,

      @UI.lineItem: [{ position: 30 }]
      Order.SoldToParty,

      @UI.lineItem: [{ position: 40 }]
      _Customer.CustomerName,

      @UI.lineItem: [{ position: 50 }]
      @Semantics.amount.currencyCode: 'TransactionCurrency'
      Order.TotalNetAmount,

      Order.TransactionCurrency,

      _Customer
}

-- 2. Service Definition
@EndUserText.label: 'Sales Report Service'
define service ZUI_SalesReport {
  expose ZC_SalesReport as SalesOrders;
}

3. Service Binding: OData V4 - UI
4. Publish → Fiori Preview
→ Done! From 50-line report to cloud-ready Fiori app

" Read Travel with all Bookings where BookingDate is within last 30 days
" Also load Customer data via association
" Sort by BookingDate descending

" Read Travel with recent Bookings and Customer data
READ ENTITIES OF zi_travel IN LOCAL MODE
  ENTITY Travel
    ALL FIELDS
    WITH VALUE #( ( TravelId = lv_travel_id ) )
  RESULT DATA(lt_travel)

  " Navigate to Bookings
  ENTITY Travel BY \_Bookings
    ALL FIELDS
    WITH VALUE #( ( TravelId = lv_travel_id ) )
  RESULT DATA(lt_all_bookings)

  " Navigate to Customer
  ENTITY Travel BY \_Customer
    ALL FIELDS
    WITH VALUE #( ( TravelId = lv_travel_id ) )
  RESULT DATA(lt_customer).

" Filter Bookings (last 30 days)
DATA(lv_cutoff_date) = cl_abap_context_info=>get_system_date( ) - 30.

DATA(lt_recent_bookings) = FILTER #( lt_all_bookings
  WHERE BookingDate >= lv_cutoff_date ).

" Sort by BookingDate descending
SORT lt_recent_bookings BY BookingDate DESCENDING.

" Output
WRITE: / |Travel: { lt_travel[ 1 ]-TravelId }|.
WRITE: / |Customer: { lt_customer[ 1 ]-CustomerName }|.
WRITE: / |Recent Bookings: { lines( lt_recent_bookings ) }|.

LOOP AT lt_recent_bookings INTO DATA(ls_booking).
  WRITE: / |  - { ls_booking-BookingDate DATE = USER }: | &&
         |{ ls_booking-CarrierId } { ls_booking-FlightPrice }|.
ENDLOOP.

Optimize this code for performance:

[Insert slow code]

LOOP AT lt_orders INTO DATA(ls_order).
  SELECT SINGLE name1 FROM kna1
    WHERE kunnr = ls_order-kunnr
    INTO @DATA(lv_name).
  ls_order-customer_name = lv_name.
  MODIFY lt_orders FROM ls_order.
ENDLOOP.

" Optimized: Single SELECT with FOR ALL ENTRIES
" Avoids N+1 query problem (was: 1 SELECT per order)

" 1. Collect unique customer IDs
DATA(lt_customer_ids) = VALUE kunnr_t(
  FOR order IN lt_orders ( order-kunnr ) ).
DELETE ADJACENT DUPLICATES FROM lt_customer_ids.

" 2. Bulk-read customer names
SELECT kunnr, name1
  FROM kna1
  FOR ALL ENTRIES IN @lt_customer_ids
  WHERE kunnr = @lt_customer_ids-table_line
  INTO TABLE @DATA(lt_customers).

" 3. Update orders with CORRESPONDING
lt_orders = VALUE #(
  FOR order IN lt_orders
  LET customer_name = VALUE #( lt_customers[ kunnr = order-kunnr ]-name1 OPTIONAL )
  IN ( CORRESPONDING #( order ) customer_name = customer_name )
).

" Performance improvement: O(N) instead of O(N²)
" Example: 1000 orders
"   Before: 1000 SELECTs (~10 seconds)
"   After:  2 SELECTs (~0.1 seconds)

VS Code Shortcuts:

Tab              Accept suggestion
Esc              Dismiss suggestion
Alt+]            Next suggestion
Alt+[            Previous suggestion
Ctrl+Enter       Show all suggestions (panel)

Chat:
Ctrl+Shift+I     Open chat
/explain         Explain selected code
/fix             Suggest fix for error
/tests           Generate unit tests
/doc             Generate documentation

Inline Chat (in editor):
Ctrl+I           Inline chat at cursor

" Cannot know company-specific logic
" Copilot does NOT know:
" - Your internal number ranges
" - Custom Z-table structures
" - Your company's business rules
" → Must be adjusted manually

" Cannot plan complex architectures
" Copilot can generate code, but NOT:
" - Design microservice architecture
" - Decide: Managed vs Unmanaged RAP
" - Analyze performance bottlenecks (without profiling data)

" Cannot do security audits
" Copilot code may contain:
" - SQL Injection (if not reviewed)
" - Hardcoded Credentials (from training data)
" - Missing Authorization Checks
" → Code Review is MANDATORY!

" Cannot be 100% correct
" Copilot makes mistakes:
" - Syntax errors (rare, but possible)
" - Logic errors (business rules wrong)
" - Suggest deprecated APIs
" → Always test!

" Copilot as assistant, not replacement
" - Use suggestions as starting point
" - Review EVERY generated code
" - Test thoroughly

" Work iteratively
" - Prompt → Generate → Review → Refine → Repeat

" Be security conscious
" - Remove Copilot-generated secrets
" - Check authorization checks
" - Follow OWASP Top 10

" Code Review
" - Treat generated code like external code
" - Pair programming with Copilot

" Learning
" - Copilot shows best practices
" - Understand the generated code (don't copy blindly!)

Hourly rate: €60
License: €15/month
Savings: 5 hours/month (at 30% productivity)
→ €300/month saved
→ ROI: 2000% (!)