Defining a simple schema with ODL

Now that a database has been created, we are going to populate it with objects.

The first step is to define the database schema.

A standard example in databases is the well known Person class (or table in relational system) which contains a few attributes such as a firstname, a lastname, an age, an address, a spouse and a set of children.

We will show the inheritance feature through the simple class Employee which inherits from the Person class and will contains a simple attribute: salary.

Here is simple ODL schema for the classes Address, Person and Employee:

//
// person.odl
//

class Address {
  int num;
  string street;
  string town;
  string country;
};

class Person {
  string firstname;
  string lastname;
  int age;
  Address addr;
  Person * spouse inverse Person::spouse;
  set<Person *> children;
};

class Employee extends Person {
  long salary;
};

A few comments about this schema:

the Address class contains four attributes, one integer and three strings.
- integer: there are three types of ODL integers:
  1. 16-bits integer, named int16 or short
  2. 32-bits integer, named int32 or int
  3. 64-bits integer, named int64 or long
  so the num attribute is a 32-bits integer.
- string: an ODL string is under the form: string or string<N>. The first form means that the string is not bounded, the second form means that the string contains at most N characters.
the Person class contains six attributes: two strings, one 32-bits integer, one Person object and one set of Person objects.
- the third attribute addr is of Address type and is a litteral because there is no * before the attribute name. A litteral is an object without identifier: the addr attribute is tied to a Person instance, it has no proper existence.
- the spouse attribute is an object, not a litteral, because it is preceded by a *. An object has an identifier and has its proper existence. The * means a reference or pointer to an object. The directive after the attribute name inverse Person::spouse is a relationship directive.
- the children attribute is a collection set of Person objects.
the Employee contains seven attributes: the six Person attributes because Employee inherits from Person and 64-bits integer attribute: salary.

To add the previous schema in the foo database, you need to use the eyedbodl tool as follows:

% eyedbodl -d foo -u person.odl
Updating 'person' schema in database foo...
Adding class Address
Adding class Person
Adding class Employee

Done

Note that you must pass the following command line options to the eyedbodl command: -d foo to specify to which database you are applying the schema and -u to update the database schema.

To verify that the update has correctly worked, you can generate the ODL schema from the database, as follows:

% eyedbodl -d foo --gencode=ODL²

//
// EyeDB Version 2.8.4 Copyright (c) 1995-2007 SYSRA
//
// UNTITLED Schema
//
// Generated by eyedbodl at Mon Dec 10 13:44:03 CET 2007
//

class Address (implementation <hash, hints = "key_count = 2048;">) {
        attribute int32 num;
        attribute string street;
        attribute string town;
        attribute string country;
};

class Person (implementation <hash, hints = "key_count = 2048;">) {
        attribute string firstname;
        attribute string lastname;
        attribute int32 age;
        attribute Address addr;
        relationship Person* spouse inverse Person::spouse;
        attribute set<Person*> children;
};

class Employee (implementation <hash, hints = "key_count = 2048;">) extends Person {
        attribute int64 salary;
};

Note that the exact output may differ a bit from what is displayed above, depending on the EYEDB version.

By default, eyedbodl generates the ODL on the standard output. You see here that the displayed ODL is very similar to the original ODL except that the keywords attribute and relationship have been added before each attribute declaration. The relationship keyword means that the attribute has an inverse directive.

Note that these two keywords are optional: it is why we have not use them in our example.

Another way to check that the schema has been created within the database, is to use the eyedboql tool, as follows:

% eyedboql -d foo -c "select schema" --print
= bag(2546.2.120579:oid, 2553.2.112046:oid, 2568.2.515951:oid)
struct Address {2546.2.120579:oid} : struct : agregat : instance : object { 
        attribute int32 num;
        attribute string street;
        attribute string town;
        attribute string country;
};
struct Person {2553.2.112046:oid} : struct : agregat : instance : object { 
        attribute string firstname;
        attribute string lastname;
        attribute int32 age;
        attribute Address addr;
        relationship Person* spouse inverse Person::spouse;
        attribute set<Person*> children;
};
struct Employee {2568.2.515951:oid} : Person : struct : agregat : instance : object { 
        attribute string Person::firstname;
        attribute string Person::lastname;
        attribute int32 Person::age;
        attribute Address Person::addr;
        relationship Person* Person::spouse inverse Person::spouse;
        attribute set<Person*> Person::children;
        attribute int64 salary;
};

Again, note that the exact output may differ a bit from what is displayed above, depending on the EYEDB version.

Note that the object identifiers (oid) of the classes are displayed.

EyeDB manual