Mastering SAP HANA Code Pushdown: Techniques, Use Cases, and Code Examples

The evolution of SAP ERP systems has reached a pivotal junction with the introduction of the SAP HANA database. For decades, ABAP developers followed the traditional "Data-to-Code" paradigm, where the application server would fetch massive amounts of data from the database, bring it into the application layer, and then perform calculations using internal tables and loops. However, with the advent of SAP HANA’s in-memory computing capabilities, this approach has become a bottleneck. To leverage the true power of HANA, SAP introduced the Code-to-Data paradigm, commonly known as Code Pushdown.

Why Do We Need Code Pushdown in SAP HANA?

Before diving into the techniques, it is essential to understand the "Why." Standard databases are optimized for disk storage, whereas SAP HANA is an in-memory, column-oriented database. The primary goal of Code Pushdown is to minimize the amount of data transferred between the Database Layer and the Application Layer (ABAP Layer).

• Reduced Data Traffic: Moving millions of rows to the application server for a simple sum calculation is inefficient. Pushing the calculation to the database ensures only the result (a single value) is sent back.
• Parallel Processing: SAP HANA can process data in parallel across multiple CPU cores. By pushing logic down, you utilize this hardware efficiency.
• Complex Calculations: Tasks like currency conversions, unit conversions, and date calculations can be handled natively by HANA much faster than by ABAP loops.
• Real-time Analytics: With S/4HANA, the line between OLTP (transactional) and OLAP (analytical) systems has blurred. Code pushdown allows for real-time reporting directly on live transactional data.

Top Techniques for SAP HANA Code Pushdown

SAP provides three primary levels of code pushdown, ranging from simple SQL enhancements to complex database procedures.

1. Enhanced Open SQL (New Syntax)

The first and easiest way to implement code pushdown is through the enhanced features of Open SQL. Since ABAP 7.40 and 7.50, Open SQL has been significantly improved to support various expressions, aggregations, and conditional logic directly within the SELECT statement.

SELECT carrid,
       connid,
       price,
       currency,
       CASE
         WHEN price > 1000 THEN 'High Price'
         WHEN price > 500  THEN 'Medium Price'
         ELSE 'Low Price'
       END AS price_category,
       ( price * 1.10 ) AS price_with_tax
  FROM sflight
  INTO TABLE @DATA(lt_flights)
  WHERE carrid = 'AA'.
        

Use Case: Use New Open SQL when you need to perform basic arithmetic, string concatenations, or conditional CASE statements without creating separate database objects. It is the most "future-proof" method because it remains database-agnostic while still benefiting from HANA's speed.

2. Core Data Services (CDS Views)

CDS is the cornerstone of modern SAP development. Unlike traditional SE11 views, CDS views are defined using a DDL (Data Definition Language) and are stored both in the ABAP layer and the Database layer. They offer rich features like Annotations, Associations (Lazy Joins), and powerful built-in functions.

@AbapCatalog.sqlViewName: 'ZSALES_VIEW'
@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Sales Analysis View'

define view Z_I_SalesByCustomer
  as select from vbak as Header
  association [1..*] to vbap as _Items on $projection.SalesOrder = _Items.vbeln
{
    key Header.vbeln as SalesOrder,
    Header.kunnr as Customer,
    @Semantics.amount.currencyCode: 'Currency'
    sum(_Items.netwr) as TotalGrossAmount,
    Header.waerk as Currency,
    /* Ad-hoc calculation pushed to DB */
    dats_days_between(Header.erdat, $session.system_date) as AgeInDays,
    
    /* Exposing association */
    _Items
}
group by Header.vbeln, Header.kunnr, Header.waerk, Header.erdat
        

Use Case: Use CDS Views for reusability. If multiple applications (Fiori apps, ABAP reports, OData services) need the same data logic, CDS is the best choice. It acts as the "Semantic Layer" of S/4HANA.

3. ABAP Managed Database Procedures (AMDP)

When Open SQL and CDS are not enough—specifically when you need complex logic involving multiple steps, temporary tables, or native HANA functions—AMDP is the solution. AMDP allows you to write SQLScript (HANA's native language) directly inside a standard ABAP Class.

CLASS zcl_sales_calculator DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    INTERFACES if_amdp_marker_hdb. -- Marker Interface for AMDP
    
    TYPES: BEGIN OF ty_result,
             vbeln TYPE vbeln,
             complex_tax TYPE netwr,
           END OF ty_result,
           tt_result TYPE STANDARD TABLE OF ty_result WITH EMPTY KEY.

    METHODS calculate_complex_tax
      IMPORTING VALUE(iv_client) TYPE mandt
      EXPORTING VALUE(et_result) TYPE tt_result.
ENDCLASS.

CLASS zcl_sales_calculator IMPLEMENTATION.
  METHOD calculate_complex_tax BY DATABASE PROCEDURE
                               FOR HDB
                               LANGUAGE SQLSCRIPT
                               USING vbak.
    -- Native SQLScript logic starts here
    et_result = SELECT vbeln, 
                       (netwr * 0.15) as complex_tax
                FROM vbak
                WHERE mandt = :iv_client;
  ENDMETHOD.
ENDCLASS.
        

Use Case: Use AMDP when you have intensive mathematical computations, such as predictive analysis, complex financial depreciation cycles, or when you need to use HANA-specific features like Windowing Functions (RANK, ROW_NUMBER) that aren't fully supported in CDS yet.

The "Golden Rules" of Performance in SAP HANA

While Code Pushdown is powerful, it must be used wisely. Here are the core principles to follow when developing for a HANA-based system:

1. Keep the Result Set Small: Use selective WHERE clauses to ensure you only pull necessary records.
2. Minimize Data Transfer: Only select the columns you need. Avoid SELECT *.
3. Avoid Multiple Hops: Don't call a database procedure inside a loop in ABAP. It's better to pass a whole table of data to the DB once.
4. Prefer CDS over AMDP: CDS is easier to maintain and integrated better with the ABAP Dictionary. Use AMDP only as a last resort for extreme complexity.
5. Search First, Sort Later: Use the database's indexing and column-store capabilities to filter data before it ever reaches the application layer.

Comparison: CDS vs. AMDP

Feature	CDS Views	AMDP
Language	DDL (SQL-like)	SQLScript (Native HANA)
Reusability	High (can be used in other CDS)	Medium (Method calls)
Complexity	Low to Medium	Very High
Integration	Excellent with Fiori/UI5	Used mostly for Backend Logic

Conclusion

Embracing Code Pushdown techniques is no longer optional for SAP developers; it is a necessity for anyone working on S/4HANA environments. By utilizing New Open SQL for simple tasks, CDS Views for reusable data modeling, and AMDP for complex calculations, you can transform slow, legacy reports into lightning-fast, real-time applications. Always remember: "Do as much as possible in the database, but as little as necessary." This balance ensures your SAP landscape remains performant, scalable, and easy to maintain.

Note: To implement these techniques, ensure your SAP NetWeaver version is 7.40 SP05 or higher and that you are using ADT (ABAP Development Tools) in Eclipse, as the standard SAP GUI has limited support for CDS and AMDP development.