CASE Expressions in ABAP CDS View Entities

Almost every production CDS View contains some form of business logic. Users expect reports to display meaningful descriptions instead of technical codes, classify customers into categories, identify high value sales orders, highlight overdue deliveries, and calculate business statuses.

Implementing these requirements in ABAP after retrieving the data is certainly possible, but it prevents the application from fully benefiting from SAP HANA's code pushdown capabilities.

This is where CASE Expressions become one of the most powerful features available in ABAP CDS.

CASE allows business decisions to be evaluated directly inside the database, enabling RAP applications, Fiori apps, analytical reports, and APIs to return business-ready information without additional ABAP processing.

By the end of this lesson, you'll understand how CASE expressions work, when to use Simple CASE versus Searched CASE, and how experienced SAP developers implement business logic directly inside CDS View Entities.

A CASE expression evaluates one or more conditions and returns a value based on the first matching condition.

Instead of displaying technical values exactly as they are stored in the database, CASE enables CDS View Entities to return meaningful, business-friendly information that can be consumed directly by RAP applications, Fiori apps, analytical reports, and external APIs.

case SalesDocumentType
    when 'OR' then 'Standard Order'
    when 'RE' then 'Return'
    else 'Other'
end as OrderType

Rather than exposing technical document type codes such as OR and RE, the CDS View now returns descriptive values that are immediately understandable to business users.

Developers coming from classical ABAP often compare CDS CASE with the familiar CASE...ENDCASE statement.

Although their syntax appears similar, they solve different problems.

CASE expressions are evaluated sequentially from top to bottom.

As soon as one WHEN condition evaluates to true, CDS immediately returns the corresponding THEN value and stops evaluating the remaining conditions.

case SalesDocumentType
    when 'OR' then 'Order'
    when 'OR' then 'Duplicate'
    else 'Other'
end

If the Sales Document Type is OR, the result will be Order.

The second WHEN condition is never evaluated because the first matching condition terminates the CASE expression.

Technically, the ELSE clause is optional. However, experienced SAP developers almost always include it.

case SalesDocumentType
    when 'OR' then 'Order'
    when 'RE' then 'Return'
end

If none of the WHEN conditions match, the result of the expression is NULL.

ABAP CDS supports two different forms of CASE expressions: Simple CASE and Searched CASE.

Although both return a value, they solve different types of business problems. Understanding when to use each form is one of the most frequently discussed topics during ABAP Cloud and RAP interviews.

Simple CASE evaluates a single expression and compares it against multiple possible values.

case SalesDocumentType
    when 'OR' then 'Standard Order'
    when 'RE' then 'Return Order'
    when 'CR' then 'Credit Memo'
    else 'Other'
end as OrderType

In this example, every WHEN compares the value of SalesDocumentType.

Conceptually, CDS evaluates something similar to:

SalesDocumentType = 'OR'
SalesDocumentType = 'RE'
SalesDocumentType = 'CR'

Searched CASE does not compare a single expression.

Instead, each WHEN contains its own logical condition, making it much more flexible than Simple CASE.

case
    when TotalNetAmount >= 10000 then 'High'
    when TotalNetAmount >= 5000 then 'Medium'
    else 'Low'
end as SalesCategory

Every WHEN clause is evaluated independently until the first condition returns true.

CASE expressions are evaluated sequentially from top to bottom.

Once a condition matches, evaluation stops immediately.

case
    when TotalNetAmount > 0 then 'Positive'
    when TotalNetAmount > 1000 then 'Large'
    else 'Zero'
end

Suppose:

TotalNetAmount = 2000

Many developers expect the result to be Large.

The actual result is:

Positive

The first condition already matches, so the remaining WHEN clauses are never evaluated.

case
    when TotalNetAmount > 1000 then 'Large'
    when TotalNetAmount > 0 then 'Positive'
    else 'Zero'
end

Many developers believe CASE is only useful for returning descriptive text.

In reality, CASE can return any compatible expression, including numbers, dates, fields, arithmetic expressions, and function results.

case Currency
    when 'USD' then 1
    when 'EUR' then 2
    else 0
end as CurrencyPriority

case SalesOrganization
    when '1710' then SalesDocument
    else SoldToParty
end as BusinessReference

Every THEN and ELSE branch should return compatible data types.

This allows the CDS compiler to determine the final type of the projected field.

case
    when NetAmount > 1000 then 'High'
    else 'Low'
end

case
    when NetAmount > 1000 then 'High'
    else 100
end

In the second example, one branch returns character data while the other returns a numeric value. Depending on the involved data types, CDS may reject the expression or perform implicit conversions that make the code harder to understand.

In production SAP systems, CASE expressions are rarely used to return simple text values. They are commonly used to classify business data, implement reporting logic, derive statuses, calculate categories, and expose business-friendly information to Fiori applications.

Let's look at some practical scenarios that you'll encounter while developing RAP applications and CDS View Entities.

Businesses often classify customers based on their purchasing value. Since these rules are evaluated for every record, implementing them directly in CDS improves performance and keeps the business logic centralized.

case
    when TotalNetAmount >= 100000 then 'Premium'
    when TotalNetAmount >= 50000 then 'Gold'
    when TotalNetAmount >= 10000 then 'Silver'
    else 'Standard'
end as CustomerCategory

Many SAP Fiori applications display records using traffic light indicators to help users identify critical situations at a glance.

case
    when DeliveryDelayDays > 10 then 'Red'
    when DeliveryDelayDays > 5 then 'Yellow'
    else 'Green'
end as TrafficLight

The UI simply consumes the calculated field and displays the appropriate icon or color.

The THEN expression is not limited to literal values. It can also return calculations.

case TransactionCurrency
    when 'USD' then NetAmount * 83
    when 'EUR' then NetAmount * 95
    else NetAmount
end as EstimatedAmount

Every branch performs a different calculation depending on the business condition.

CASE can return entire fields instead of literals.

case SalesOrganization
    when '1710' then SalesDocument
    else SoldToParty
end as BusinessReference

This allows the projected value to depend dynamically on business conditions while keeping the CDS View simple and readable.

CASE and CAST are frequently used together to ensure every branch returns a compatible data type.

case
    when NetAmount >= 10000
        then cast( 'High' as abap.char(10) )
    when NetAmount >= 5000
        then cast( 'Medium' as abap.char(10) )
    else
        cast( 'Low' as abap.char(10) )
end as SalesCategory

Explicit CAST expressions remove ambiguity and clearly define the resulting data type of the CASE expression.

CASE expressions can be nested, allowing one CASE to return another CASE expression.

case SalesDocumentType
    when 'OR'
        then case TransactionCurrency
                 when 'USD' then 'US Order'
                 else 'Domestic Order'
             end
    else 'Other'
end as OrderCategory

Nested CASE is supported, but excessive nesting can reduce readability.

CASE expressions are straightforward to write, but small mistakes can lead to incorrect business results, activation errors, or unexpected NULL values. Understanding these common pitfalls will help you build more reliable CDS View Entities.

CASE expressions are executed directly in SAP HANA as part of the SQL statement. This allows business rules to benefit from code pushdown and reduces the need for post-processing in ABAP.

Follow the complete implementation in Eclipse ADT as we build practical CDS View Entities using both Simple CASE and Searched CASE, discuss common activation errors, and implement real business scenarios used in SAP S/4HANA Public Cloud projects.