CAST Expressions in ABAP CDS View Entities

As CDS View Entities become more powerful, developers frequently work with calculated fields, CASE expressions, string functions, aggregations, arithmetic operations, RAP projections, and analytical queries. Almost all of these features eventually introduce situations where different data types need to work together.

This is where CAST becomes one of the most important expressions available in ABAP CDS.

Unfortunately, CAST is also one of the most misunderstood concepts. Many developers believe it converts business values such as currencies or units of measure, while others use it simply to remove compiler errors without understanding why those errors occurred in the first place.

In reality, CAST performs a very specific task—it changes the technical data type of an expression during query execution. Understanding this distinction is essential for building clean, maintainable, and production-ready CDS View Entities in SAP S/4HANA Public Cloud.

By the end of this lesson, you will have a complete understanding of how CAST works inside ABAP CDS View Entities and when it should be used in real RAP projects.

Imagine you are building a reporting CDS View that combines data from Sales Orders, Billing Documents, Business Partners, and Financial Accounting.

Some fields contain numbers, some represent business identifiers, while others are amounts, quantities, dates, or character strings. Although many of these values may look similar when displayed on the screen, they are represented internally using completely different data types.

When CDS evaluates expressions, the database engine expects compatible data types. If two operands are incompatible, activation fails with a compiler error before the view can even be executed.

One of the biggest mistakes developers make is assuming that data types are determined by how values look on the screen.

Consider the following examples.

Although all of these values may contain digits, they should never be treated as the same kind of data.

Some values identify business objects, while others represent monetary amounts, quantities, or dates. Each category follows different rules, supports different operations, and requires different handling inside CDS expressions.

CAST is a built-in ABAP CDS expression that converts an expression from one technical data type to another during query execution.

It tells the CDS compiler and SAP HANA database how a particular expression should be interpreted while evaluating the query. CAST does not modify the data stored in the underlying database table—it only changes the data type of the result returned by the expression.

cast( expression as target_type )

The expression can be a database field, a literal value, a calculation, another CDS expression, or the result of a built-in function.

Let's begin with a few simple examples before looking at real-world business scenarios.

cast( Material as abap.char(40) ) as Material

cast( ExchangeRate as abap.decfloat34 ) as ExchangeRate

cast( TaxPercent as abap.dec(5,2) ) as TaxPercentage

In each example, only the technical data type changes. The business meaning of the value remains exactly the same.

Many developers imagine that CAST physically changes the value stored in the database. This is not what happens.

During activation, the CDS compiler validates every expression in the projection list and determines whether the participating operands are compatible. When a CAST expression is encountered, the compiler treats the source expression as the specified target data type before passing the statement to the SAP HANA database.

The original database column is never modified. Only the result of the expression is returned using the requested data type.

The following simplified flow illustrates what happens when a CAST expression is executed.

Database Field
      │
      ▼
CDS Expression
      │
      ▼
CAST Applies Target Data Type
      │
      ▼
Expression Evaluation
      │
      ▼
Result Returned

Notice that the CAST operation happens while the database evaluates the expression. It is not a post-processing step performed after the query has finished.

Developers coming from classical ABAP often compare CAST with moving a value from one variable to another using different data types.

Although the intention is similar, there is an important difference: CDS CAST is part of the SQL expression executed by SAP HANA, whereas ABAP assignments are executed in the ABAP application server after the database has already returned the data.

At first glance, CAST may seem like a feature that is only required in complex CDS Views. In reality, almost every production-grade RAP application eventually uses CAST somewhere in its data model.

As CDS Views become more sophisticated, developers begin combining fields with different technical data types inside calculations, conditional logic, string functions, aggregate expressions, and UNION statements. These operations require compatible data types, and that is precisely where CAST becomes essential.

One of the most common misconceptions among new SAP developers is assuming that a Sales Order is a numeric value simply because it contains only digits.

5000001234

Although it looks like an integer, a Sales Order is not intended for mathematical calculations.

It is a business identifier. Its purpose is to uniquely identify a business document—not to participate in arithmetic expressions.

SalesOrder + 1

Consider another value that often causes confusion.

1000

Again, the value consists entirely of digits, yet Company Code is not an integer.

It represents an organizational unit within SAP and is modeled using the semantic data element BUKRS, whose underlying technical representation is character-based.

