SAP technical topicObjectAnalytical CDS viewsModuleRAP_CDS_ODATA

Analytical CDS Views for Cubes and Dimensions

An analytical CDS view is a CDS view entity annotated with the data category cube or dimension, marking it as a source for aggregated reporting rather than transactional data access. Cube views expose measures with default aggregation behaviour; dimension views expose master data attributes with text and hierarchy associations. They power Fiori analytical apps, smart business tiles and embedded analytics, consumed through OData services that support server-side aggregation.

This page covers analytical CDS views, the cube and dimension annotated layer of the CDS virtual data model used for embedded analytics and Fiori analytical apps. It explains the structural gap between how the view reads at design time and how aggregation actually happens at runtime, and where this approach fits against BW queries and HANA calculation views.

Published 16 Sept 2026· 1,534 words

What it is

An analytical CDS view is an ordinary CDS view entity that carries the annotation marking it as a cube or a dimension, borrowing terminology from BW modeling without being a BW object. A cube view exposes measures, numeric fields flagged with a default aggregation behaviour such as sum or count, alongside characteristics used to slice those measures. A dimension view exposes descriptive attributes for a business entity, typically with an association to a text view and sometimes a hierarchy. The one fact that causes most confusion: the view's own SQL statement is usually unaggregated, row-level data. Grouping and summing do not happen inside the CDS SELECT; they happen when a consumer, most often an OData service using an aggregation transformation, issues a request that groups by certain fields. Open the view in the ABAP Development Tools data preview and it looks like plain detail rows. The aggregation only appears once the analytical consumption path is exercised.

When to use it

Reach for an analytical CDS view when the requirement is a KPI tile, an analytical list page, an overview page card, or any Fiori app that needs totals, counts or averages sliced by dimensions such as sales organization, material group or period, especially over large transactional tables. It is also the right layer when embedded analytics tools need a multidimensional source without staging data into BW. It is the wrong tool for a transactional list report that just needs filtered detail rows with no aggregation; a plain CDS view entity or a basic or composite interface view is lighter and easier to debug. It is also the wrong tool when the volumes are small enough that a transactional app can compute the number client-side, or when the business logic genuinely needs BW's time-dependent hierarchies, currency translation types and multi-provider blending, in which case a real BW query is a better fit than force-fitting a cube annotation onto a CDS view.

How it fits the stack

Below the analytical CDS view sit the basis tables or a table function providing the detail data, plus dimension views supplying master data and text. Above it sits an OData service, usually OData V4 with analytics support, exposed through a service definition and binding, which is what Fiori elements analytical list pages, overview page cards and smart business KPI tiles actually query. Analysis for Office and other embedded analytics clients can also reach the same cube through the InfoAccess protocol without a custom OData layer. In terms of what it supersedes: it is the S/4HANA-era replacement for hand-built HANA native analytic and attribute views, and for many custom ABAP reports that used to aggregate in a loop. It does not replace BW query modeling for genuinely multidimensional, hierarchy-heavy reporting; the two coexist, with analytical CDS views handling the lighter, embedded, near-real-time cases.

A worked example

A sales overview KPI tile needs net order value and open quantity by sales organization and material group, refreshed against live order data. The cube view selects from the sales order item detail source, exposes net value and quantity as measures with default aggregation set to sum, exposes sales organization and material group as characteristics, and carries associations to a customer dimension view and a material dimension view, each of which in turn associates to a text view for the description in the logged-on language. Currency handling uses the amount annotation referencing the transaction currency field so downstream consumers know which field carries the unit. The cube view is exposed through a service definition as an OData V4 analytical service. The Fiori overview page card is configured against that service using an aggregation transformation requesting a group-by on sales organization with a sum of net value. Nothing in the cube view's own SQL groups anything; the grouping request comes from the OData call the card issues at runtime, and the database performs the aggregation when that call is processed.

How to choose

  • Volume and refresh need: if the source table is small and can be aggregated client-side or by a simple transactional CDS view without a performance problem, a cube annotation adds ceremony without benefit; reserve it for datasets where pushing aggregation to the database materially matters.
  • Consumer type: if the only consumer will ever be a transactional list report, do not annotate the view as a cube just because it happens to sum a number in one screen; the annotation is a contract that other analytical tooling will discover and rely on.
  • Hierarchy and currency translation depth: if the requirement needs time-dependent hierarchies or multiple currency translation types applied at query time, ask whether a BW query is the better home before trying to replicate that logic inside dimension view associations.
  • Fan-out risk: before associating one cube view to another cube view, check whether the join multiplies rows; cube-to-cube associations for drilldown are a common source of double-counted measures and are usually better modeled as separate queries joined at the consumption layer, not inside the view itself.
  • Ownership of the KPI definition: confirm whether the business owner expects this number to match a BW query or a financial report elsewhere; if so, the aggregation logic, currency handling and exception aggregation behaviour need to be agreed with that owner before the view is built, not reconciled afterward.

Common pitfalls

  • Assuming the CDS view itself aggregates: the data preview shows detail rows and developers sometimes add a manual GROUP BY inside the view's SQL to force it, which breaks the analytical annotation's expected behaviour and produces incorrect totals once a real aggregation transformation is layered on top.
  • Currency and unit mixing: a measure summed across rows with different currencies or units without a conversion step produces a number that looks plausible and is wrong; this rarely surfaces in development data with a single currency and appears only in production.
  • Double counting through associations: joining a cube view to another cube view, or to a dimension view with a one-to-many cardinality that was assumed to be one-to-one, multiplies the measure rows before aggregation and inflates totals silently.
  • Missing or wrong default aggregation behaviour on a measure: a field intended as a measure but left without the annotation, or annotated with the wrong aggregation type such as average where sum was intended, produces numbers that pass a quick sanity check but fail reconciliation against the general ledger or another report.
  • Performance at scale: a cube view with several nested associations into other views performs fine against test data and degrades sharply once real transaction volumes and multiple concurrent KPI tile refreshes hit it; this needs to be checked with production-representative volumes, not development client data.
  • Treating a dimension view as transactional: pulling live operational detail through a dimension view association, rather than through the cube's own measures, produces inconsistent snapshots when the dimension data and the fact data are read at slightly different points in time.

ECC, S/4HANA and clean core

Analytical CDS views are the standard, supported way to build custom embedded analytics content on S/4HANA and sit comfortably within a clean core approach when built as extensions on top of released CDS view entities rather than by modifying standard cube or dimension views directly. Reworking a standard SAP-delivered analytical view in place is discouraged; the clean core path is to build a new custom cube view that consumes released extension points or released views, and to expose it through its own service definition. Where compatibility views exist to bridge older query-based reporting objects, they are a migration aid, not a long-term modeling target for new development.

Whose problem this is

Development ownership sits with the ABAP or CDS developer who models the cube and dimension views and their measures. Functional ownership sits with whoever defines the KPI logic, currency handling and expected aggregation behaviour, typically an FI, SD or controlling functional consultant. Handover should include the annotated view source, the service definition it is exposed through, and a written statement of what each measure's aggregation and currency conversion is supposed to do, so a later reviewer does not have to reverse-engineer it from the annotations alone.

Related SAP objects

Reviewed pages this object connects to in the ERPClimb knowledge graph.

Source: ERPClimb — https://erpclimb.com/sap-technical-topics/analytical-cds-viewsERPClimb is an independent platform and is not affiliated with SAP SE. Reference pages are written and reviewed by SAP consultants for learning and troubleshooting.