15 ABAP on HANA Interview Questions and Answers

ABAP on HANA represents a significant evolution in SAP’s technology stack, combining the robust capabilities of ABAP with the high-performance in-memory computing of SAP HANA. This integration allows for more efficient data processing and real-time analytics, making it a critical skill for professionals working with SAP systems. Mastery of ABAP on HANA can lead to improved application performance and more streamlined business processes.

This article offers a curated selection of interview questions designed to test your knowledge and proficiency in ABAP on HANA. By reviewing these questions and their detailed answers, you will be better prepared to demonstrate your expertise and problem-solving abilities in a technical interview setting.

ABAP on HANA Interview Questions and Answers

1. How would you call a database procedure from ABAP code?

In ABAP on HANA, you can call a database procedure using the ADBC (ABAP Database Connectivity) framework or by using AMDP (ABAP Managed Database Procedures). AMDP is the preferred approach as it allows you to write database procedures directly in ABAP using SQLScript.

Example using AMDP:

CLASS zcl_my_amdp_class DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    INTERFACES: if_amdp_marker_hdb.
    CLASS-METHODS: my_procedure
      IMPORTING
        VALUE(iv_input) TYPE i
      EXPORTING
        VALUE(ev_output) TYPE i.
ENDCLASS.

CLASS zcl_my_amdp_class IMPLEMENTATION.

  METHOD my_procedure BY DATABASE PROCEDURE FOR HDB
    LANGUAGE SQLSCRIPT
    OPTIONS READ-ONLY
    USING my_hana_table.

    ev_output = SELECT COUNT(*) FROM my_hana_table WHERE column = :iv_input;

  ENDMETHOD.

ENDCLASS.

DATA: lv_input  TYPE i VALUE 5,
      lv_output TYPE i.

CALL METHOD zcl_my_amdp_class=>my_procedure
  EXPORTING
    iv_input  = lv_input
  IMPORTING
    ev_output = lv_output.

2. What are some techniques for optimizing ABAP code performance on HANA?

Optimizing ABAP code performance on HANA involves several techniques that leverage HANA’s in-memory processing capabilities:

• Code Pushdown: Move data-intensive operations to the database layer using AMDP or CDS views to reduce data transfer and leverage HANA’s processing power.
• Use of CDS Views: Define complex data models and calculations at the database level for efficient data retrieval and processing.
• Efficient SQL Queries: Optimize SQL queries by avoiding SELECT * statements, using appropriate indexes, and minimizing nested SELECTs.
• Parallel Processing: Utilize techniques like parallel cursors to distribute workload across processors.
• Buffering: Implement buffering for frequently accessed data to reduce database access times.
• Performance Analysis Tools: Use tools like SQL Trace (ST05) and Runtime Analysis (SAT) to identify performance bottlenecks.

3. Describe how to create a basic CDS view.

Core Data Services (CDS) views allow developers to define and consume data models directly on the database layer, enhancing performance and maintenance.

To create a basic CDS view:

• Define the CDS view using @AbapCatalog and @EndUserText annotations.
• Specify the SQL view name and data source.
• Define the fields to be included in the view.

Example:

@AbapCatalog.sqlViewName: 'ZDEMO_CDS_VIEW'
@EndUserText.label: 'Basic CDS View Example'
define view ZDEMO_CDS_VIEW as select from sflight
{
    key carrid,
    key connid,
    fldate,
    price
}

4. How do you implement an AMDP method?

ABAP Managed Database Procedures (AMDP) execute database procedures directly from ABAP programs, leveraging SAP HANA’s power for performance-critical operations.

To implement an AMDP method:

• Create an AMDP class.
• Define an AMDP method within the class.
• Implement the method using SQLScript.

Example:

CLASS zcl_amdp_example DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    INTERFACES: if_amdp_marker_hdb.
    CLASS-METHODS: get_data
      IMPORTING
        VALUE(iv_param) TYPE string
      EXPORTING
        VALUE(et_result) TYPE TABLE OF string.