Treating these fields as numeric values can introduce incorrect assumptions into your CDS design and often results in unnecessary CAST expressions later in the development process.

Now compare the previous examples with a billing amount.

12500.75 INR

Unlike a Sales Order or Company Code, this value represents a measurable amount of money. It participates in calculations, aggregations, currency conversion, and financial reporting.

Because it represents a measurable quantity, numeric operations make perfect sense.

NetAmount * ExchangeRate

This distinction is extremely important because developers often assume that every value containing digits behaves the same way. Business semantics determine how a field should be treated—not its appearance.

If you remember only one concept from this lesson, make it this one:

This distinction is frequently misunderstood. Many developers assume that CAST performs business conversions such as changing one currency into another or converting kilograms into pounds.

It does not.

CAST simply tells the CDS compiler and SAP HANA how the expression should be interpreted while the SQL statement is being executed.

Consider the following billing document.

Net Amount : 1,000.00
Currency   : USD

A common misconception is that the following expression converts the amount into another currency.

cast(
    NetAmount
    as abap.curr(15,2)
) as NetAmount

This expression does not convert USD into INR.

Business conversions involve calculations based on business rules, exchange rates, or unit conversion tables. These operations are far more complex than simply changing a data type.

Up to this point, we have used built-in data types such as abap.char(), abap.dec(), and abap.int4 as CAST targets. Although these types are perfectly valid, they are not always the best choice.

SAP provides thousands of predefined semantic data elementsthat represent real business concepts such as Company Code, Material, Customer, Supplier, Currency, and Unit of Measure.

Whenever your expression represents one of these business concepts, using the corresponding semantic data element makes your CDS model easier to understand and aligns it with SAP's Virtual Data Model (VDM).

Consider the following two CAST expressions.

cast(
    CompanyCode
    as abap.char(4)
) as CompanyCode

cast(
    CompanyCode
    as BUKRS
) as CompanyCode

Technically, both expressions may produce values with the same length. However, they communicate very different intentions.

The first expression simply states that the result is a four-character field.

The second clearly communicates that the value represents a Company Code, preserving the business semantics of the data.

Developers frequently move between CDS View Entities and ABAP Classes. Although the concepts are similar, the syntax differs significantly.

Understanding both syntaxes is important because RAP development regularly alternates between CDS View Entities and ABAP implementation classes.

Selecting the target type is not simply about making the compiler happy. The chosen type should accurately reflect the business meaning of the resulting value.

In real projects, CAST is rarely used in isolation. It usually appears inside calculations, conditional expressions, reporting views, RAP projections, analytical queries, and OData services.

Let's look at some common scenarios where experienced SAP developers use CAST to create clean and production-ready CDS View Entities.

Every branch of a CASE expression must return compatible data types. If different branches return different types, the CDS compiler cannot determine the final result type.

case
    when OverallSDProcessStatus = 'C'
        then cast( 'Completed' as abap.char(15) )
    when OverallSDProcessStatus = 'B'
        then cast( 'In Process' as abap.char(15) )
    else
        cast( 'Open' as abap.char(15) )
end as StatusText

Explicitly casting each branch makes the result predictable and avoids data type inconsistencies.

String functions expect character-based input. If the source expression is not already compatible, CAST may be required before the function can be evaluated.

upper(
    cast(
        Supplier
        as abap.char(10)
    )
) as SupplierUpper

Here, CAST ensures that the input expression is treated as character data before the UPPER() function is applied.

Both SELECT statements participating in a UNION must expose compatible data types for corresponding columns.

If one side returns a different technical type, CAST can be used to align the structures.

cast(
    CompanyCode
    as BUKRS
) as CompanyCode

This ensures that both branches of the UNION expose identical technical definitions.

CDS View Entities frequently serve as the foundation for RAP services and OData APIs.

The exposed metadata depends on the data types defined in the CDS projection. CAST can therefore influence how client applications interpret the returned values.

Up to this point, we have used CAST in relatively simple expressions. In production CDS Views, however, CAST is frequently combined with arithmetic operations, aggregate functions, CASE expressions, and layered VDM models.

Understanding these advanced scenarios helps you design CDS View Entities that are easier to maintain, easier to extend, and better optimized for SAP HANA.

