CDS View - Technical Framework - a Brief

Core Data and Services (CDS) in SAP

Core Data and Services (CDS) plays a vital role in the SAP ecosystem, especially within the SAP Cloud Application Programming Model (CAP). It enables the declarative definition of service interfaces, data models, queries, and expressions in a highly structured yet accessible format. This makes it easier for developers to manage data and services while maintaining clear and extendable code structures. This article will guide students through the fundamentals of CDS, exploring its syntax, structure, and practical applications, along with study suggestions to deepen understanding and improve technical skills.

1. What is CDS and Why is It Important?

CDS provides a streamlined way to describe data models, relationships, and services in SAP applications. By using CDS, developers can define complex data relationships and logic in a single, unified language that integrates seamlessly with SAP HANA and SAP Cloud Platform. It is a powerful abstraction tool for building data-intensive applications and simplifies database interactions while making applications more robust and maintainable.

• Declarative Syntax: CDS uses a syntax that allows developers to describe what they want to achieve rather than how it should be achieved. This abstracts low-level coding and reduces errors while speeding up development.
• Integration with SAP HANA: CDS is tightly integrated with SAP HANA, leveraging in-memory capabilities for optimal performance.
• CAP Support: Within CAP, CDS enables developers to declaratively define data models, services, and queries, facilitating streamlined development and deployment.

2. Core Concepts and Components of CDS

To effectively use CDS, it is essential to understand its core components and how they interact within CAP and SAP environments. The most fundamental components include:

• Core Schema Notation (CSN): CSN is an open specification derived from JSON Schema. It defines the format of CDS models as plain JavaScript objects, making it easier to interpret, extend, and process at runtime. This contributes to CDS's flexibility, allowing developers to dynamically create and modify models.
• Service Definitions: CDS allows you to define service interfaces that specify which parts of your data model are exposed to users or external systems. This enables controlled access to data and promotes secure service architectures.
• Data Models: These are the backbone of CDS, defining entities, associations, compositions, and views that represent the core data structure of your application.
• Queries and Expressions: CDS supports declarative queries that allow developers to retrieve and manipulate data, leveraging the full power of SQL in a structured format.
• Annotations: These are metadata elements that add additional information to models and entities, such as security settings, labels, and descriptions. Annotations enhance the functionality and usability of your data models.

Key Entities in CDS

1. Entity: The fundamental building block, similar to a table in a database. It has fields (or columns) and often represents a real-world object, such as a Customer or Product.
2. View: A virtual table defined by a query on one or more entities. It allows you to encapsulate complex queries into reusable components.
3. Association: Defines relationships between entities, allowing data to be linked in a manner similar to foreign keys in relational databases. For example:

   entity Author {    key ID : Integer;    name  : String;  }    entity Book {    key ID   : Integer;    title    : String;    authorId : Integer;    author : Association to Author on authorId = Author.ID;   }  

4. Composition: A stronger form of association used to establish ownership relationships between entities. Compositions allow you to model complex relationships and dependency chains. For example:

   entity Order {    key ID : Integer;    date : Date;  }    entity OrderItem {    key ID       : Integer;    quantity : Integer;    parent   : Association to Order;   }  

3. Working with CDS Models

CDS models are created as plain JavaScript objects following the CSN specification. This format makes CDS extremely versatile, allowing developers to parse, interpret, and dynamically create models at runtime. The models can be compiled into various target languages, making CDS a powerful tool for multi-platform applications.

A simple example of a CDS model:

entity Book {    key ID   : Integer;    title    : String;    author   : String;    publishedYear : Integer;  }  

This CDS model defines a simple entity Book with fields for an ID, title, author, and publication year. The key keyword specifies that ID is the primary key of the entity.

4. Practical Use Cases of CDS in SAP

CDS has a wide range of practical applications across various SAP modules. Here are some typical use cases:

• Data Retrieval and Transformation: CDS simplifies data retrieval by abstracting complex queries into readable models. This is particularly useful for reporting and analytics.
• Business Logic Encapsulation: CDS allows developers to encapsulate business logic in a reusable and declarative format. For example, you can create CDS views that filter and aggregate data according to specific business rules.
• Service Exposure: Through CDS, you can define service interfaces that control which data is exposed to users or external systems, allowing for more secure and manageable service architectures.

5. Syntax and Annotations

CDS syntax is designed to be readable and intuitive, with various annotations available to add metadata to entities and fields. Here are some key elements:

• @OData.publish: Enables entities to be exposed as OData services.
• @title: Provides a label for the field, often used in UI components.
• @readonly: Specifies that a field should be read-only.
• @UI.hidden: Hides a field from the UI.

Example with Annotations:

entity Book {    key ID   : Integer;    title    : String @title : 'Book Title';    author   : String @title : 'Author' @UI.hidden;    publishedYear : Integer @title : 'Year Published' @readonly;  }  

6. Developing with CDS in CAP

CDS is the backbone of CAP, which provides a standardized approach to building applications. In CAP, CDS is used for defining both data models and services, which are automatically translated into REST or OData services.

Study Ideas for Students

To become proficient in CDS, students can follow these steps:

1. Learn the Fundamentals of CDS Syntax: Understand entities, views, associations, and compositions.
   • Exercise: Create a CDS model for a simple business scenario, such as an e-commerce application with entities like Product, Customer, and Order.
2. Explore Core Schema Notation (CSN): Understand how CDS models are stored and interpreted as JavaScript objects.
   • Exercise: Convert a basic CDS model into CSN format and analyze its structure.
3. Implement Annotations and Metadata: Learn to enhance models with metadata for UI and security purposes.
   • Exercise: Annotate an entity with labels, descriptions, and security settings like @Capabilities.authorizationCheck.
4. Practice Data Modeling and Querying: Practice creating complex queries and relationships between entities.
   • Exercise: Create a CDS view to retrieve data from multiple entities, including filtering and aggregation.
5. Integrate CDS with CAP Applications: Understand how CDS integrates with CAP to create services.
   • Exercise: Develop a basic CAP application that exposes CDS models as OData services.
6. Experiment with Service Definitions and Security: Learn how to define service interfaces and manage data exposure.
   • Exercise: Create a secure service interface that limits access to specific fields or entities using annotations.
7. Build and Deploy a Sample Application Using CDS and CAP: Apply all learned concepts in a real-world application.
   • Exercise: Develop a mini-application, such as a bookstore or inventory system, using CDS for data modeling and CAP for deployment.

Final Thoughts

Mastering CDS is essential for anyone working within the SAP ecosystem, particularly in developing SAP Fiori and CAP applications. With its declarative syntax and powerful data modeling capabilities, CDS is a versatile tool that simplifies SAP application development. By following these study ideas, students can build a strong foundation in CDS, preparing them for advanced SAP development roles.