Object Instance Access

Object instances are instances of a complex data type. Elementary data types may apply to attribute instances, only. Object instances may contain any number of base type instances (inheritance), attributes, references (part of) and relationships (associations).

Object instance

Base type instances: Base type instances are either directly embedded in the instance (exclusive inheritance) or refer to the base type instance via an instance LOID (shared inheritance). Internally, base type instances always appear as embedded instances, but externally, in case of shared inheritance, only the instance LOID is stored. Since base type instances are object instances, those may, again, contain all types of instance properties.

Attributes: Typically, attributes refer to elementary data types, but may have also complex data types. In case of complex data types, attribute object instances must not contain shared base type instances and relationships. Attributes may refer to single instances or to an array of instances with a fixed dimension. Usually, attributes are directly embedded in the object instance. A special attribute is the generic attribute (mainly used for toring attribute instances for different languages). Internally, generic attributes appear as embedded instances (e.g. for preferred language), but externally, the collection LOID to the instance collection is stored.

References: References may refer to elementary data type fields as text fields (STRING, UTF8, ...) or binary objects (BLOB). In this case, the referenced instance is stored externally as instance LOID. Also, references may refer to e collection of complex data type instances, in which case the external object instance contains the collection LOID. Internally, references appear as property handles (odaba::Property). Referenced instances are owned by the object instance and will be deleted, when the object instance is deleted.

Relationships: Relationships always refer to instance collections via a collection LOID (externally). Internally, the appear as property handles (odaba::Property). Usually, referenced instances in a relationship can be shared with other collections.

Extension properties: Extension properties are instance properties (except base type properties), that may be added dynamically to an object instance.

Instance properties that internally appear as property handle can be used for further collection access by means of the stored LOID. Although, in some cases instances are referenced directly via an instance LOID, this will also be considered as a special type of a collection LOID.