Arithmetic expressions require compatible numeric data types. Depending on the source fields, CAST may be required before the calculation can be evaluated correctly.

cast(
    NetAmount
    as abap.dec(15,2)
) * ExchangeRate as ConvertedAmount

In this example, CAST ensures that the first operand participates in the multiplication using the required numeric representation.

Aggregate functions such as SUM(), AVG(), MIN(), and MAX() operate on compatible data types.

Depending on the source expression, CAST may be used before applying the aggregate function.

sum(
    cast(
        NetAmount
        as abap.dec(15,2)
    )
) as TotalNetAmount

CAST is often used together with aggregated CDS Views. However, developers should remember that CAST does not remove the normal SQL rules governing GROUP BY and HAVING clauses.

sum(
    cast(
        NetAmount
        as abap.dec(15,2)
    )
) as TotalAmount

One of the most common questions asked by CDS developers is why an alias defined earlier in the projection list cannot be referenced by another expression in the same SELECT statement.

cast(
    NetAmount
    as abap.dec(15,2)
) as Amount,

cast(
    Amount
    as abap.char(20)
) as AmountText

Although this looks perfectly reasonable, CDS activation fails because aliases are not available to other expressions within the same projection list.

Instead of creating long projection lists with complex nested expressions, SAP recommends breaking the logic into multiple CDS layers.

Interface View
        │
        ▼
Composite View
        │
        ▼
Projection View
        │
        ▼
Consumption / RAP Service

The first layer performs calculations and creates reusable aliases. Subsequent layers consume those aliases without repeating complex expressions.

CAST participates in SAP HANA's code pushdown mechanism and is generally inexpensive when used appropriately.

Nevertheless, unnecessary CAST expressions can make a CDS View more difficult to read and may indicate opportunities to simplify the underlying model.

Every SAP developer eventually encounters compiler errors while building CDS View Entities. Most of these errors are not caused by incorrect syntax—they occur because the participating expressions use incompatible data types.

Rather than memorizing individual error messages, it's much more useful to understand why the compiler rejects a particular expression. Once you understand the underlying type system, most CAST-related errors become straightforward to resolve.

div(
    cast(
        NetAmount
        as abap.decfloat34
    ),
    10
)

Function DIV:
Type DECFLOAT34 is not supported.

The DIV() function performs integer division and only supports specific numeric data types. Although DECFLOAT34 is numeric, it is intentionally excluded because DIV is designed for integer-style arithmetic.

mod(
    cast(
        NetAmount
        as abap.dec(15,2)
    ),
    10
)

Function MOD:
Type DEC is not supported.

MOD() calculates the remainder after integer division. Since decimal values can produce fractional remainders, CDS restricts MOD to integer-compatible data types.

Every branch of a CASE expression must return a compatible data type.

case
    when OverallSDProcessStatus = 'C'
         then 'Completed'
    else
         NetAmount
end

In this example, one branch returns character data while the other returns a numeric amount. Since CDS cannot determine a single result type, activation fails.

Not every source type can be converted into every target type.

cast(
    UUID
    as abap.char(20)
)

Depending on the source and target types, CDS may reject the conversion because no valid conversion rule exists.

cast(
    NetAmount
    as abap.dec(15,2)
) as Amount,

cast(
    Amount
    as abap.char(20)
) as AmountText

CDS evaluates every projection expression independently. Therefore, aliases are not available to other expressions within the same projection list.

The following questions are commonly asked in interviews for ABAP Cloud, RAP, S/4HANA Public Cloud, and Senior Technical Consultant roles. They test not only your understanding of CAST syntax but also your ability to make correct architectural decisions.

In the accompanying video, we'll implement every concept covered in this lesson using Eclipse ADT and SAP S/4HANA Public Cloud.

We'll build real CDS View Entities, explore common compiler errors, understand why they occur, and apply CAST correctly in practical RAP development scenarios.

Now that you understand how to work with different data types and use CAST effectively, you're ready to learn one of the most powerful expression constructs available in ABAP CDS: CASE Expressions.

In the next lesson, you'll learn how to implement conditional logic directly in CDS View Entities using both Simple CASE and Searched CASE, create business-friendly calculated fields, combine CASE with CAST, and apply these techniques to real-world reporting and RAP applications.