ATL Transformations

OCL Expressions Deep Dive

Master the Object Constraint Language (OCL) for expressing complex queries and constraints in ATL transformations.

In this tutorial, you’ll explore advanced OCL expressions including navigation, type operations, and sophisticated collection queries.

You’ll learn how to write precise, expressive transformations using OCL’s powerful expression language.

45 mins Estimated Time

Section 1

Navigation and Type Operations

OCL provides operators for navigating model relationships and working with types. Navigation uses . for attributes and -> for collections.

Type operations like oclIsTypeOf, oclIsKindOf, and oclAsType enable runtime type checking and casting.

Step 1

Create a metamodel with inheritance.

This metamodel demonstrates inheritance with Employee subtypes and department relationships.

Organisation.ecore

1<?xml version="1.0" encoding="UTF-8"?>
2<ecore:EPackage xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3    xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" name="Organisation" nsURI="http://www.example.org/organisation" nsPrefix="org">
4  <eClassifiers xsi:type="ecore:EClass" name="Department">
5    <eStructuralFeatures xsi:type="ecore:EAttribute" name="name" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
6    <eStructuralFeatures xsi:type="ecore:EReference" name="employees" upperBound="-1" eType="#//Employee" containment="true"/>
7  </eClassifiers>
8  <eClassifiers xsi:type="ecore:EClass" name="Employee" abstract="true">
9    <eStructuralFeatures xsi:type="ecore:EAttribute" name="name" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
10    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt"/>
11  </eClassifiers>
12  <eClassifiers xsi:type="ecore:EClass" name="Manager" eSuperTypes="#//Employee">
13    <eStructuralFeatures xsi:type="ecore:EAttribute" name="teamSize" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt"/>
14  </eClassifiers>
15  <eClassifiers xsi:type="ecore:EClass" name="Developer" eSuperTypes="#//Employee">
16    <eStructuralFeatures xsi:type="ecore:EAttribute" name="programmingLanguage" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
17  </eClassifiers>
18</ecore:EPackage>

Step 2

Use navigation expressions.

Navigate through relationships using . for single-valued references and -> for collections.

OrganisationTransform.atl

1-- @path Organisation=/Organisation/Organisation.ecore
2-- @path Report=/Report/Report.ecore
3
4module OrganisationTransform;
5create OUT: Report from IN: Organisation;
6
7-- Helper demonstrating navigation
8helper context Organisation!Department def: employeeNames: Sequence(String) =
9    self.employees->collect(e | e.name);
10
11-- Helper navigating to check employee count
12helper context Organisation!Department def: isLarge(): Boolean =
13    self.employees->size() > 10;

Step 3

Apply type checking operations.

Use oclIsTypeOf for exact type matches and oclIsKindOf for subtype matches.

OrganisationTransform.atl

1-- @path Organisation=/Organisation/Organisation.ecore
2-- @path Report=/Report/Report.ecore
3
4module OrganisationTransform;
5create OUT: Report from IN: Organisation;
6
7-- Helper using oclIsTypeOf for exact type match
8helper context Organisation!Employee def: isManager(): Boolean =
9    self.oclIsTypeOf(Organisation!Manager);
10
11-- Helper using oclIsKindOf for subtype match
12helper context Organisation!Employee def: isEmployeeOrSubtype(): Boolean =
13    self.oclIsKindOf(Organisation!Employee);

Step 4

Perform type casting with oclAsType.

Cast elements to specific types to access subtype-specific features.

OrganisationTransform.atl

1-- @path Organisation=/Organisation/Organisation.ecore
2-- @path Report=/Report/Report.ecore
3
4module OrganisationTransform;
5create OUT: Report from IN: Organisation;
6
7-- Helper using oclAsType to access subtype features
8helper context Organisation!Employee def: getManagerTeamSize(): Integer =
9    if self.oclIsTypeOf(Organisation!Manager) then
10        self.oclAsType(Organisation!Manager).teamSize
11    else
12        0
13    endif;

Section 2

Advanced OCL Operations

OCL provides sophisticated operations for strings, numbers, and complex collection queries. Understanding these operations enables precise transformation logic.

Operations include string manipulation, numeric calculations, collection aggregation, and logical operations.

Step 1

Use string operations.

OCL string operations include concat, substring, toUpper, toLower, and size.

OrganisationTransform.atl

1-- @path Organisation=/Organisation/Organisation.ecore
2-- @path Report=/Report/Report.ecore
3
4module OrganisationTransform;
5create OUT: Report from IN: Organisation;
6
7-- Helper with string operations
8helper context Organisation!Employee def: formattedName(): String =
9    'Employee: ' + self.name.toUpper();
10
11-- Helper checking string content
12helper context Organisation!Developer def: isPythonDeveloper(): Boolean =
13    self.programmingLanguage = 'Python';

Step 2

Apply numeric operations and comparisons.

Numeric operations include arithmetic, comparison, and aggregate functions like sum, min, and max.

OrganisationTransform.atl

