Skip to main content

Data Model Objects


Database as Objects

The ORDA technology is based upon an automatic mapping of an underlying relational database structure to a data model (this concept can be viewed as an included and enhanced ORM), along with powerful features such as calculated attributes or dataclass functions. It also provides access to data through entity and entity selection objects.

As a result, ORDA exposes the whole database as a set of data model objects, including model objects as well as data objects.


Objects have Classes

With ORDA, you can declare and use high-level user class functions above the data model. This allows you to write business-oriented code and "publish" it just like an API. Datastore, dataclasses, entity selections, and entities are all available as class objects that can contain functions.

For example, you could create a getNextWithHigherSalary() function in the EmployeeEntity class to return employees with a salary higher than the selected one. It would be as simple as calling:


Thanks to this feature, the entire business logic of your Qodly application can be stored as a independent layer so that it can be easily maintained and reused with a high level of security:

  • You can "hide" the overall complexity of the underlying physical structure and only expose understandable and ready-to-use functions.
  • If the physical structure evolves, you can simply adapt function code and client applications will continue to call them transparently.
  • By default, all of your data model class functions (including calculated attribute functions) are not exposed to remote calls. You must explicitly declare each public function with the exposed keyword.

Class Architecture

ORDA provides generic classes exposed through a 4D class store, as well as specific user classes (extending generic classes) exposed in the cs class store:

All ORDA data model classes are exposed as properties of the cs class store. The following ORDA classes are available:

ClassExample nameInstantiated by
cs.DataStorecs.DataStoreds command
cs.DataClassNamecs.EmployeedataStore.DataClassName, dataStore["DataClassName"]
cs.DataClassNameEntitycs.EmployeeEntitydataClass.get(),, entitySelection.first(), entitySelection.last(), entity.previous(),, entity.first(), entity.last(), entity.clone()
cs.DataClassNameSelectioncs.EmployeeSelectiondataClass.query(), entitySelection.query(), dataClass.all(), dataClass.fromCollection(), dataClass.newSelection(), entitySelection.drop(), entity.getSelection(), entitySelection.and(), entitySelection.minus(), entitySelection.or(), entitySelection.orderBy(), entitySelection.orderByFormula(), entitySelection.slice()

Also, object instances from ORDA data model user classes benefit from their parent's properties and functions:

Creating Data Model Classes

In Qodly Studio, you can create all the classes related to a dataclass by clicking on a single button:

  1. Open the Model Editor and select the dataclass for which you want to create classes.
  2. Click on the <...> button at the top right side of the panel.

All classes are automatically created and can be displayed in the Classes section of the Explorer:


The datastore is the interface object to a database. It builds a representation of the whole database as object. A datastore is made of a model and data:

  • The model contains and describes all the dataclasses that make up the datastore. It is independant from the underlying database itself.
  • Data refers to the information that is going to be used and stored in this model. For example, names, addresses, and birthdates of employees are pieces of data that you can work with in a datastore.

When handled through the code, the datastore is an object named DataStore, returned by the ds command, whose properties are all of the dataclasses which have been specifically exposed.

The DataStore object itself cannot be copied as an object:

mydatastore=objectCopy(ds) //returns null

The datastore properties are however enumerable:

 var names : collection
//names contains the names of all the dataclasses

DataStoreImplementation Class

A database exposes its own DataStoreImplementation class, named DataStore, in the cs class store.

  • Extends: 4D.DataStoreImplementation
  • Class name in cs class store: DataStore

You create functions in the DataStore class that will be available through the ds object, from any context of the application.


// DataStore class

extends DataStoreImplementation

exposed function getDesc
return "Database exposing employees and their companies"

This function can then be called:

desc=ds.getDesc() //"Database exposing..."


A dataclass is the equivalent of a database table. It is used as an object model and references all fields as attributes, including relational attributes (attributes built upon relations between dataclasses) as well as calculated and alias attributes. Relational, computed and alias attributes can be used in queries like any other attribute.

All dataclasses in a Qodly project are available as a property of the ds datastore. The Expose as REST resource option must be selected at the model level for each dataclass that you want to be called from the Web.

For example, consider the following database table:

The Company dataclass is available in the ds datastore. You can write:

