5.1 Conceptual Information Type Model

Go to 5. Common Information Types

The Conceptual Information Type Model defines the categories and characteristics used by DIDO-TE to describe reusable Common Information Types.

The model defines the meaning, value space, structure, units, and conceptual constraints of information independently of the logical or physical type systems used to represent that information.

The Conceptual Information Type Model provides a common framework for defining reusable information types without binding those types to a particular programming language, database, serialization format, interface definition language, runtime, or storage technology.

The model allows DIDO-TE to distinguish between:

• the conceptual meaning of information;
• the logical representation selected for a particular technology; and
• the physical representation selected by a particular implementation.

This section defines the conceptual level only.

Conceptual Information Types are organized primarily as:

• Scalar Types — types whose values are treated conceptually as individual values; and
• Structured Types — types composed from multiple subordinate conceptual values or elements.

A Scalar Type may have internal representation in a logical or physical realization without becoming a Structured Type at the conceptual level.

For example, a Binary Large Object (BLOB) may contain substantial internal binary structure, but the containing Information Model treats the BLOB as a single conceptual value.

A Scalar Type represents a conceptual value that is treated as a single value by the Information Model.

DIDO-TE recognizes the following general Scalar Type kinds:

These kinds define conceptual semantics. They do not prescribe equivalent types in SQL, JSON, XML, HTML, OMG IDL, Java, ECMAScript, Rust, or another logical or physical type system.

Numeric Scalar Types represent quantities or mathematical values.

The principal numeric kinds provided in Figure 5.1-1 Principal Numeric Kinds.

An Integer represents a whole-number value.

A Big Integer represents a whole-number value whose required conceptual range is not constrained to the range normally associated with fixed-size integer representations.

A Decimal represents an exact decimal value. A Decimal may define precision, scale, range, or other conceptual constraints.

A Big Decimal represents an exact decimal value whose required precision or scale is not constrained to an ordinary fixed-size decimal representation.

A Floating-Point value represents an approximate real-valued quantity for which precision characteristics are significant.

A Real represents a value from the conceptual domain of real numbers without prescribing Decimal, Floating-Point, or another computational representation.

Numeric types may define conceptual characteristics such as:

• minimum value;
• maximum value;
• range;
• precision;
• scale;
• units; and
• permitted increments.

A range constrains the value space of another type and is not itself a Scalar Type.

For example:

Integer
    Range: 0..10

Decimal
    Precision: 8
    Scale: 2

Floating-Point
    Precision: defined by the conceptual type

An Enumeration defines a finite ordered set of conceptual members.

Each Enumeration member may define the following properties:

The Position identifies the declared ordering of the Enumeration members and begins with 1.

The Ordinal Value identifies the zero-based ordinal corresponding to the declared Position and begins with 0.

The String Image identifies the symbolic textual representation of the member.

The Value identifies the conceptual value associated with the member.

The Value is not restricted to an Integer. Depending on the Enumeration, the Value may be:

• Integer
• Big Integer
• Decimal
• Big Decimal
• Floating-Point value
• String
• a range
• Duration
• color value
• Structured Type
• another conceptual value appropriate to the Enumeration.

For example:

An Enumeration may associate members with ranges:

An Enumeration may also associate members with structured conceptual values:

Position, Ordinal Value, String Image, and Value are distinct conceptual properties.

Logical or physical mappings may represent these properties differently without changing the conceptual Enumeration.

Temporal Scalar Types represent dates, times, temporal points, and elapsed time.

A Duration is distinct from Date, Time, or Date-Time because Duration represents an amount of time rather than a temporal point.

Individual Common Information Types may establish additional conceptual characteristics such as:

• precision;
• units;
• time-zone semantics;
• calendar semantics; or
• permitted ranges.

A String represents a sequence of characters treated as a single conceptual value.

Specialized Common Information Types may assign additional semantics or constraints to String values.

Examples include:

• names;
• descriptions;
• filenames;
• command-line expressions;
• namespaces;
• URIs;
• phone numbers; and
• version identifiers.

Two Common Information Types may both use String as their conceptual representation while retaining different semantics.

For example, Filename Type and URI Type may both use String as their conceptual representation, but they define different conceptual value spaces and semantic roles.

A Binary Type represents binary information treated as a single conceptual value.

Binary Types may represent Binary Large Objects (BLOBs) or other opaque binary information.

The conceptual Binary Type does not prescribe:

• storage representation;
• byte ordering;
• serialization;
• encoding;
• compression;
• encryption; or
• physical datatype.

These characteristics belong to applicable logical or physical mappings unless they form part of the conceptual semantics of a specialized type.

An Identifier represents an atomic conceptual value used to distinguish an identifiable thing from other things within an applicable identification scope.

An Identifier Type may define conceptual characteristics such as:

• uniqueness scope;
• persistence;
• namespace;
• assigning authority;
• generation rules; or
• comparison semantics.

The representation of an identifier is independent of its conceptual identity semantics.

A Structured Type is composed from multiple subordinate conceptual values, fields, members, or definitions that collectively form a reusable value structure.

Structured Types differ from Scalar Types because their subordinate elements form part of the conceptual definition of the type.

Examples may include:

• parameter definitions;
• parameter values;
• parameter lists;
• compound measurements;
• coordinate values;
• color values; or
• other reusable composite information structures.

The structure of each Structured Type is defined on its applicable Common Information Type page.

A Common Information Type may define one or more conceptual characteristics appropriate to the type.

Examples include:

Not every characteristic applies to every Common Information Type.

Each Common Information Type identifies only the characteristics required to define that type conceptually.

The Conceptual Information Type Model defines what information means and the conceptual characteristics that must be preserved.

Logical models subsequently map these conceptual types into the type systems provided by technologies such as:

• SQL;
• JSON;
• XML;
• HTML;
• OMG IDL;
• Java;
• ECMAScript;
• Rust; and
• other applicable languages, notations, or interchange technologies.

Physical models subsequently define concrete platform-specific representations.

A logical or physical representation may differ substantially from the conceptual representation provided that the required conceptual semantics and constraints are preserved.

• [DTE4] DIDO Reference Data Model, conceptual datatypes, Enumerations, Primitive Types, and related conceptual model elements.

• This page defines the DIDO-TE conceptual information-type framework.
• Keep conceptual type categories independent of logical and physical implementation technologies.
• Add a conceptual type category only when the category represents a meaningful semantic distinction required by DIDO-TE.
• Do not infer a conceptual distinction solely from the existence of a datatype in a particular programming language, database, or serialization technology.