---

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

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

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

// Own Header
#include <cConnection.h>

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

Connection::Connection(
                        Database *DB,
                        const char *UserName,
                        const char *Password,
                        const int LocHandle,
                        const int GlobHandle
                        )
//Creates a new database connection
{
  #ifdef C_CONNECTION_TRACE
         logmsg("Connection::Connection() invoked");
         #endif
  _Database = DB;
  StrCpy(_UserName = NULL, UserName);
  StrCpy(_Password = NULL, Password);
  _LocalHandle = LocHandle;
  _Handle = GlobHandle;
  _DefaultCursor = NULL;
  };

Connection::~Connection()
//Connection object destructor
{
  #ifdef C_CONNECTION_TRACE
         logmsg("Connection::~Connection() invoked");
         #endif
  if (_Database != NULL) {
         if (_DefaultCursor != NULL)
            delete _DefaultCursor;
         Disconnect();
         };
  }

bool Connection::Sql(const char * SqlCommand)
{
        #ifdef C_CONNECTION_TRACE
                logmsg("Connection::Sql(\"%s\") invoked", SqlCommand);
        #endif
        if (!ObjectCache.UpdateAll(this))
                return(false);
        return(_Sql(SqlCommand));
};

bool Connection::Commit()
//Commit database, after storing modified objects
{
        #ifdef C_CONNECTION_TRACE
                logmsg("Connection::Commit() invoked");
        #endif
        ObjectCache._ResetForUpdateFlags = true;
        // commit has to reset this _ForUpdate flag in object
        // because database locks on objects will be released
        if (!ObjectCache.UpdateAll(this))
        {
                ObjectCache._ResetForUpdateFlags = false;
                return(false);
        };
        ObjectCache._ResetForUpdateFlags = false;
        return(_Commit());
};

bool Connection::Rollback()
//Rollback database, then destroy all copies in memory
{
        #ifdef C_CONNECTION_TRACE
                logmsg("Connection::Rollback() invoked");
        #endif
        if (!_Rollback())
                return(false);
        return(ObjectCache._RemoveAll(this));
};

bool Connection::Savepoint(const char * const Name)
//Create savepoint, after storing all modified objects
{
        #ifdef C_CONNECTION_TRACE
                logmsg("Connection::Savepoint(\"%s\") invoked",Name);
        #endif
        if (!ObjectCache.UpdateAll(this))
                return(false);
        return(_Savepoint(Name));
};

bool Connection::RollbackToSavepoint(const char * const Name)
//Rollback to savepoint, then destroy all data in memory
{
        #ifdef C_CONNECTION_TRACE
                logmsg("Connection::RollbackToSavepoint(\"%s\") invoked",Name);
        #endif
        if (!_RollbackToSavepoint(Name))
                return(false);
        return(ObjectCache._RemoveAll(this));
};

bool Connection::Disconnect()
//Commit work and disconnect from database
{
        #ifdef C_CONNECTION_TRACE
                logmsg("Connection::Disconnect() invoked");
        #endif
        _Database->_DisposeConnectionHandles(_LocalHandle,_Handle);
        _Database = NULL;
        StrFree(_UserName);
        StrFree(_Password);
        free(this);
        return(true);
};

bool Connection::Abort()
//Rollback work and disconnect from database
{
        #ifdef C_CONNECTION_TRACE
                logmsg("Connection::Abort() invoked");
        #endif
        _Database->_DisposeConnectionHandles(_LocalHandle,_Handle);
        _Database = NULL;
        StrFree(_UserName);
        StrFree(_Password);
        free(this);
        return(true);
};

Connection &Connection::operator << (
                        const char * const SqlCommand
                        )
{
        (void)Sql(SqlCommand);
        return *this;
};

Connection &Connection::operator << (
        const class Cmd &Command
        )
{
        (void)Command.ExecuteCommand(*this);
        return(*this);
};

bool Connection::operator == (
        const class Connection &DbConn
        ) const
//Tests, if the Database connections are the same
{
        return (this == &DbConn);
};

bool Connection::operator != (
        const class Connection &DbConn
        ) const
//Tests, if the Database connections are not the same
{
        return (this != &DbConn);
};

bool Connection::_Open()
{
        return _DefaultCursor->_Open();
};

bool Connection::_Prepare(const char *SqlCommand)
{
        return _DefaultCursor->_Prepare(SqlCommand);
};

