---

cDatabase.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: ... cDatabase.cpp                                               */
/* Module: ...... Database Abstraction Layer                                  */
/*                                                                            */
/******************************************************************************/

// Standard Header(s)
#include <malloc.h>
#include <string.h>

// Common POLiTe Header(s)
#include <lDefs.h>
#include <lTypes.h>
#include <lTrace.h>

// Own Header
#include <cDatabase.h>

// Parent Header(s)

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

extern class ObjectBuffer _ObjectBuffer_;

Connection *Database::_AllConnections[MAX_CONNECTION];
int Database::_FreeAllConnections[MAX_CONNECTION];
int Database::_FirstFreeAllConnection;

bool Database::_FindFreeConnectionHandles(int &LocHandle, int &GlobHandle)
{
  LocHandle = GlobHandle = -1;
  if (_FirstFreeConnection < 0)
         return false;
  if (_FirstFreeAllConnection < 0)
         return false;
  LocHandle = _FirstFreeConnection;
  _FirstFreeConnection = _FreeConnections[_FirstFreeConnection];
  GlobHandle = _FirstFreeAllConnection;
  _FirstFreeAllConnection = _FreeAllConnections[_FirstFreeAllConnection];
  return true;
  };

void Database::_DisposeConnectionHandles(int &LocHandle, int &GlobHandle)
{
  if (LocHandle >= 0) {
         _Connections[LocHandle] = NULL;
         _FreeConnections[LocHandle] = _FirstFreeConnection;
         _FirstFreeConnection = LocHandle;
         };
  if (GlobHandle >= 0) {
         _AllConnections[GlobHandle] = NULL;
         _FreeAllConnections[GlobHandle] = _FirstFreeAllConnection;
         _FirstFreeAllConnection = GlobHandle;
         };
  LocHandle = GlobHandle = -1;
  return;
  }

Database::Database(const char *ConnectString)
//Creates a Database object assigned to a real database
{
        int i;
        #ifdef C_DATABASE_TRACE
                if (ConnectString)
                        logmsg("Database::Database(\"%s\") invoked", ConnectString);
                else
                        logmsg("Database::Database() invoked");
        #endif
        _Strategies = ObjectCache._Strategies;
        _ConnectString = NULL;
        for (i = 0; i < MAX_CONNECTION_PER_DATABASE; i++)
                _Connections[i] = NULL;
        for (i = 0; i < MAX_CONNECTION_PER_DATABASE-1; i++)
                _FreeConnections[i] = (i+1);
        _FreeConnections[MAX_CONNECTION_PER_DATABASE] = -1;
        _FirstFreeConnection = 0;
        if (ConnectString)
                Assign(ConnectString);
};

Database::~Database()
//Database object destructor
{
        int i;
        #ifdef C_DATABASE_TRACE
                logmsg("Database::~Database() invoked");
        #endif
        for (i = 0; i < MAX_CONNECTION_PER_DATABASE; i++)
                if (_Connections[i] != NULL)
                        _Connections[i]->Disconnect();
        StrFree(_ConnectString);
}

bool Database::Assign(const char *ConnectString)
{
        #ifdef C_DATABASE_TRACE
                logmsg("Database::Assign(\"%s\") invoked", ConnectString);
        #endif
        StrCpy(_ConnectString,ConnectString);
        return true;
};

bool Database::Commit()
//Commit all connections on the database, after storing modified objects
{
        int i;
        bool result = true;
        #ifdef C_DATABASE_TRACE
                logmsg("Database::Commit() invoked");
        #endif
        for (i = 0; i < MAX_CONNECTION_PER_DATABASE; i++)
                if (_Connections[i] != NULL)
                        result = result && _Connections[i]->Commit();
        return(result);
};

bool Database::_Commit()
//Commit all connections on the database, none storing of modified objects
{
        int i;
        bool result = true;
        #ifdef C_DATABASE_TRACE
                logmsg("Database::_Commit() invoked");
        #endif
  for (i = 0; i < MAX_CONNECTION_PER_DATABASE; i++)
         if (_Connections[i] != NULL)
                result = result && _Connections[i]->_Commit();
  return(result);
  };

