Chapter 5: ODMG C++/VERSANT Usage

ODMG header files are in ..h/odmg.

File: hello.h

#ifndef HELLO_H
#define HELLO_H
#include <odmg/object.h>
#include <odmg/string.h>
#include <iostream.h>
class Hello : public d_Object {
private:
   PString note;
public:
   // construct given const char pointer
   Hello   (const char*);
   // copy constructor
   Hello   (const Hello& );
   // access functions
   void      setNote(PString );
   PString   getNote();
   void d_activate();
   void d_deactivate();
};
#endif

File: hello.cxx

#include "hello.h"
// constructor, given pointer to const char
Hello::Hello(const char *s) : note(s)
{
    VPP_CLASS_CONSTRUCTOR1(Hello);
}
// copy constructor
Hello::Hello(const Hello& h) : note(h.note)
{
    VPP_CLASS_CONSTRUCTOR1(Hello);
}
// access functions
void Hello::setNote(PString s)
{

File: runhello.cxx

#include <iostream.h>
#include <odmg/odmg.h>
#include <odmg/set.h>
#include "hello.h"
extern "C" void exit(int);
main(int argc, char** argv)
{
   if ( argc != 2 )
   {
      cout << "Usage: " << argv[0] <<" dbname " << endl;
      exit(1);
   }
   d_Database* database = new d_Database;
   database->open(argv[1]);
   d_Transaction tran;
   tran.begin();
   char* str[6] =
   {
      "Hello", "World", "Versant",
      "Object", "Technology", "Corporation"
   };
   cout << "create Hello object" << endl;
   Hello *h;
   for ( o_4b i = 0; i < 3; i++ )
   {
      h= new(database, "Hello") Hello(str[i]);
   }
   cout << "\nTesting checkpoint..." << endl;
   tran.checkpoint();
   h= new(PClassObject<Hello>::Pointer()) Hello(str[3]);
   for ( i = 4; i < 6; i++ )
   {  // use operator new(size_t, const d_Ref_Any&, const char*)
      h= new(h->cod(), "Hello") Hello(str[i]);
   }
   cout << "\nTesting commit..." << endl;
   tran.commit();
   tran.begin();
   d_Set<d_Ref<Hello> > a =
      (VstrAny)PClassObject(Hello)::Object().select(argv[1],
                                                    FALSE,
                                                    NULL_PREDICATE);
   d_Iterator<d_Ref<Hello> > iter = a.create_iterator();
   d_Ref<Hello> ref;
   for ( ; iter.not_done(); iter.advance() )
   {
      ref = iter.get_element();
      cout << "\ndefrefence an object..." << endl;
      cout << (const char *)ref->getNote() << endl;
   }
   cout << "\nsecond time defefence the same objects" << endl;
   iter.reset();
   for ( ; iter.not_done(); iteradvance )
   {  ref = iter.get_element();
      cout << "\ndefrefence an object..." << endl;
      cout << (const char *)ref->getNote() << endl;
   }
   cout << "\nTesting abort..." << endl;
   tran.abort();
   database->close();
   delete database;
   exit(0);
}

File: Demo.h

// Schema Definition in C++ ODL
#include <odmg/odmg.h>
class City; // forward declaration
struct Address
{  d_UShort number;
   d_String street;
   d_Ref<City> city;
   Address();
   Address(d_UShort, const char*, const d_Ref<City> &);
};
extern const char _spouse [ ], _parents [ ], _children [ ] ;
class Person : public d_Object
{
public:
   // Attributes (all public, for this example)
   d_String name;
   Address address;
   // Relationships
   d_Rel_Ref<Person, _spouse> spouse;
   d_Rel_List<Person, _parents> children;
   d_Rel_List<Person, _children> parents;
   // Operations
   Person(const char * pname);
   void birth(const d_Ref<Person> &child); // a child is born
   void marriage(const d_Ref<Person> &to_whom);
   d_Ref<d_Set<d_Ref<Person> > > ancestors() const;
                                              // returns ancestors
   void move(const Address &);   // move to a new address
   // Extent
   static  d_Ref<d_Set<d_Ref<Person> > > people;
                                 // a reference to class extent
   static  const char * const extent_name;
};
class City : public d_Object
{
public:
   // Attributes
   d_ULong city_code;
   d_String name;
   //d_Ref<d_Set<d_Ref<Person> > > population;
   d_Set<d_Ref<Person> >  population;
                                 // the people living in this City
   // Operations
   City(d_ULong, const char*);
   // Extension
   static   d_Ref<d_Set<d_Ref<City> > > cities;
                                // a reference to the class extent
   static  const char * const extent_name;
};
File: Demo.cxx

// Classes Implementation in C++

#include "demo.h"
// Address structure:
Address::Address( d_UShort pnum,
                  const char* pstreet,
                  const d_Ref<City> &pcity )
   : number(pnum),
     street(pstreet),
     city(pcity)
{ }
Address::Address()
   : number(0),
     street((char *)0),
     city(0)
{ }
// Person Class:
const char * const Person::extent_name = "people";
d_Ref<d_Set<d_Ref<Person> > > Person::people;
Person::Person(const char * pname)
   : name(pname)
{

#include <iostream.h>
#include "demo.h"
#include <cxxcls/vql.h>
#include <cxxcls/oqlexec.h>
static d_Database dbobj;
static d_Database * database = &dbobj;
void Load()
{
   // Transaction which populates the database
   d_Transaction load;
   load.begin();
   // Create both Persons and Cities extensions, and name them.
   Person::people = new( database, "d_Set<Link<Person > >")
                         d_Set<d_Ref<Person> >;
   City::cities = new(database, "d_Set<Link<City > >" )
                      d_Set<d_Ref<City> >;
   database->set_object_name(Person::people, Person::extent_name);
   database->set_object_name(City::cities, City::extent_name);
   // Construct 3 persistent objects from class Person.
   d_Ref<Person> God, Adam, Eve;
   God  = new(database, "Person") Person("God");
   Adam = new(database, "Person") Person("Adam");
   Eve  = new(database, "Person") Person("Eve");
   // Construct an Address structure, Paradise,
   // as (7 Apple Street, Garden)
   // and set the address attributes of Adam and Eve.
   Address Paradise( 7,
                     "Apple",
                     new(database, "City") City(0, "Garden"));
   Adam -> move(Paradise);
   Eve  -> move(Paradise);
   // Define the family relationships.
   God->birth(Adam);
   Adam->marriage(Eve);
   Adam->birth(new(database, "Person") Person("Cain"));
   Adam->birth(new(database, "Person") Person("Abel"));
   load.commit();  // Commit transaction, putting objects
                   // into the database.
}
static void print_persons(const d_Collection<d_Ref<Person> >& s)
{
   // A service function to print a collection of Persons
   d_Ref<Person> p;
   d_Iterator<d_Ref<Person> > it = s.create_iterator();
   while( it.next(p) )
   {  cout << "--- " << p->name << " lives in ";
      if (p->address.city)
         cout << p->address.city->name;
      else
         cout << "Unknown";
         cout << endl;
   }
}
void Consult()
{
   // Transaction which consults and updates the database
   d_Transaction consult;
   d_List<d_Ref<Person> > list;
   consult.begin();
   // Static references to objects or collections must be recomputed
   // after a commit
   Person::people = database->lookup_object(Person::extent_name);
   City::cities   = database->lookup_object(City::extent_name);
   // Now begin the transaction
   cout << "All the people ....:" << endl;
   print_persons(*Person::people);
   cout << "All the people name ....:" << endl;
   d_VQL_Query query("select SelfOID from Person");
   LinkVstr<Person> personVstr;
   d_oql_execute(query, personVstr);
   list = (VstrAny) personVstr;
   print_persons(list);
   // Adam and Eve are moving ...
   Address Earth( 13,
                  "Macadam",
                  new(database,
                  "City") City(1,
                  "St-Croix"));
   LinkVstr<Person> Adams; query.set_query_string(
      "select SelfOID from Person where name = \"Adam\"" );
   d_oql_execute(query, Adams);
   d_Ref<Person> Adam = Adams[0];
   Adam->move(Earth);
   Adam->spouse->move(Earth);
   cout << "Cain's ancestors ...:" << endl;
   d_Ref<Person> Cain = Adam->children.retrieve_element_at(0);
   print_persons(*(Cain->ancestors()));
   consult.commit();
}
main()
{
   database->open("family");
   Load();
   Consult();
   database->close();
}
File: schema.imp

// This file is required for VERSANT schema compiler
// to create database schema.

#include "demo.h"

const char _spouse   [ ] = "spouse";
const char _parents  [ ] = "parents";
const char _children [ ] = "children";

O_CAPTURE_SCHEMA(Person);
O_CAPTURE_SCHEMA(Address);
O_CAPTURE_SCHEMA(City);
O_CAPTURE_SCHEMA(d_Collection<d_Ref<Person> >);
O_CAPTURE_SCHEMA(d_Collection<d_Ref<City> >);
O_CAPTURE_SCHEMA(d_List<d_Ref<Person> >);
O_CAPTURE_SCHEMA(d_Rel_Ref<Person, _spouse>);
O_CAPTURE_SCHEMA(d_Rel_List<Person, _parents>);
O_CAPTURE_SCHEMA(d_Rel_List<Person, _children>);
O_CAPTURE_SCHEMA(d_Set<d_Ref<Person> >);
O_CAPTURE_SCHEMA(d_Set<d_Ref<City> >);

File: demo.h

As above example

File:demo.cxx

As above example

File: schema.imp

As above example

File: main.cxx

#include <stdlib.h>
#include <unistd.h>
#include <iostream.h>
#include "demo.h"
#include <cxxcls/vql.h>
#include <cxxcls/oqlexec.h>
void *thr_main(void *);
void Load();
void print_persons(const d_Collection<d_Ref<Person> >& s);
void Consult();
d_Database *database;
int main(int argc, char** argv)
{

void Consult()
{

A conditional variable, cond, is used to make sure that three transactions successfully begin before threads join each other.

File: main.cxx

#include <stdlib.h>
#include <unistd.h>
#include <iostream.h>
#include <odmg/odmg.h>
#include "number.h"
#define MAX_SESSION3
void *thr_func0(void *);
void *thr_func1(void *);
void *thr_func2(void *);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
d_Transaction *tr[3];
d_Database *db[2];
int session_count=0;
main(int argc, char** argv)
{

void *thr_func0(void *arg)
{

void *thr_func1(void *arg)
{

void *thr_func2(void *arg)
{

File: number.h

#include <odmg/object.h>
class Number :public d_Object
{
public:

File: schema.imp

#include "number.h"

O_CAPTURE_SCHEMA(Number);