1-- @path Organisation=/Organisation/Organisation.ecore
2-- @path Report=/Report/Report.ecore
3
4module OrganisationTransform;
5create OUT: Report from IN: Organisation;
6
7-- Helper with numeric operations
8helper context Organisation!Manager def: isLargeTeam(): Boolean =
9    self.teamSize > 5;
10
11-- Helper with aggregate functions
12helper context Organisation!Department def: totalTeamSize(): Integer =
13    self.employees
14        ->select(e | e.oclIsTypeOf(Organisation!Manager))
15        ->collect(e | e.oclAsType(Organisation!Manager).teamSize)
16        ->sum();

Step 3

Combine complex collection operations.

Chain collection operations and use advanced queries like flatten, union, and intersection.

OrganisationTransform.atl

1-- @path Organisation=/Organisation/Organisation.ecore
2-- @path Report=/Report/Report.ecore
3
4module OrganisationTransform;
5create OUT: Report from IN: Organisation;
6
7-- Helper with complex collection operations
8helper context Organisation!Department def: managerNames: Sequence(String) =
9    self.employees
10        ->select(e | e.oclIsTypeOf(Organisation!Manager))
11        ->collect(e | e.name)
12        ->sortedBy(name | name);
13
14-- Helper checking collection properties
15helper context Organisation!Department def: hasSwiftDevelopers(): Boolean =
16    self.employees
17        ->select(e | e.oclIsTypeOf(Organisation!Developer))
18        ->exists(e | e.oclAsType(Organisation!Developer).programmingLanguage = 'Swift');

Step 4

Build a complete transformation with advanced OCL.

The complete transformation demonstrates sophisticated OCL expressions in a practical context.

OrganisationTransform.atl

1-- @path Organisation=/Organisation/Organisation.ecore
2-- @path Report=/Report/Report.ecore
3
4module OrganisationTransform;
5create OUT: Report from IN: Organisation;
6
7-- Helper: format employee information
8helper context Organisation!Employee def: formattedInfo(): String =
9    self.name + ' (ID: ' + self.id.toString() + ')';
10
11-- Helper: get manager-specific information
12helper context Organisation!Employee def: getManagerInfo(): String =
13    if self.oclIsTypeOf(Organisation!Manager) then
14        let mgr : Organisation!Manager = self.oclAsType(Organisation!Manager) in
15        'Manager of ' + mgr.teamSize.toString() + ' people'
16    else
17        'Not a manager'
18    endif;
19
20-- Helper: get developer-specific information
21helper context Organisation!Employee def: getDeveloperInfo(): String =
22    if self.oclIsTypeOf(Organisation!Developer) then
23        let dev : Organisation!Developer = self.oclAsType(Organisation!Developer) in
24        'Develops in ' + dev.programmingLanguage
25    else
26        'Not a developer'
27    endif;
28
29-- Helper: calculate department statistics
30helper context Organisation!Department def: statistics(): String =
31    let total : Integer = self.employees->size() in
32    let managers : Integer = self.employees
33        ->select(e | e.oclIsTypeOf(Organisation!Manager))
34        ->size() in
35    let developers : Integer = self.employees
36        ->select(e | e.oclIsTypeOf(Organisation!Developer))
37        ->size() in
38    'Total: ' + total.toString() + 
39    ', Managers: ' + managers.toString() + 
40    ', Developers: ' + developers.toString();
41
42-- Rule: Transform department to report
43rule DepartmentToReport {
44    from
45        s: Organisation!Department
46    to
47        t: Report!DepartmentReport (
48            name <- s.name,
49            statistics <- s.statistics(),
50            employees <- s.employees
51                ->collect(e | e.formattedInfo() + ' - ' + 
52                    if e.oclIsTypeOf(Organisation!Manager) then
53                        e.getManagerInfo()
54                    else
55                        if e.oclIsTypeOf(Organisation!Developer) then
56                            e.getDeveloperInfo()
57                        else
58                            'Employee'
59                        endif
60                    endif)
61        )
62}

Check Your Understanding

Question 1 of 3

What is the difference between . and -> in OCL navigation?

. is for single values; -> is for collections

Use . to navigate single-valued attributes and references (e.g., employee.department). Use -> to navigate and operate on collections (e.g., department->collect(e | e.name)).

. is faster than ->

Performance isn’t the distinguishing factor. They serve different purposes based on cardinality.

-> can only be used with helpers

-> is used for collection operations anywhere in OCL expressions, not just with helpers.

Question 2 of 3

When should you use oclIsKindOf instead of oclIsTypeOf?

When checking primitive types

Both operations work with class types. The difference is in how they handle inheritance.

When you want to match subtypes as well as exact types

oclIsKindOf returns true for the exact type and all its subtypes, whilst oclIsTypeOf only matches the exact type.

When you need better performance

The choice between these operations is about semantics (subtypes vs exact types), not performance.

Question 3 of 3

Can you use oclAsType without checking the type first?

No, you must always use oclIsTypeOf first

Whilst checking is recommended, oclAsType can be used directly if you’re confident about the type.

Yes, it automatically checks and returns null if wrong type

oclAsType doesn’t provide automatic null handling. Invalid casts cause runtime errors.

Yes, but you risk runtime errors if the type is incorrect

You can use oclAsType directly, but it’s safer to verify the type first using oclIsTypeOf or oclIsKindOf to avoid runtime errors.

Debugging Transformations

Learn techniques for debugging ATL transformations and diagnosing common transformation issues.

Get started