ToC path:

Base Data Types

The following table describes the data types recognized by the DDL compiler mcocomp:
Data type

Meaning

Example

signed<n>

Signed n-byte integer, n = 1, 2, 4, or 8.
Example:
 
{
    signed<2> a_short; 
};
 
unsigned<n>

Unsigned n-byte integer, n = 1, 2, 4, or 8.
Example:
 
{
    unsigned<4> hall;
};
 
float

4-byte real number.
Example:
 
{
    float rate;
};
 
double

8-byte real number.
Example:
 
{
    double rate;
};
 
char<n>

Fixed length single-byte character array less than 64K in size. char fields could store C-type strings or binary data. Trailing null characters for C strings are not required to be stored, since eXtremeDB adds them when the string is read out of the database, provided that the size of the supplied buffer is large enough to hold it.
Example:
 
{
    char<8> name;
};
 
nchar<n>

Fixed length double-byte character array less than 64K in size. nchar fields store 2-byte characters that are sorted by their numerical value. This is suitable for many Asian languages.
Example:

In the schema:
 
{
    nchar<20> uname;
};
 
In the C/C++ program:
 
    nchar_t uname[21];
 
wchar<n>

Fixed length double-byte character array of less than 64K in size. wchar fields store Unicode characters that are sorted according to the machine’s locale setting.
Example:

In the schema:
 
{
    wchar<20> uname;
};
 
In the C/C++ program:
 
    wchar_t uname[21];
 
binary<n>

Fixed length byte array less than 64K in size. Like char<n> except in how comparison is performed while building an index or searching. For these purposes an array of characters has the natural delimiter '\0' that marks the end of the compared part; binary data are used entirely as defined by the array size. Can be a field of a class, structure and even of a direct structure. Arrays and vectors of binary<n> are allowed.
Example:
 
{
    binary<100>                  b;
    binary<100>                  b_array[10];
    vector<binary<100>>                  b_vector;
};
 
string

Variable-length single-byte character array of less than 64K bytes in size. Bytes are returned to the application exactly as stored (up to the length of the supplied buffer). C-strings of unknown length should be stored in a string field to save space. Ending null characters can be omitted, for the same reasons as for char<n> type. On creation, fields of type string contain only a 2 or 4 byte null pointer. No storage is allocated until a value is inserted and the pointer value is set to the address of the variable length storage (which consists of the 2 byte length followed by the body).
Example:
 
{
    string description;
};
 
nstring

Variable length double-byte character array less than 64K in size. See nchar. On creation, fields of type nstring contain only a 2 or 4 byte null pointer. No storage is allocated until a value is inserted and the pointer value is set to the address of the variable length storage (which consists of the 2 byte length followed by the body).
Example:

In the schema:
 
{
    nstring uname;
};
 
In the C/C++ program:
 
    nchar_t *uname;
 
wstring

Variable length double-byte character array less than 64K in size. See wchar. On creation, fields of type wstring contain only a 2 or 4 byte null pointer. No storage is allocated until a value is inserted and the pointer value is set to the address of the variable length storage (which consists of the 2 byte length followed by the body).
Example:

In the schema:
 
{
    wstring uname;
};
 
In the C/C++ program:
 
    wchar_t *uname;
 
varbinary

Variable length byte array (like type string is a variable length character array except for comparison where all bytes of the string are used). Can be a member of a class or structure (making it variable length). But it cannot be a field of direct structure; can be nullable; arrays and vectors of varbinary are allowed. On creation, fields of type varbinary contain only a 2 or 4 byte null pointer. No storage is allocated until a value is inserted and the pointer value is set to the address of the variable length storage (which consists of the 2 byte length followed by the body).
Example:
 
{
    varbinary                   vb;
    varbinary                   vb_array[10];
    vector<varbinary>           vb_vector;
};
 
enum

User-defined type consisting of a set of named constants called enumerators. The name of each enumerator is treated as a constant and must be unique within the scope of the DDL schema where the enum is defined. An enumerator can be promoted to a unit1, uint2, or uint4 value.
Example:
 
enum FLOWCONTROL {
       XON, CTS 
};
 
class using_enum {
    FLOWCONTROL fc;
};
 