var compClass : cs.Company //declares a compClass object variable of the Company class
compClass=ds.Company //assigns the Company dataclass reference to compClass

The dataclass offers an abstraction of the physical database and allows handling a conceptual data model with specific features such as computed attributes or alias attributes.

A dataclass object can contain:

  • storage attributes
  • relation attributes
  • computed attributes
  • alias attributes
  • functions

The dataclass is the only means to query the datastore. A query is done from a single dataclass. Queries are built around attributes and relation attribute names of the dataclasses. So the relation attributes are the means to involve several linked dataclasses in a query.

The dataclass object itself cannot be copied as an object:

mydataclass=objectCopy(ds.Employee) //returns null

The dataclass properties are however enumerable:

 var names : collection
//names contains the names of all the dataclass attributes

DataClass Class

Each dataclass offers a DataClass class in the cs class store.

  • Extends: 4D.DataClass
  • Class name in cs class store: DataClassName
  • Example name: Employee

Example 1

// Company class

extends DataClass

// Returns companies whose revenue is over the average
// Returns an entity selection related to the Company DataClass

function getBestOnes() : cs.CompanySelection
sel=this.query("revenues >= :1",this.all().average("revenues"))
return sel

Then you can get an entity selection of the "best" companies by executing:

    var best : cs.CompanySelection

Calculated attributes are defined in the Entity Class.

Example 2

Considering the following model (partial view):

Zipcodes are used as primary keys of the ZipCode table. The many-to-one relation attribute between cityID and ID is named city.

The City Class provides an API:

// City class

extends DataClass

exposed function getCityName(zipcode : integer) -> result : string
var zip : cs.ZipCodeEntity


if (zip!=null)

The application can use the API to get the city matching a zip code:



An entity is the equivalent of a record. It is actually an object that references a record in the database. It can be seen as an instance of a dataclass, like a record of the table matching the dataclass.

However, an entity also contains data correlated to the datastore. The purpose of the entity is to manage data (create, read, update, delete). When an entity reference is obtained by means of an entity selection, it also retains information about the entity selection which allows iteration through the selection.

For example, to create an entity:

 var status : object
var employee : cs.EmployeeEntity //declares a variable of the EmployeeEntity class type

The entity object itself cannot be copied as an object:

 myentity=objectCopy(ds.Employee.get(1)) //returns null

The entity properties are however enumerable:

 var names : collection
//names contains the names of all the entity attributes

Entity Class

Each dataclass offers an Entity class in the cs class store.

  • Extends: 4D.Entity
  • Class name in cs class store: DataClassNameEntity
  • Example name: CityEntity

Calculated attributes

Entity classes allow you to define calculated attributes using specific keywords:

  • function get attributeName
  • function set attributeName
  • function query attributeName
  • function orderBy attributeName

For more information, please refer to the Calculated attributes section below.


// cs.CityEntity class

extends Entity

function getPopulation() -> result : integer

function isBigCity() -> result : boolean
// The getPopulation() function is usable inside the class

Then you can call this code:

var city : cs.CityEntity
var message : string


if (city.isBigCity()) + " is a big city"

Entity selection

An entity selection is an object containing one or more reference(s) to entities belonging to the same dataclass. It is usually created as a result of a query or returned from a relation attribute. An entity selection can contain 0, 1 or X entities from the dataclass -- where X can represent the total number of entities contained in the dataclass.


var e : cs.EmployeeSelection //declares a e object variable of the EmployeeSelection class type
e=ds.Employee.all() //assigns the resulting entity selection reference to the e variable

The entity selection object itself cannot be copied as an object:

 myentitysel=objectCopy(ds.Employee.all()) //returns null

The entity selection properties are however enumerable:

 var names : collection
//names contains the names of the entity selection properties
//("length", "00", "01"...)

EntitySelection Class

Each dataclass offers an EntitySelection class in the cs class store.

  • Extends: 4D.EntitySelection
  • Class name in cs class store: DataClassNameSelection
  • Example name: EmployeeSelection


// EmployeeSelection class

extends EntitySelection

//Extract the employees with a salary greater than the average from this entity selection

function withSalaryGreaterThanAverage() -> result : cs.EmployeeSelection
result=this.query("salary > :1",this.average("salary")).orderBy("salary")