ENDCLASS.

CLASS zcl_amdp_example IMPLEMENTATION.

  METHOD get_data BY DATABASE PROCEDURE FOR HDB
    LANGUAGE SQLSCRIPT
    OPTIONS READ-ONLY.
    et_result = SELECT column_name
                FROM table_name
                WHERE column_name = :iv_param;
  ENDMETHOD.

ENDCLASS.

5. How would you write a SQL Script procedure in HANA and call it from ABAP?

To write a SQL Script procedure in HANA and call it from ABAP:

1. Create the SQL Script procedure in HANA.
2. Call the procedure from ABAP using the appropriate syntax.

Example of a SQL Script procedure:

CREATE PROCEDURE "MY_SCHEMA"."MY_PROCEDURE" (IN input_param INT, OUT output_param INT)
LANGUAGE SQLSCRIPT
AS
BEGIN
    output_param := input_param * 2;
END;

To call this procedure from ABAP:

DATA: lv_input  TYPE i VALUE 5,
      lv_output TYPE i.

CALL DATABASE PROCEDURE 'MY_PROCEDURE'
  EXPORTING
    input_param = lv_input
  IMPORTING
    output_param = lv_output.

WRITE: / 'Output:', lv_output.

6. How do you use annotations in CDS views to enhance functionality?

Annotations in CDS views add metadata to control various aspects of the view’s behavior, such as UI elements, data exposure, and performance optimization. Annotations are prefixed with @ and placed above the CDS view elements they modify.

Example:

@AbapCatalog.sqlViewName: 'ZCUSTOMER'
@AccessControl.authorizationCheck: #CHECK
@EndUserText.label: 'Customer Data'
define view ZCustomer as select from kna1
{
    key kunnr as CustomerID,
    name1 as CustomerName,
    ort01 as City,
    land1 as Country
}

In this example, annotations specify the SQL view name, authorization checks, and provide a label for the CDS view.

7. What are the advantages of using ABAP Development Tools (ADT) in Eclipse over traditional SE80?

ABAP Development Tools (ADT) in Eclipse offer several advantages over the traditional SE80 environment:

• Eclipse-based Environment: Provides a modern and user-friendly interface.
• Enhanced Productivity: Features like code completion and real-time syntax checking improve productivity.
• Integration with Other Tools: Seamlessly integrates with other development tools and plugins.
• Improved Debugging and Testing: Offers enhanced debugging and testing capabilities.
• Support for Modern Development Practices: Supports practices like Test-Driven Development and Agile methodologies.
• Better Performance: Optimized for performance, handling large codebases efficiently.

8. How do you handle security and authorization?

Handling security and authorization in ABAP on HANA involves several practices to protect data and operations from unauthorized access.

User authentication is managed through the SAP NetWeaver platform, supporting methods like username/password and SSO. Role-based access control (RBAC) manages user permissions, grouping authorizations into roles assigned to users. Authorization objects define specific permissions required for operations, controlling user actions. Regularly reviewing and auditing user roles and authorizations prevents privilege creep.

9. How would you implement parallel processing?

Parallel processing in ABAP on HANA can be implemented using asynchronous RFC (aRFC) or background jobs. The goal is to split a large task into smaller, independent tasks that can be processed in parallel, reducing execution time.

One approach is to use the CALL FUNCTION statement with the STARTING NEW TASK addition to execute function modules asynchronously.

Example:

DATA: lt_tasks TYPE TABLE OF string,
      lv_task  TYPE string.

" Split the workload into smaller tasks
LOOP AT lt_data INTO lv_data.
  lv_task = 'TASK_' && sy-tabix.
  APPEND lv_task TO lt_tasks.

  CALL FUNCTION 'Z_MY_FUNCTION_MODULE'
    STARTING NEW TASK lv_task
    DESTINATION 'NONE'
    PERFORMING callback ON END OF TASK
    EXPORTING
      iv_data = lv_data.
ENDLOOP.

