Reltio Attribute Types

Reltio allows you to use attribute types within an entity or relationship object.

Entities and relationships typically hold a set of attributes. A principal and unique aspect of the Reltio information model and architecture, are the fundamental attribute types you can use within an entity or relationship object. These attribute types, each modeled as an array to hold multiple values, empower business analysts and developers to define a logical model for the business without worrying about physical tables and foreign keys. The four Reltio Attribute types are:

  • Simple attribute
  • Nested attribute
  • Reference attribute
  • Analytic attribute

Simple Attribute

The Simple Attribute is designed to capture and represent a single stand-alone attribute within an entity or relationship.

The simple attribute type is the only Reltio attribute type that can and must be further defined as a data type, described in the following table. Other Reltio attributes (Nested, Reference, and Analytic) are composed of collections of the Simple attribute or Nested attribute.

Table 1. Simple Attribute Data Types
Data Type of Simple Attribute Description Supported Format Additional Information
String This can be any text.   Length of the value is limited by the option maxAttributeValueSize in the physical configuration, where the default maximum value is 10240.
Int, Integer, Long, Dollar All these types are considered by the Reltio platform as Long java type.    
Number Number supports any value that can be parsed to Double and Long java objects such as (Long.parseLong(value) or Double.parseDouble(value);).    
Float, Double This can be any value that can be parsed to the Double java object (Double.parseDouble(value);).    
Boolean This can be any value that can be parsed to the Boolean java object (Boolean.parseBoolean(value);) . The possible values considered as true or false. Look at the possible values for Java type Boolean (java/lang/Boolean.java).
Date, Time, Timestamp Date is a different type. Following are the supported Date formats:
  • yyyy-MM-dd
  • MM/dd/YYYY
  • MM.dd.YYYY
  • MM-dd-YYYY
  • YYYY/MM/dd
  • YYYY-MM-dd
  • YYYY.MM.dd
  • YYYYMMdd
Supports the Time format but does not consider extra information such as hours and minutes.
Time and Timestamp are the same types. Following are the supported Time and Timestamp formats:
  • YYYY-MM-dd'T'HH:mm:ss.SSSZ
  • yyyy-MM-dd'T'HH:mm:ssZZ
  • yyyy-MM-dd'T'HH:mm:ss.SSSZZ
  • MM/dd/YYYY HH.mm
  • MM.dd.YYYY HH.mm
  • MM-dd-YYYY HH.mm
Supports the Date format but the missing information such as hours and minutes are filled in by zeros.
Blob Any text can be entered in a blob. As the value represents binary data, the same text cannot be used for searching. You can store a multiline text data in this type of attributes.  

For more information, refer to the Knowledge Base Article.

URL, Blog URL, Image URL This can be any text and is wrapped if needed. It is displayed as a link on the Hub.    

Reltio platform does not allow you to define a custom format for the time and date values, but supports various formats for attributes of the specified types as explained in the above table.

Examples of Attributes Filled by Template

Timestamp

The timestamp in the business configuration is as follows:

...{
    "label": "DeliveryTime",
    "name": "DeliveryTime",
    "description": "",
    "type": "Timestamp",
    "hidden": false,
    "important": false,
    "system": false,
    "required": false,
    "searchable": true,
    "attributeOrdering": {
        "orderType": "ASC",
        "orderingStrategy": "LUD"
    },
    "uri": "configuration/entityTypes/Package/attributes/DeliveryTime",
    "skipInDataAccess": false
}...

The possible formats of the timestamp attribute in a request are as follows:

[
    {
        "attributes": {
            "DeliveryTime": [
                  {
                    "value": "2015-04-29T10:15:00.500+0000"
                  },
                  {
                    "value": "2015-04-29T10:16:00+00:00"
                },
                {
                    "value": "2015-04-29T10:17:00.500+00:00"
                },
                {
                    "value": "04/29/2015 10.18"
                },
                {
                    "value": "04.29.2015 10.19"
                },
                {
                    "value": "04-29-2015 10.20"
                },
                {
                    "value": "1601547609000"
                }
            ]
        },
        "type": "configuration/entityTypes/Package",
        "crosswalks": [
            {
                "type": "configuration/sources/HMS",
                "value": "pack01"
            }
        ]
    }
]