Then you can get employees with a salary greater than the average in any entity selection by executing:


Ordered or unordered entity selection

For optimization reasons, by default ORDA usually creates unordered entity selections, except when you call the orderBy() function or use specific options. In this documentation, unless specified, "entity selection" usually refers to an "unordered entity selection".

Ordered entity selections are created only when necessary or when specifically requested using options, i.e. in the following cases:

  • result of an orderBy() on a selection (of any type)
  • result of an orderByFormula() on a selection (of any type)
  • result of the newSelection() function with the dk keep ordered option

Ordered entity selections support duplicated entity references. On the other hand, when an ordered entity selection becomes an unordered entity selection, any repeated entity references are removed.

Unordered entity selections are created in all other cases, including:

  • result of a query() on a selection (of any type) or a query() on a dataclass,
  • result of a all(), fromCollection(), or newSelection() (without option) function on a dataclass,
  • result of various functions from the entity selection class, whatever the input selection types: or(), and(), add(), copy(), extract(), slice(), drop()...
  • result of a relation such as empSel=company.employees, or a projection such as,
  • result of an entity.getSelection() function.


There is no specific class for attribute objects. Basically, dataclass properties are attribute objects describing the underlying fields or relations. For example:

 var nameAttribute, revenuesAttribute : object //reference to class attribute
revenuesAttribute=ds.Company["revenues"] //alternate way to reference

This code assigns to nameAttribute and revenuesAttribute references to the name and revenues attributes of the Company dataclass. This syntax does NOT return values held inside of the attribute, but instead returns objects describing the attributes themselves, that you can handle by calling the dataclass attribute name. To handle values, you need to go through Entities.

The Expose as REST resource option must be selected at the model level for each attribute that you want to be called from the Web (by default this option is inherited from the dataclass level).

Dataclass attributes come in several kinds: storage, relatedEntity, relatedEntities, computed (aka calculated), or alias. Attributes that are scalar (i.e., provide only a single value) support all the standard data types (integer, text, object, etc.).

Storage and Relation attributes

  • A storage attribute is equivalent to a field in a database and can be indexed. Values assigned to a storage attribute are stored as part of the entity when it is saved. When a storage attribute is accessed, its value comes directly from the datastore. Storage attributes are the most basic building block of an entity and are defined by name and data type.
  • A relation attribute provides access to other entities. Relation attributes can result in either a single entity (or no entity) or an entity selection (0 to N entities). Relation attributes are built upon "classic" relations in the relational structure to provide direct access to related entity or related entities. Relation attributes are directy available in ORDA using their names.

For example, consider the following partial model and the relation properties:

All storage attributes will be automatically available:

  • in the Project dataclass: "ID", "name", and "companyID"
  • in the Company dataclass: "ID", "name", and "discount"

In addition, the following relation attributes will also be automatically available:

  • in the Project dataclass: theClient attribute, of the "relatedEntity" kind; there is at most one Company for each Project (the client)
  • in the Company dataclass: companyProjects attribute, of the "relatedEntities" kind; for each Company there is any number of related Projects.

All dataclass attributes are exposed as properties of the dataclass:

    // Company available attributes
ds.Company.companyProjects //relatedEntities

//Project available attributes
ds.Project.theClient //relatedEntity

Keep in mind that these objects describe attributes, but do not give access to data. Reading or writing data is done through entity objects.

Alias attributes

An alias attribute is built above another attribute of the data model, named target attribute. The target attribute can belong to a related dataclass (available through any number of relation levels) or to the same dataclass. An alias attribute stores no data, but the path to its target attribute. You can define as many alias attributes as you want in a dataclass.

Calculated attributes

Calculated attributes are declared using a get <attributeName> function in the Entity class definition. Their value is not stored but evaluated each time they are accessed. They do not belong to the underlying database structure, but are usually built upon it and can be used as any attribute of the data model.


ORDA calculated attributes are not exposed by default. You expose a calculated attribute by adding the exposed keyword to the get function definition.

function get <attributeName>


{exposed} function get <attributeName>({event : object}) -> result : type
// code

The getter function is mandatory to declare the attributeName calculated attribute. Whenever the attributeName is accessed, the function get code is evaluated and the result value is returned.

