Conceptual Modeling
Say what the business means, before you say how it is stored
A logical data model answers how information is structured: which entities exist, which attributes they carry, what datatype each one has. That is the right level for generating something, but it is the wrong level for agreeing with the business what you are even talking about.
A conceptual data model answers the earlier question. It names the things the business cares about and how they relate, in the business's own words. Each concept carries a name, a description and the attributes the business uses to talk about it, and that is exactly the level at which an agreement can be reached. How the data is stored is settled later, on the logical model, so a concept is a statement of its own rather than an early draft of a table.
The two are then linked. A logical entity declares which concept it realizes, so you can look at a warehouse table and trace it back to the business idea behind it, or start from a concept and ask which physical structures implement it.
In this tutorial you will build a small conceptual model for BrightGreen Electronics and connect the existing data warehouse model to it.
Released in v1.19.4
Conceptual modeling is officially part of CrossModel as of v1.19.4, conceptual diagrams included. Earlier releases carried parts of it as a preview. See the release notes.
What you will learn
- Creating a conceptual data model and how it differs from a logical one
- Adding conceptual entities, attributes and relationships
- Declaring a dependency so one model can reference another
- Linking logical entities and attributes to the concepts they realize
- Drawing the concepts on a conceptual diagram
Before you start
This tutorial assumes you have completed Datamodeling Fundamentals, or are at least comfortable with the Model Explorer and the form editor.
Clone the BrightGreen workspace as described in Getting the workspace for a tutorial. It already contains the Example DWH logical model, which you will link to your concepts in the last step.
Want to see the finished result?
Clone examples → data-modeling → conceptual into a second workspace to compare your
work against the completed model.
The scenario
BrightGreen's data warehouse has grown organically. There is a Customer entity in the
warehouse, another in the webshop source system, and a third in the finance package. Everyone
agrees they are "customers", and nobody has written down what a customer actually is for
BrightGreen, or how that idea relates to an order.
You have been asked to capture that shared vocabulary as a conceptual model, and to record which warehouse structures realize which concept.
Exercise one: build the conceptual model
1 - Create a conceptual data model
In the Model Explorer, use the New Data Model... button in the toolbar.
In the form that appears, set:
| Field | Value |
|---|---|
| Name | BrightGreen Concepts |
| Type | Conceptual |
Save with ++ctrl+s++.
The Type dropdown is the whole decision. Picking Conceptual tells CrossModel that everything inside this model is a concept, and the application adapts accordingly: the objects you can create, the fields on their forms, and the file extension all follow from it.
Conceptual files use the .ccm extension
A conceptual entity is stored as Customer.entity.ccm; a logical one CrossModel creates
today as Customer.entity.lcm. The extension is what tells CrossModel which tier to read
the file as, which is why you never need a different keyword inside the file itself. The
logical models in the BrightGreen workspace predate the .lcm extension and are still
.entity.cm files; those keep working, and are read as logical.
2 - Add the Customer concept
Right-click your new data model and choose New Element → Entity....
Notice what that submenu offers: Entity..., Relationship... and Diagram... - everything you need to describe what the business means and to draw it. The menu is tailored to the kind of model you are in, so every choice it offers makes sense at the conceptual level.
Name the entity Customer and give it a description such as
"Someone who has bought from BrightGreen, in any channel." Save.
3 - Add attributes in business terms
Expand the Attributes section and press Add Attribute. Add two:
| Name | Description |
|---|---|
Customer Name |
The name the customer is known by |
Contact Details |
How BrightGreen reaches the customer |
The grid has columns for Name, Type and Description: what the business calls the attribute and what it means, which is what you want people to agree on.
The storage details - datatype, length, identifiers - are added on the logical entity that realizes the concept, once those decisions are made. The conceptual model stays readable for the business, and the logical model gets the precision a database needs.
Type means type definition, here as everywhere else
There is a Type column on a conceptual attribute, and it is not a stand-in for the missing datatype. It is the same field a logical entity, a relationship or a data model carries: a reference to an object definition that supplies extra properties and house standards. Leave it empty until you have definitions worth pointing at.
4 - Add the Order concept
Repeat step 2 for a second entity:
| Field | Value |
|---|---|
| Name | Order |
| Description | Something a customer asked BrightGreen to supply |
Give it one attribute, Order Reference.
5 - Relate the two concepts
Right-click the data model again and choose New Element → Relationship....
The form opens with a placeholder name, <Parent> to <Child>, and two collapsible sections,
Parent end and Child end. Each holds three fields: the entity itself, a role, and a
cardinality.
Fill them in like this:
| Section | Field | Value |
|---|---|---|
| Parent end | Parent | Customer |
| Parent end | Parent Cardinality | 1..1 |
| Child end | Child | Order |
| Child end | Child Cardinality | 0..N |
Read together, that says a customer places zero or more orders and an order belongs to
exactly one customer. The Role fields are free text for when the plain entity names do
not carry enough meaning, for example a parent role of places.
Notice what the form does not offer: anywhere to say which attribute joins to which. A logical relationship needs that, because it has to resolve to a real join. Concepts relate as wholes, and the join columns are a logical concern.
You now have a small, complete conceptual model: two concepts and the relationship between them.
Exercise two: connect the logical model to the concepts
A vocabulary nobody references is just a document. The value appears when the warehouse can point at it.
6 - Declare the dependency
Open the Example DWH data model, expand Dependencies, and press Add Dependency.
Choose BrightGreen Concepts and version 1.0.0. Save.
This step is worth understanding rather than just performing.
A model references what is on its dependency list. With BrightGreen Concepts on it, the
Realizes field in the next step offers your concepts; without it, that field has nothing
to offer yet. The same mechanism is why Example DWH's entities can already use
type: dwh-definitions.Formal_entity: that model is in its dependency list too.
The empty-dropdown rule
Any CrossModel dropdown that references another object is populated from what the current model can see: its own contents, plus the contents of the models its own dependency list names. An empty dropdown almost always means a missing dependency rather than a missing feature.
A dependency reaches one step, not further (as of v1.19.4)
Dependencies do not chain. If Example DataMart depends on Example DWH, and Example DWH depends on BrightGreen Concepts, the DataMart still cannot point at a concept: it sees Example DWH and nothing behind it. To reference the concepts from the DataMart, add BrightGreen Concepts to the DataMart's own dependency list. Before v1.19.4 a model could see its dependencies' dependencies as well; that made every edit to a dependency list rebuild far more of the workspace than it needed to, and on a large workspace it made saving one unworkably slow.
7 - Record what the warehouse realizes
Open the Customer entity in Example DWH. Its form now has a Realizes field directly
under Type. Set it to your conceptual Customer.
The dropdown now has something in it, which is the dependency doing its job.
Realizes exists at both levels, so do the same one level down: open the Name attribute and
point it at the Customer Name concept attribute.
Pick the attribute that genuinely corresponds. Id is a surrogate key the warehouse invented
for itself, and it realizes nothing - no concept ever asked for it. Leaving it unlinked is the
correct answer, and a useful one: the attributes with no counterpart are exactly the ones that
exist for technical reasons rather than business ones.
References are qualified by the data model they come from, so what gets written is
BrightGreen_Concepts.Customer for the entity and
BrightGreen_Concepts.Customer.CustomerName for the attribute.
The form and the file spell it differently
The form shows BrightGreen Concepts.Customer and the file stores
BrightGreen_Concepts.Customer. Nothing is wrong: the form displays the model's name
and the file records its id. Which one you see is controlled by the display-label
setting described in
the user interface article.
Note the direction. The link lives on the logical side, pointing up at the concept. That
is deliberate: one concept can be realized by many logical entities, which is exactly
BrightGreen's problem. The webshop Customer, the finance Customer and the warehouse
Customer can all realize the same idea, and "which structures implement this concept" is
then a question you can answer.
If you hand-edit the code editor, field order matters
Everything above is easiest in the form editor, which writes fields in the order the
model expects. If you switch to the Code Editor and add realizes to an attribute by
hand, it has to sit after description and before datatype. Put it further down and
the file fails to parse with Expecting token of type 'DEDENT' but found 'realizes',
which does not hint that position is the problem.
Exercise three: draw the concepts
A conceptual model is the one most often shown to people who do not use CrossModel: the business owner who agreed what a customer is, the analyst who will build on it. Since v1.18.0 it has a diagram of its own, so you can show them a picture rather than a list.
8 - Create a conceptual diagram
Right-click BrightGreen Concepts and choose New Element → Diagram.... Name it
Customers and Orders and press OK.
CrossModel creates Customers_and_Orders.diagram.ccm in the model's diagrams folder and opens
it on an empty canvas. The .ccm extension is the same signal as on the entities: this is a
diagram of the conceptual tier.
9 - Put the concepts on it
Expand the model's entities folder, select Customer, hold ++ctrl++ and select Order, and
drag both onto the canvas together.
Both concepts arrive with their attributes, and the Customer to Order relationship from step 5
is drawn between them with its cardinalities, because both of its ends were part of the same
drop. That is the same behaviour a logical diagram has; see
Putting entities you already have onto a diagram.
10 - What the toolbox offers
Open the toolbox at the top right of the canvas:
It offers Show Entity, Create Entity, Show Relationship, Create Relationship and
Create Note: put concepts you already have on the picture, create new ones, relate them, and
write down what was agreed. As with the New Element menu in step 2, every tool is one that
means something at this level. An entity or relationship you create here is a concept, saved as
a .ccm file in this model.
Starting from the picture
This tutorial writes the concepts first and draws them afterwards. In a workshop with the
business it is often the other way round, and the canvas supports that: choose Create
Entity, click the canvas and type the concept's name; choose Create Relationship and drag
from one concept to the other. Each lands in the model's entities or relationships folder
like the ones you made in forms, so you add the descriptions and attributes afterwards, in the
concept's form.
Add a note with what was agreed - right-click the canvas, choose Create Note, and double-click the note to type - and you have the picture the finished example ships with:
Each conceptual node lists its attributes by name, the business terms from step 3, so the diagram reads the way the business talks. Notes are covered in more detail in Notes on a diagram.
Wrapup
You have built a conceptual model, connected a logical model to it, and drawn it. The vocabulary now lives in the workspace rather than in someone's head, each warehouse structure records which idea it implements, and there is a picture of it for the people who agreed it.
The pieces you used are worth naming, because they recur:
- Type on a data model decides which tier you are working in, and everything else follows from it.
- Dependencies decide what a model can see. Empty reference dropdowns are almost always a missing dependency.
- Realizes links logical to conceptual, at both entity and attribute level, and always from the logical side.
- A conceptual diagram shows the concepts and how they relate, and offers only what makes sense at that level.
Where to go next
- Extending the Metamodel with Type Definitions explains the Type field you left empty, and how a definition can supply properties and derive names.
- Mapping Fundamentals moves from what the data means to how it flows.












