Defining Domain Models

Core Data Services (CDS) are a fundamental concept in CAP. They provide the means to declaratively capture data models as well as service models.

Watch the video to understand the model-based approach.

In this lesson we will focus on domain models. Service models will be covered in the next lesson.

CDS models are represented in Core Schema Notation (CSN). CSN (pronounced like "season") is similar to JSON Schema, but goes beyond the capabilities of JSON to capture full-blown entity-relationship models and extensions.

Watch the video to get an overview of the source and target formats of the CDS models.

In this learning, we will define models in .cds files.

As mentioned earlier, let's now look at how to create domain models using CDL. To do this, we create a file with the extension .cds in the db folder of the CAP project. The name of the file is arbitrary, a common file name is for example schema.cds.

First, we specify a single domain entity called Authors in the file (see figure A Simple Domain Entity).

Domain entities are structured types with named and typed elements representing data sets that can be read and manipulated using usual CRUD operations. When translated into persistence models, entities become tables.

To type the elements, CDS comes with a small set of built-in types. A list of the built-in types can be found in the CDS documentation.

The syntax entity Authors used in the figure is equivalent to define entity Authors. This means that the keyword define is optional.

Use the keyword key to specify one or more elements that form the primary key of an entity.

You can define namespaces that are automatically applied to all relevant names in a file. In the example shown, the entity name Authors is prefixed with the namespace com.sap.learning, resulting in com.sap.learning.Authors as the full entity name. Namespaces are just prefixes - there is nothing special about them beyond that. Namespaces are optional - use them if your models could be reused in other projects; otherwise you can do without them.

In figure Example of a Simple Type, a simple type called NoOfBooks is defined. It is based on the built-in data type Integer. This means that wherever NoOfBooks is used, it essentially represents an Integer value.

The Books entity shown has a stock element that is typed with the NoOfBooks type. This means that the data type of this element is essentially Integer.

The definition

1
type NoOfBooks : Integer;

1
define type NoOfBooks : Integer;

Structured types are custom data types that combine one or more related elements under a single type. They make it possible to create complex data structures and use them within entities.

The Books entity shown in figure Example of a Structured Type has a price element of type Price, which is a separately defined structured type.

The Price type has two elements: amount of built-in type Decimal and currency of built-in type String with a maximum length of 3 characters.

Enumerations (or enums for short) can be used to make code more readable and self-explanatory, as they allow you to replace cryptic values with symbols in the application logic.

You can specify enumeration values for a type as a semicolon-separated list of symbols with assigned corresponding values. For string types, the assignment of actual values is optional; if omitted, the actual values are the string counterparts of the symbols.

The Books entity in figure Example of Enums has an element called genre of type Genre, which is a custom type with enumeration values.

The Genre type is based on the built-in Integer type, which means that each symbol in the enumeration corresponds to an Integer value.

The Genre enumeration contains two symbols: fiction, which corresponds to Integer value 1, and non_fiction, which corresponds to Integer value 2.

When you execute cds watch in the terminal to start a server, your domain model, which is defined in the project's db folder, is automatically translated into a persistence model and deployed to the configured database. This means that corresponding SQL DDL statements are generated and executed on the basis of your CDS model.

You can also generate these SQL DDL statements manually using the following command in the terminal:

1
cds compile <models> [<options>]

1
cds compile ?

To generate an SQL DDL script for a domain model contained in a file named schema.cds in the db folder of the CAP project, execute this command in the root directory of the project:

1
cds compile db/schema.cds --to sql

The SQL DDL script in figure Compiled CDS Model was generated in this way.

Watch the video to understand the rules that apply to the generated SQL DDL output.

Later we will see that projected entities are generated as views. We will also see that foreign key fields are automatically created in generated database tables to reflect certain associations that can be defined between entities.

Watch the video to see how to capture a domain model.