" Wait for all tasks to complete
LOOP AT lt_tasks INTO lv_task.
  WAIT UNTIL lv_task IS FINISHED.
ENDLOOP.

FORM callback USING taskname.
  " Handle the callback logic here
ENDFORM.

In this example, the workload is divided into smaller tasks, and each task is processed by a separate instance of the function module Z_MY_FUNCTION_MODULE.

10. How do you handle errors in AMDP methods?

Error handling in ABAP Managed Database Procedures (AMDP) methods ensures smooth execution of database operations. In AMDP, errors can be managed using exception classes, allowing you to catch and handle exceptions during database procedure execution.

In AMDP methods, use the RAISE EXCEPTION statement to raise an exception when an error condition is met. You can also use the TRY...CATCH block to catch and handle exceptions.

Example:

CLASS zcl_amdp_example DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    INTERFACES: if_amdp_marker_hdb.
    CLASS-METHODS: get_data
      IMPORTING
        VALUE(iv_param) TYPE string
      RETURNING
        VALUE(rt_data) TYPE TABLE OF string.
ENDCLASS.

CLASS zcl_amdp_example IMPLEMENTATION.

  METHOD get_data BY DATABASE PROCEDURE FOR HDB
    LANGUAGE SQLSCRIPT
    OPTIONS READ-ONLY.

    DECLARE lv_error_message NVARCHAR(100);

    BEGIN
      IF iv_param IS NULL THEN
        lv_error_message := 'Input parameter is null';
        RAISE EXCEPTION TYPE CX_AMDP_ERROR
          EXPORTING
            textid = lv_error_message;
      END IF;
    END;

  END METHOD.

ENDCLASS.

In this example, the RAISE EXCEPTION statement raises an exception if the input parameter iv_param is null.

11. Explain the concept of Core Data Services (CDS) in ABAP.

Core Data Services (CDS) in ABAP on HANA are a framework for defining and consuming semantically rich data models. CDS allows developers to define data models directly in the database using a declarative SQL-based language. These models can then be consumed by ABAP programs, providing a seamless integration between the application and the database layer.

CDS views are defined using the DDL (Data Definition Language) in ABAP Development Tools (ADT). They enable developers to push complex calculations and data processing to the database, leveraging SAP HANA’s in-memory capabilities for optimized performance. CDS views support features such as associations, annotations, and expressions, which enhance the expressiveness and functionality of the data models.

Example:

@AbapCatalog.sqlViewName: 'ZCUSTOMER'
@AbapCatalog.compiler.compareFilter: true
@AccessControl.authorizationCheck: #CHECK
@EndUserText.label: 'Customer Data'
define view Z_Customer as select from kna1
{
    key kunnr,
    name1,
    ort01,
    land1
}

In this example, a CDS view named Z_Customer is defined to select customer data from the KNA1 table. The view includes annotations for SQL view name, authorization check, and end-user text label.

12. What are the key differences between classical ABAP and ABAP on HANA?

The key differences between classical ABAP and ABAP on HANA are primarily centered around performance optimization, data processing capabilities, and the introduction of new features that leverage the in-memory computing power of HANA.

• Performance: ABAP on HANA significantly improves performance by utilizing HANA’s in-memory computing capabilities. This allows for faster data retrieval and processing compared to classical ABAP, which relies on traditional disk-based databases.
• Data Processing: In classical ABAP, data processing is often done at the application server level, which can lead to performance bottlenecks. ABAP on HANA, however, pushes data-intensive operations down to the HANA database layer, enabling more efficient data processing and reducing the load on the application server.
• Code Pushdown: ABAP on HANA introduces the concept of code pushdown, where complex calculations and data manipulations are executed directly in the HANA database using SQLScript or AMDP (ABAP Managed Database Procedures). This reduces the amount of data transferred between the database and the application server, further enhancing performance.
• New Features: ABAP on HANA brings new features such as CDS (Core Data Services) views, which allow for the definition of data models at the database level. CDS views provide a more efficient way to define and consume data models, leveraging HANA’s advanced capabilities.
• Real-time Analytics: With ABAP on HANA, real-time analytics become more feasible due to the high-speed data processing capabilities of the HANA database. This enables businesses to gain insights and make decisions based on up-to-date information.

