---

cPersistentObject.cpp

Go to the documentation of this file.

/******************************************************************************/
/*                                                                            */
/* POLiTe - Persistent Object Library Test                                    */
/*                                        Ph.D. Thesis by Mgr. Michal Kopecky */
/*                                                                            */
/* Charles University Prague                                                  */
/*                                                                            */
/******************************************************************************/
/*                                                                            */
/* File name: ...                                                             */
/* Module: ......                                                             */
/*                                                                            */
/******************************************************************************/

//      PersistentObject is represented in a
//      relational database by a set of tables.
//  To the root class of the hierarchy tree is assigned a table
//  with columns associated to the attributes of this class.
//  Each descendant class is represented by a table which columns
//      correspond only to the added attributes.
//  Attributes of one object then appear in several tables.
//  From this follows that a object must be     constructed
//  by multiple joins of tables associated with all predecessors
//      in the hierarchy tree.
//  To be able to join all pieces of one object,
//      each table must contain an additional column OID.

// Own Header
#include <cPersistentObject.h>

// Other POLiTe Header(s)
#include <tProto.h>
#include <cRefBase.h>

PROTOTYPE(PersistentObject);
//Proto<PersistentObject> PersistentObject_class;

//PersistentObject constructor

PersistentObject::PersistentObject()
{
        #ifdef C_PERSISTENTOBJECT_TRACE
        logmsg("PersistentObject::PersistentObject() invoked");
        #endif

        _SerialNumber = 0;
        _OID = -1;  // non-existent OID

// OidBasedPersistentObjects
// The class is similar to PersistentObject with following differences:
// Object has special primary key called OID (Object Identification).
// OID is unique in the database.
// It supports specialisation hierarchy of classes, parent data are stored separately in other tables
// and handled by predecessors.

        #ifdef C_PERSISTENTOBJECT_TRACE
        logmsg("PersistentObject::PersistentObject() finished");
        #endif
}

//PersistentObject destructor

PersistentObject::~PersistentObject()
{
        #ifdef C_PERSISTENTOBJECT_TRACE
                logmsg("PersistentObject::~PersistentObject() invoked");
        #endif

        _Free();

        #ifdef C_PERSISTENTOBJECT_TRACE
                logmsg("PersistentObject::~PersistentObject() finished");
        #endif
}

//Causes an object to be persistent.
//Persistent objects are  created as transient (they exist only
//in memory) and when it is needed (all attributes are set to
//appropriate values), then they  can be converted to true
//persistent objects. An advantage is that transient objects do
//not propagate into a database while persistent objects are
//written (in spite of buffering mechanism) to the database
//often.

class RefBase PersistentObject::BePersistent(
        class Connection *DbCon
        )
{
        RefBase retval;

        #ifdef C_PERSISTENTOBJECT_TRACE
                logmsg("int PersistentObject::BePersistent() invoked");
        #endif

        if (IsPersistent())
                retval = Address();
        else {
                if (DbCon == NULL)
                        throw ObjLibException_ConnectionError();
                // SELECT NEW OID
                DbCon->_NextOID(_OID,_SerialNumber);
                retval = DatabaseObject::BePersistent(DbCon);
                };

        #ifdef C_PERSISTENTOBJECT_TRACE
                logmsg("int PersistentObject::BePersistent() finished");
        #endif

        return retval;
        };


bool PersistentObject::Update()
{
        bool retval = true;
        class Connection *DbCon;

        #ifdef C_PERSISTENTOBJECT_TRACE
                logmsg("bool PersistentObject::Update() invoked");
        #endif

        if (IsPersistent() && IsDirty())
        {
                #ifdef C_PERSISTENTOBJECT_TRACE
                        logmsg("PersistentObject is dirty");
                #endif
                if ((DbCon = Connection()) == NULL)
                        throw ObjLibException_ConnectionError();
                // SELECT NEW SERIAL FOR THIS OID
                DbCon->_NextSN(_OID,_SerialNumber);
                retval = DatabaseObject::Update();
        };

        #ifdef C_PERSISTENTOBJECT_TRACE
                logmsg("bool PersistentObject::Update() finished");
        #endif

        return retval;
        };

// Checks, if version of object in memory is the same as the version in the database
// Applicable on PersistentObject class, predecessors return true
bool PersistentObject::_VersionsMatch()
{
        if (IsTransient())
                        return true;
        // check version in the database with current version in itself
        long dbVersion;
        bool okay;
        char *oidStr = LongToStr(_OID);
        char *sqlcmd = NULL;
        StrCat(sqlcmd,2,"SELECT VERSION FROM " PERSISTENT_OBJECT_TABLE " WHERE OID = ",oidStr);
        StrFree(oidStr);
        okay = _Connection->_Open()
                && _Connection->_Prepare(sqlcmd)
                && _Connection->_Execute()
                && _Connection->_PreFetchBind(
                        1,
                        (void *)&dbVersion,
                        4,
                        TYPE_INT
                        )
                && _Connection->_FetchNext()
                && _Connection->_Close();
        return okay && (dbVersion==_SerialNumber);
};

---