In the response, the values are converted to one format as follows:

... "attributes": {
        "DeliveryTime": [
            {
                "type": "configuration/entityTypes/Package/attributes/DeliveryTime",
                "ov": true,
                "value": "2015-04-29T10:18:00.000+0000",
                "uri": "entities/l4KNI1t/attributes/DeliveryTime/27ruofPRB"
            },
            {
                "type": "configuration/entityTypes/Package/attributes/DeliveryTime",
                "ov": true,
                "value": "2015-04-29T10:17:00.500+0000",
                "uri": "entities/l4KNI1t/attributes/DeliveryTime/27ruofLAv"
            },
            {
                "type": "configuration/entityTypes/Package/attributes/DeliveryTime",
                "ov": true,
                "value": "2015-04-29T10:16:00.000+0000",
                "uri": "entities/l4KNI1t/attributes/DeliveryTime/27ruofGuf"
            },
            {
                "type": "configuration/entityTypes/Package/attributes/DeliveryTime",
                "ov": true,
                "value": "2020-10-01T10:20:09.000+0000",
                "uri": "entities/l4KNI1t/attributes/DeliveryTime/27ruofXxh"
            },
            {
                "type": "configuration/entityTypes/Package/attributes/DeliveryTime",
                "ov": true,
                "value": "2015-04-29T10:19:00.000+0000",
                "uri": "entities/l4KNI1t/attributes/DeliveryTime/27ruofThR"
            },
            {
                "type": "configuration/entityTypes/Package/attributes/DeliveryTime",
                "ov": true,
                "value": "2015-04-29T10:15:00.500+0000",
                "uri": "entities/l4KNI1t/attributes/DeliveryTime/27ruofCeP"
            },
            {
                "type": "configuration/entityTypes/Package/attributes/DeliveryTime",
                "ov": true,
                "value": "2015-04-29T10:20:00.000+0000",
                "uri": "entities/l4KNI1t/attributes/DeliveryTime/1CiSgOvkQ"
            }
        ]
    },...

Date

The possible formats of the date attribute in a request are as follows:

[
    {
        "attributes": {
            "DeliveryDate": [
                {
                    "value": "2015-04-10"
                },
                {
                    "value": "04/11/2015"
                },
                {
                    "value": "04.12.2015"
                },
                {
                    "value": "04-13-2015"
                },
                {
                    "value": "2015/04/14"
                },
                {
                    "value": "2015-04-15"
                },
                {
                    "value": "2015.04.16"
                },
                {
                    "value": "20150417"
                }
            ]
        },
        "type": "configuration/entityTypes/Package",
        "crosswalks": [
            {
                "type": "configuration/sources/HMS",
                "value": "pack02"
            }
        ]
    }
]

In the response, the values are converted to one format as follows:

..."DeliveryDate": [
        {
            "type": "configuration/entityTypes/Package/attributes/DeliveryDate",
            "ov": true,
            "value": "2015-04-17",
            "uri": "entities/1MDULiDj/attributes/DeliveryDate/2UUBjKj2R"
        },
        {
            "type": "configuration/entityTypes/Package/attributes/DeliveryDate",
            "ov": true,
            "value": "2015-04-16",
            "uri": "entities/1MDULiDj/attributes/DeliveryDate/2UUBjKemB"
        },
        {
            "type": "configuration/entityTypes/Package/attributes/DeliveryDate",
            "ov": true,
            "value": "2015-04-15",
            "uri": "entities/1MDULiDj/attributes/DeliveryDate/2UUBjKaVv"
        },
        {
            "type": "configuration/entityTypes/Package/attributes/DeliveryDate",
            "ov": true,
            "value": "2015-04-14",
            "uri": "entities/1MDULiDj/attributes/DeliveryDate/2UUBjKWFf"
        },
        {
            "type": "configuration/entityTypes/Package/attributes/DeliveryDate",
            "ov": true,
            "value": "2015-04-13",
            "uri": "entities/1MDULiDj/attributes/DeliveryDate/2UUBjKRzP"
        },
        {
            "type": "configuration/entityTypes/Package/attributes/DeliveryDate",
            "ov": true,
            "value": "2015-04-12",
            "uri": "entities/1MDULiDj/attributes/DeliveryDate/2UUBjKNj9"
        },
        {
            "type": "configuration/entityTypes/Package/attributes/DeliveryDate",
            "ov": true,
            "value": "2015-04-11",
            "uri": "entities/1MDULiDj/attributes/DeliveryDate/2UUBjKJSt"
        },
        {
            "type": "configuration/entityTypes/Package/attributes/DeliveryDate",
            "ov": true,
            "value": "2015-04-10",
            "uri": "entities/1MDULiDj/attributes/DeliveryDate/2UUBjKFCd"
        }
    ]
},...