numeric | decimal

numeric<W,P> =decimal<W,P>; W = width P = Precision where P <= W < 20 The actual storage space occupied is determined by the specified width:
Width Storage Type
1 - 2 signed<1>
3 - 4 signed<2>
5 - 9 signed<4>
10 - 19 signed<8>
Example:
 
{
    numeric<10,2> num;
    decimal<8> dec;
};
 
sequence

A sequence is an unbounded array of eXtremeDB-supported scalar data elements, e.g. [u]int[1|2|3|4|8], float and double.
Example:
 
class quote 
{
    sequence<float> open; 
    sequence<float> close;
    sequence<float> high;
    sequence<float> low;
    sequence<int4> volume;
    sequence< time asc> timestamp; 
};
 
blob

Binary data object; a byte array of any size, can be greater than 64K in size.
Example:
 
{
    blob jpeg
};
 
vector

Variable length array of any data type, such as signed, unsigned, or struct (in C terminology).
Example:
 
struct A {
    unsigned<2> a1;
    char a2
};
 
class A_class {
 
    vector <A> struct_array;
    vector<unsigned<2>> numbers;
};
 
ref

Explicitly declared reference to an object by object’s oid.
Example:
 
struct Id {
    unsigned<2> a1;
    char a2
};
 
declare oid 	Id[20000];
 
class A {
    ...
    oid;
};
 
class B {
    ...
    ref a; // reference to an
               // object of class A
};
 
autoid_t

Explicitly declared reference to an object by object’s autoid.
Example:
 
class A {
    ...
    autoid[20000];
};
 
class B {
    ...
    autoid_t<A> a;
    vector <autoid_t> va;
};
 
date

A 32 bit unsigned integer. Though it can be used to store date values in any user-defined format, typically it is used to store the value used in most C/C++ time functions which treat the integer value as the number of seconds since 1 Jan 1970 (Epoch).
Example:
 
{
    date start_dt;
};
 
time

A 32 bit unsigned integer. Though it can be used to store time values in any user-defined format, typically it is used to store the value used in most C/C++ time functions which treat the integer value as the number of seconds since 1 Jan 1970 (Epoch).
Example:
 
{
    time start_tm;
};
 
datetime

A 64 bit unsigned integer. It can store the date/time in higher resolution, up to nanoseconds. To be compatible with Java, C# and xSQL, C/C++ applications must store date/time with database's resolution (defined with MCO_RT_OPTION_DATETIME_PRECISION). Please refer to page Managing Date/Time Fields in C for further details.)
Example:
 
{
    datetime start_dt;
};
 
boolean

A fixed size array of bits.
Example:
 
{
    boolean bits[8];
};
 
rect | rectangle

A rectangle with 2,4,8 byte integers, float or double coordinates.
Example:
 
{
    rectangle <uint2>	u2[3];
    rectangle<float>	f[2];
};
 

Width	Storage Type
1 - 2	signed<1>
3 - 4	signed<2>
5 - 9	signed<4>
10 - 19	signed<8>

In addition, data types can be fixed size arrays, for example:
 
    time start_tm[3];
 
defines an array of three time values. Any element except vectors, blobs and optional structs can be a fixed size array. Fixed size arrays cannot be used in indexes; for this, use a vector.

Variable Length Field References

For each string, vector, sequence, blob or optional struct field a reference pointer (2 or 4 bytes) is stored in the data layout for the objects of this class. The actual object data is stored separately and retrieved via this reference address when the object is accessed. This can lead to performance considerations especially for persistent databases.

String, Blob and Binary Fields

It is recommended to use blob fields only for large data fields (greater than 1 Kb). When a field is not intended to be used in indexes and its data size is less than 64 Kb it is recommended to use string fields (without any encoding). String fields in eXtremeDB can contain arbitrary data, not only ASCII characters; i.e. arbitrary binary data can be stored in a string without encoding. The only limitation is that string fields cannot be used in internal comparisons (needed for indexes) and cannot be passed as parameters in xSQL. If a field of binary data is intended to be indexed, the binary or varbinary data type should be used. Unlike blob fields, binary and varbinary fields can be added to both simple and compound indexes.