13. Describe the process of creating and using an OData service.

Creating and using an OData service in ABAP on HANA involves several key steps:

1. Define the Data Model: The first step is to define the data model that the OData service will expose. This is typically done using the ABAP Development Tools (ADT) in Eclipse. You create a Data Definition Language (DDL) source to define the CDS (Core Data Services) views that represent the data model.

2. Create the OData Service: Once the data model is defined, you create the OData service itself. This involves creating a Service Definition and a Service Binding. The Service Definition specifies which CDS views will be exposed, and the Service Binding activates the service and makes it available for consumption.

3. Implement Business Logic: If necessary, you can implement custom business logic by creating ABAP classes and methods. These can be linked to the OData service to handle specific operations, such as data validation or custom processing.

4. Register the Service: After creating the OData service, you need to register it in the SAP Gateway. This is done using the transaction code /IWFND/MAINT_SERVICE. Here, you add the service to the service catalog and assign it to a system alias.

5. Consume the OData Service: Finally, the OData service can be consumed by various clients, such as SAP Fiori applications, external web applications, or mobile apps. The clients make HTTP requests to the OData service to perform CRUD (Create, Read, Update, Delete) operations on the data.

14. How does the use of in-memory computing in HANA impact ABAP application design?

In-memory computing in HANA significantly impacts ABAP application design by shifting the focus from traditional disk-based data storage to leveraging the high-speed data processing capabilities of HANA’s in-memory architecture. This shift necessitates changes in how ABAP applications are designed and optimized.

Key impacts include:

• Data Processing: With HANA, data processing can be pushed down to the database level, reducing the need for data transfer between the application server and the database. This is achieved through the use of advanced SQL and SQLScript, allowing complex calculations and aggregations to be performed directly in the database.
• Code-to-Data Paradigm: The traditional approach of bringing data to the application layer for processing is replaced by the code-to-data paradigm. This means that more logic is executed at the database level, minimizing data movement and improving performance.
• Optimized Data Models: ABAP applications need to be redesigned to take advantage of HANA’s columnar storage and compression techniques. This involves creating optimized data models, such as using Core Data Services (CDS) views, which provide a more efficient way to define and consume data models.
• Real-Time Analytics: HANA’s in-memory capabilities enable real-time analytics and reporting. ABAP applications can be designed to provide instant insights and analytics by leveraging HANA’s real-time data processing capabilities.
• Performance Tuning: Traditional performance tuning techniques may not be sufficient. ABAP developers need to focus on optimizing SQL queries, using appropriate indexes, and leveraging HANA-specific features like partitioning and parallel processing.

15. What are the best practices for ensuring data consistency and integrity?

Ensuring data consistency and integrity in ABAP on HANA involves several best practices:

• Transaction Management: Use proper transaction handling to ensure that a series of operations either complete successfully or have no effect at all. This can be achieved using the COMMIT and ROLLBACK statements to manage transactions effectively.
• Data Validation: Implement data validation both at the application level and the database level. This includes checking data types, ranges, and formats before performing database operations.
• Database Constraints: Utilize database constraints such as primary keys, foreign keys, unique constraints, and check constraints to enforce data integrity rules at the database level.
• Locking Mechanisms: Use appropriate locking mechanisms to prevent concurrent access issues. This includes using SAP’s ENQUEUE and DEQUEUE functions to lock and unlock database entries during critical operations.
• Error Handling: Implement robust error handling to catch and manage exceptions that may occur during database operations. This ensures that any issues are logged and addressed promptly, maintaining data integrity.
• Data Consistency Checks: Regularly perform data consistency checks to identify and rectify any discrepancies in the database. This can be done using custom reports or standard SAP tools.