Nested Attribute

Create collections of attributes.

A nested attribute is as a collection of simple attributes. An example of a nested attribute is a phone number, which has sub-attributes of number, type, area code, and extension. For this attribute, the sub-attributes are only meaningful when held together as a collection. When posted as a nested attribute the entire collection represents a single instance (the value) of the nested attribute. Posts of additional collections are also valid and serve to accumulate additional nested attributes within the entity or relationship object.

When an attribute assumes a collections of sub-attributes, it is a best practice to use the nested attribute. But even if you only expect a single instance, a nested attribute is a convenient way to group a set of attributes that have a collective synergy. Visually, the nested attribute has the expand-collapse capability that allows the sub-attributes to be hidden when not needed in their entire details and display. For example, to capture the physical characteristics of a person, such as eye color, hair color, height, and weight, a simple attribute could be used for each. However, the set of characteristics must be sub-attributes of a nested attribute. As a nested set, the sub-attributes are normally collapsed but can be fully viewed in the UI by expanding the nest.

Reference Attribute

Reference attributes define relationships between entity types.

Reference attributes are used to empower one entity to reference and thus make use of the attributes of another as if they were defined natively in the referencing entity. A prerequisite of the reference attribute is an underlying relationship type between the referenced and referencing entity types. That is, in order to define a reference attribute, you must first establish a relationship type between two entity types of interest. Then you can assign one entity type to be a reference of the other.

For example, the L1 layer in Reltio platform's Information Model defines a relationship that links an Organization and an Individual using the affiliatedwith relationship type. It could stop at that point and if it did, from a visual perspective, you could navigate to the Organization and see a faceted list of related Individuals or vice versa. They would be hyperlinked and you could click on them to navigate. But the affiliatedwith definition goes further and defines the Organization entity type to be a reference attribute of the individual entity type. By doing so the following capabilities become available:

  • The Individual entity type could have an attribute named perhaps Previous Employer which presents itself as a hyperlink on the Individual’s Profile facet. Clicking on the hyperlink will navigate the user to the entity of the previous employer.
  • The attributes of the referenced entity as well as those of the affiliatedwith relationship are available to be treated (thus indexed) as though they were native to the referencing entity, in this case, the Individual. The attributes defined to actually be referenced behave as if they were native.

Consider this example:

If a data set includes 100 John Smith records, and John Smith is entered in the type ahead search box, with the magnifying option, 100 John Smith records will be returned. But if Acme is added to the search criteria, only records with John Smith that have a reference (and thus an attribute) that contains the word Acme are returned. In this case the returned results are filtered and much more relevant.

For cases where you want to use reference attributes in a way when numerous entities make reference to the same in another entity, you can mark all sub-attributes of a reference attribute as immutable for some particular sources. Refer to Immutable Reference Attributes for more information.

Note: It is possible to use only OV values inside reference attributes. Refer to The Entity Type for more information

Analytic Attribute

Analytic attributes receive and hold values defined by Analytics.

The Analytic Attribute is a lightweight attribute, similar to simple attribute. It is not managed as are other attributes when records come together during a merge operation. Instead, the Analytic attribute is reserved for the purpose of receiving and holding a value delivered from Analytics.

For example, if your Analytics implementation is designed to calculate a customer’s lifetime value. And, you want that value to be available to the MDM user while looking at the customer’s profile, or available to other applications using the Reltio Rest API, you could define an Analytic attribute to hold this value and instruct Reltio Insights to deliver the result of the calculation to this attribute.