bool Connection::_PreExecBind(
        const char *const VarName,
        const void *VarAddr,
        const int VarLen,
        const char VarType,
        const short *VarInd
        )
{
        return _DefaultCursor->_PreExecBind(VarName,VarAddr,VarLen,VarType,VarInd);
};

bool Connection::_Execute()
{
        return _DefaultCursor->_Execute();
};

bool Connection::_PreFetchBind(
        const int Position,
        const void *VarAddr,
        const int VarLen,
        const char VarType,
        const short *VarInd
        )
{
        return _DefaultCursor->_PreFetchBind(Position,VarAddr,VarLen,VarType,VarInd);
};

bool Connection::_FetchNext()
{
        return _DefaultCursor->_FetchNext();
};

bool Connection::_FetchPrev()
{
        return _DefaultCursor->_FetchPrev();
};

bool Connection::_Close()
{
        return _DefaultCursor->_Close();
};

// Set corresponging patrs of attribute _Strategies
// that holds all concurency strategies
bool Connection::SetUpdatingStrategy(enum UpdatingStrategy anUpdatingStrategy)
{
        #ifdef C_CONNECTION_TRACE
                logmsg("bool Connection::SetUpdatingStrategy(...) invoked");
        #endif
        switch (anUpdatingStrategy)
        {
                case US_Current:
                        break;
                case US_Inherited:
                        _Strategies = _Strategies & ~US_MASK | (unsigned int)_Database->CurrentUpdatingStrategy();
                        break;
                case US_Default:
                        _Strategies = _Strategies & ~US_MASK | DEFAULT_UPDATING_STRATEGY;
                        break;
                default:
                        _Strategies = _Strategies & ~US_MASK | (unsigned int)anUpdatingStrategy;
        };
        #ifdef C_OBJREF_TRACE
                logmsg("bool Connection::SetUpdatingStrategy(...) finished");
        #endif
        return true;
};
bool Connection::SetWaitingStrategy(enum WaitingStrategy aWaitingStrategy)
{
        #ifdef C_CONNECTION_TRACE
                logmsg("bool Connection::SetWaitingStrategy(...) invoked");
        #endif
        switch (aWaitingStrategy)
        {
                case WS_Current:
                        break;
                case WS_Inherited:
                        _Strategies = _Strategies & ~WS_MASK | (unsigned int)_Database->CurrentWaitingStrategy();
                        break;
                case WS_Default:
                        _Strategies = _Strategies & ~WS_MASK | DEFAULT_WAITING_STRATEGY;
                        break;
                default:
                        _Strategies = _Strategies & ~WS_MASK | (unsigned int)aWaitingStrategy;
        };
        #ifdef C_CONNECTION_TRACE
                logmsg("bool Connection::SetWaitingStrategy(...) finished");
        #endif
        return true;
};
bool Connection::SetLockingStrategy(enum LockingStrategy aLockingStrategy)
{
        #ifdef C_CONNECTION_TRACE
                logmsg("bool Connection::SetLockingStrategy(...) invoked");
        #endif
        switch (aLockingStrategy)
        {
                case LS_Current:
                        break;
                case LS_Inherited:
                        _Strategies = _Strategies & ~LS_MASK | (unsigned int)_Database->CurrentLockingStrategy();
                        break;
                case LS_Default:
                        _Strategies = _Strategies & ~LS_MASK | DEFAULT_LOCKING_STRATEGY;
                        break;
                default:
                        _Strategies = _Strategies & ~LS_MASK | (unsigned int)aLockingStrategy;
        };
        #ifdef C_CONNECTION_TRACE
                logmsg("bool Connection::SetLockingStrategy(...) finished");
        #endif
        return true;
};
bool Connection::SetReadingStrategy(enum ReadingStrategy aReadingStrategy)
{
        #ifdef C_CONNECTION_TRACE
                logmsg("bool Connection::SetReadingStrategy(...) invoked");
        #endif
        switch (aReadingStrategy)
        {
                case RS_Current:
                        break;
                case RS_Inherited:
                        _Strategies = _Strategies & ~RS_MASK | (unsigned int)_Database->CurrentReadingStrategy();
                        break;
                case RS_Default:
                        _Strategies = _Strategies & ~RS_MASK | DEFAULT_READING_STRATEGY;
                        break;
                default:
                        _Strategies = _Strategies & ~RS_MASK | (unsigned int)aReadingStrategy;
        };
        #ifdef C_CONNECTION_TRACE
                logmsg("bool Connection::SetReadingStrategy(...) finished");
        #endif
        return true;
};

---