A calculated attribute can use the value of other calculated attribute(s). Recursive calls generate errors.

The getter function defines the data type of the calculated attribute thanks to the result parameter. The following resulting types are allowed:

  • Scalar (string, boolean, date, time, number)
  • object
  • Image
  • BLOB
  • Entity (i.e. cs.EmployeeEntity)
  • Entity selection (i.e. cs.EmployeeSelection)

The event parameter contains the following properties:

attributeNamestringCalculated attribute name
dataClassNamestringDataclass name
resultvariantOptional. Add this property with null value if you want a scalar attribute to return null


  • fullName calculated attribute:
function get fullName(event : object)-> fullName : string

: (this.firstName==null) & (this.lastName==null)
event.result=null //use result to return null
: (this.firstName==null)
: (this.lastName==null)
fullName=this.firstName+" "+this.lastName
  • A calculated attribute can be based upon an entity related attribute:
function get bigBoss(event : object)-> result: cs.EmployeeEntity

  • A calculated attribute can be based upon an entity selection related attribute:
function get coWorkers(event : object)-> result: cs.EmployeeSelection
if (this.manager==null)

function set <attributeName>


function set <attributeName>(value : type {, event : object})
// code

The setter function executes whenever a value is assigned to the attribute. this function usually processes the input value(s) and the result is dispatched between one or more other attributes.

The value parameter receives the value assigned to the attribute.

The event parameter contains the following properties:

attributeNamestringCalculated attribute name
dataClassNamestringDataclass name
valuevariantValue to be handled by the calculated attribute


function set fullName(value : string , event : object)
var p : integer
p=position(" ",value)
this.firstname=substring(value, 1, p-1) // "" if p<0
this.lastname=substring(value, p+1)

function query <attributeName>


function query <attributeName>(event : object)
function query <attributeName>(event : object) -> result : string
function query <attributeName>(event : object) -> result : object
// code

This function supports three syntaxes:

  • With the first syntax, you handle the whole query through the event.result object property.

  • With the second and third syntaxes, the function returns a value in result:

    • If result is a string, it must be a valid query string
    • If result is an object, it must contain two properties:
    result.querystringValid query string with placeholders (:1, :2, etc.)
    result.parameterscollectionvalues for placeholders

The query function executes whenever a query using the calculated attribute is launched. It is useful to customize and optimize queries by relying on indexed attributes. When the query function is not implemented for a calculated attribute, the search is always sequential (based upon the evaluation of all values using the get <AttributeName> function).


The following features are not supported:

  • calling a query function on calculated attributes of type Entity or Entity selection,
  • using the order by keyword in the resulting query string.

The event parameter contains the following properties:

