---

cDatabaseObject.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: ......                                                             */
/*                                                                            */
/******************************************************************************/

// Own Header
#include <cDatabaseObject.h>                                                    // Persistent Object class header

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


// Database Objects are objects stored in a relational database. Database objects
// represent rows in existing external relational database tables. Each row is identified
// by values of the primary key attributes. Persistent Objects can be locked in the memory
// to avoid their swapping out from memory and to assure their fixed memory address until
// unlock is called.

PROTOTYPE(DatabaseObject);
//Proto<DatabaseObject> DatabaseObject_class;

// DatabaseObject constructor:
// Create the DatabaseObject object with the appropriate initialization.

DatabaseObject::DatabaseObject()
{
// DatabaseObject
// Select may access data in one table only.
// Using of GROUP BY and HAVING clauses, aggregate function operators is not allowed.
// Object structure must be compatible with the accessed table structure.
// Object changes are propagated to an appropriate row of database table.

        #ifdef C_DATABASEOBJECT_TRACE
        logmsg("DatabaseObject::DatabaseObject() invoked");
        #endif

        _DirtyFlag = false;
        _MemoryLocks = 0;

        #ifdef C_DATABASEOBJECT_TRACE
                logmsg("DatabaseObject::DatabaseObject() finished");
        #endif
}

// DatabaseObject constructor:
// Create the DatabaseObject object with the appropriate initialization.

DatabaseObject::DatabaseObject(
        enum LockingStrategy a_LockingStrategy,
        enum UpdatingStrategy an_UpdatingStrategy,
        enum WaitingStrategy a_WaitingStrategy,
        enum ReadingStrategy a_ReadingStrategy
        )
{
        #ifdef C_DATABASEOBJECT_TRACE
                logmsg("DatabaseObject::DatabaseObject(...) invoked");
                logmsg("a_LockingStrategy == \"%s\"", msg(a_LockingStrategy));
                logmsg("an_UpdatingStrategy == \"%s\"", msg(an_UpdatingStrategy));
                logmsg("a_WaitingStrategy == \"%s\"", msg(a_WaitingStrategy));
                logmsg("a_ReadingStrategy == \"%s\"", msg(a_ReadingStrategy));
        #endif

        SetLockingStrategy(a_LockingStrategy);
        SetUpdatingStrategy(an_UpdatingStrategy);
        SetWaitingStrategy(a_WaitingStrategy);
        _DirtyFlag = false;
        _MemoryLocks = 0;

        #ifdef C_DATABASEOBJECT_TRACE
        logmsg("DatabaseObject::DatabaseObject(...) finished");
        #endif
}

// Object destructor:
// Delete the Object object with the appropriate de-initialization.

DatabaseObject::~DatabaseObject()     // destructor
{
        #ifdef C_DATABASEOBJECT_TRACE
        logmsg("DatabaseObject::~DatabaseObject() invoked");
        #endif

        _Free();

        #ifdef C_DATABASEOBJECT_TRACE
        logmsg("DatabaseObject::~DatabaseObject() 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 DatabaseObject::BePersistent(
        class Connection *DbCon
        )
{
        RefBase retval;

        #ifdef C_DATABASEOBJECT_TRACE
                logmsg("int DatabaseObject::BePersistent() invoked");
        #endif

        if (IsTransient())
        {
                //Prototype()->_ExportAttributes(this);
                _Connection = DbCon;
                // Insert this object from
                // all prototypes including
                // predecessors
                if (Prototype()->_InsertAll(this))
                {
                        retval = Address();
                        ObjectCache.RegisterObject(retval,this);
                        _MarkAsClean();
                }
                else
                {
                        _Connection = NULL;
        };
        };

        #ifdef C_DATABASEOBJECT_TRACE
                logmsg("int DatabaseObject::BePersistent() finished");
        #endif

        return Address();
        };

---