bool Database::Rollback()
//Rollback all connections on the database, then destroy all copies in memory
{
  int i;
  bool result = true;
  #ifdef C_DATABASE_TRACE
         logmsg("Database::Rollback() invoked");
         #endif
  for (i = 0; i < MAX_CONNECTION_PER_DATABASE; i++)
         if (_Connections[i] != NULL)
                result = result && _Connections[i]->Rollback();
  return(result);
  };

bool Database::_Rollback()
//Rollback all connections on the database only
{
  int i;
  bool result = true;
  #ifdef C_DATABASE_TRACE
         logmsg("Database::_Rollback() invoked");
         #endif
  for (i = 0; i < MAX_CONNECTION_PER_DATABASE; i++)
         if (_Connections[i] != NULL)
                result = result && _Connections[i]->_Rollback();
  return(result);
  };

class Connection *Database::Connect(
        const char * const/*UserName*/,
        const char * const/*Password*/)
{
  #ifdef C_DATABASE_TRACE
         logmsg("Database::Connect() invoked");
         #endif
  return(NULL);
};

// Set corresponging patrs of attribute _Strategies
// that holds all concurency strategies
bool Database::SetUpdatingStrategy(enum UpdatingStrategy anUpdatingStrategy)
{
        #ifdef C_DATABASE_TRACE
                logmsg("bool Database::SetUpdatingStrategy(...) invoked");
        #endif
        if (anUpdatingStrategy==US_Current)
                ;
        else if (anUpdatingStrategy==US_Default)
                _Strategies = _Strategies & ~US_MASK | DEFAULT_UPDATING_STRATEGY;
        else
                _Strategies = _Strategies & ~US_MASK | (unsigned int)anUpdatingStrategy;
        #ifdef C_OBJREF_TRACE
                logmsg("bool Database::SetUpdatingStrategy(...) finished");
        #endif
        return true;
};
bool Database::SetWaitingStrategy(enum WaitingStrategy aWaitingStrategy)
{
        #ifdef C_DATABASE_TRACE
                logmsg("bool Database::SetWaitingStrategy(...) invoked");
        #endif
        if (aWaitingStrategy==WS_Current)
                ;
        else if (aWaitingStrategy==WS_Default)
                _Strategies = _Strategies & ~WS_MASK | DEFAULT_WAITING_STRATEGY;
        else
                _Strategies = _Strategies & ~WS_MASK | (unsigned int)aWaitingStrategy;
        #ifdef C_DATABASE_TRACE
                logmsg("bool Database::SetWaitingStrategy(...) finished");
        #endif
        return true;
};
bool Database::SetLockingStrategy(enum LockingStrategy aLockingStrategy)
{
        #ifdef C_DATABASE_TRACE
                logmsg("bool Database::SetLockingStrategy(...) invoked");
        #endif
        if (aLockingStrategy==LS_Current)
                ;
        else if (aLockingStrategy==LS_Default)
                _Strategies = _Strategies & ~LS_MASK | DEFAULT_LOCKING_STRATEGY;
        else
                _Strategies = _Strategies & ~LS_MASK | (unsigned int)aLockingStrategy;
        #ifdef C_DATABASE_TRACE
                logmsg("bool Database::SetLockingStrategy(...) finished");
        #endif
        return true;
};
bool Database::SetReadingStrategy(enum ReadingStrategy aReadingStrategy)
{
        #ifdef C_DATABASE_TRACE
                logmsg("bool Database::SetReadingStrategy(...) invoked");
        #endif
        if (aReadingStrategy==RS_Current)
                ;
        else if (aReadingStrategy==RS_Default)
                _Strategies = _Strategies & ~RS_MASK | DEFAULT_READING_STRATEGY;
        else
                _Strategies = _Strategies & ~RS_MASK | (unsigned int)aReadingStrategy;
        #ifdef C_DATABASE_TRACE
                logmsg("bool Database::SetReadingStrategy(...) finished");
        #endif
        return true;
};

---