attributeNamestringCalculated attribute name
dataClassNamestringDataclass name
valuevariantValue to be handled by the calculated attribute
operatorstringQuery operator (see also the query class function). Possible values:
  • == (equal to, @ is wildcard)
  • === (equal to, @ is not wildcard)
  • != (not equal to, @ is wildcard)
  • !== (not equal to, @ is not wildcard)
  • < (less than)
  • <= (less than or equal to)
  • > (greater than)
  • >= (greater than or equal to)
  • IN (included in)
  • % (contains keyword)
  • resultvariantValue to be handled by the calculated attribute. Pass null in this property if you want to execute a default query (always sequential for calculated attributes).

    If the function returns a value in result and another value is assigned to the event.result property, the priority is given to event.result.


    • Query on the fullName calculated attribute.
    function query fullName(event : object)->result : object

    var fullname, firstname, lastname, myQuery : string
    var operator, myQuery : string
    var p : integer
    var parameters : collection


    p=position(" ",fullname)
    if (p>0)
    firstname=substring(fullname, 1, p-1)+"@"
    lastname=substring(fullname, p+1)+"@"
    parameters=newCollection(firstname, lastname) // two items collection
    parameters=newCollection(fullname) // single item collection

    : (operator=="==") | (operator=="===")
    if (p>0)
    myQuery="(firstName = :1 and lastName = :2) or (firstName = :2 and lastName = :1)"
    myQuery="firstName = :1 or lastName = :1"
    : (operator="!=")
    if (p>0)
    myQuery="firstName != :1 and lastName != :2 and firstName != :2 and lastName != :1"
    myQuery="firstName != :1 and lastName != :1"

    result=newObject("query", myQuery, "parameters", parameters)

    Keep in mind that using placeholders in queries based upon user text input is recommended for security reasons (see query() description).

    Calling code, for example:

    emps=ds.Employee.query("fullName = :1", "Flora Pionsin")
    • This function handles queries on the age calculated attribute and returns an object with parameters:
    function query age(event : object)->result : object

    var operator, myQuery : string
    var age : integer


    age=num(event.value) // integer
    d1=addToDate(currentDate, -age-1, 0, 0)
    d2=addToDate(d1, 1, 0, 0)
    parameters=newCollection(d1, d2)


    : (operator=="==")
    myQuery="birthday > :1 and birthday <= :2" // after d1 and before or egal d2

    : (operator=="===")

    myQuery="birthday = :2" // d2 = second calculated date (= birthday date)

    : (operator==">=")
    myQuery="birthday <= :2"

    //... other operators


    if (undefined(event.result))

    Calling code, for example:

    // people aged between 20 and 21 years (-1 day)
    twenty=people.query("age = 20") // calls the "==" case

    // people aged 20 years today
    twentyToday=people.query("age === 20") // equivalent to people.query("age is 20")

    function orderBy <attributeName>


    function orderBy <attributeName>(event : object)
    function orderBy <attributeName>(event : object)-> result : string

    // code

    The orderBy function executes whenever the calculated attribute needs to be ordered. It allows sorting the calculated attribute. For example, you can sort fullName on first names then last names, or conversely. When the orderBy function is not implemented for a calculated attribute, the sort is always sequential (based upon the evaluation of all values using the get <AttributeName> function).


    Calling an orderBy function on calculated attributes of type Entity class or Entity selection class is not supported.

    The event parameter contains the following properties:

    attributeNamestringCalculated attribute name
    dataClassNamestringDataclass name
    valuevariantValue to be handled by the calculated attribute
    operatorstring"desc" or "asc" (default)
    descendingbooleantrue for descending order, false for ascending order
    resultvariantValue to be handled by the calculated attribute. Pass null if you want to let Qodly execute the default sort.

    You can use either the operator or the descending property. It is essentially a matter of programming style (see examples).

    You can return the orderBy string either in the event.result object property or in the result function result. If the function returns a value in result and another value is assigned to the event.result property, the priority is given to event.result.


    You can write conditional code:

    function orderBy fullName(event : object)-> result : string
    if (event.descending==true)
    result="firstName desc, lastName desc"
    result="firstName, lastName"

    You can also write compact code:

    function orderBy fullName(event : object)-> result : string
    result="firstName "+event.operator+", "lastName "+event.operator

    Conditional code is necessary in some cases:

    function orderBy age(event : object)-> result : string
    if (event.descending==true)
    result="birthday asc"
    result="birthday desc"

    Exposed vs non-exposed functions

    For security reasons, all of your data model class functions are not exposed (i.e., private) by default to web requests.

    A function that is not exposed is not available from web requests and cannot be called on any object instance. You define non-exposed functions (as well as dataclasses or attributes) if you want them to be only available on the server through local code. If a web request tries to access a non-exposed function, the "-10729 - Unknown member method" error is returned.

    To allow a data model class function to be called by a remote request, you must explicitly declare it using the exposed keyword. The formal syntax is:

    // declare an exposed function
    exposed function <functionName>

    The exposed keyword can only be used with Data model class functions. If used with a regular user class function, it is ignored.


    You want an exposed function to use a private function in a dataclass class:

    extends DataClass

    //Public function
    exposed function registerNewStudent(student : object) -> status : object

    var entity : cs.StudentsEntity
    entity.fromObject(student)"name=:1", student.schoolName).first()

    //Not exposed (private) function
    function computeIDNumber()-> id : integer
    //compute a new ID number

    When the code is called:

    var student , status : object
    var id : integer

    student=newObject("firstname", "Mary", "lastname", "Smith", "schoolName", "Math school")

    status=ds.Schools.registerNewStudent(student) //can be called from a web request
    // id=ds.Schools.computeIDNumber() // Error "Unknown member method" if called from a web request