Transaction Class Reference

#include <Transaction.h>

Collaboration diagram for Transaction:

[legend]

Public Member Functions
DbRetVal	releaseAllLocks (LockManager *lockManager_)
void	updateWaitLock (LockHashNode *node)
void	removeWaitLock ()
DbRetVal	insertIntoHasList (Database *sysdb, LockHashNode *node)
DbRetVal	removeFromHasList (Database *sysdb, void *tuple)
bool	findInHasList (Database *sysdb, LockHashNode *node)
DbRetVal	appendUndoLog (Database *sysdb, OperationType type, void *data, size_t size)
DbRetVal	appendLogicalUndoLog (Database *sysdb, OperationType type, void *data, size_t size, void *indexPtr)
UndoLogInfo *	createUndoLog (Database *sysdb, OperationType type, void *data, size_t size, DbRetVal *rv)
void	addAtBegin (UndoLogInfo *logInfo)
UndoLogInfo *	popUndoLog ()
DbRetVal	removeUndoLogs (Database *sysdb)
DbRetVal	applyUndoLogs (Database *sysdb)
int	noOfUndoLogs ()
void	printDebugInfo (Database *sysdb)
Data Fields
int	status_
IsolationLevel	isoLevel_
TransHasNode *	hasLockList_
UndoLogInfo *	firstUndoLog_
LockHashNode *	waitLock_

---

Detailed Description

Definition at line 61 of file Transaction.h.

---

Member Function Documentation

void Transaction::addAtBegin

(

UndoLogInfo *

logInfo

)

Definition at line 148 of file Transaction.cxx.

References firstUndoLog_, and UndoLogInfo::next_.

Referenced by appendLogicalUndoLog(), and appendUndoLog().

{
    //add it to the begin of the log list
    logInfo->next_ = firstUndoLog_;
    firstUndoLog_ = logInfo;
    return;
}

Here is the caller graph for this function:

DbRetVal Transaction::appendLogicalUndoLog	(	Database *	sysdb,
		OperationType	type,
		void *	data,
		size_t	size,
		void *	indexPtr
	)

Definition at line 120 of file Transaction.cxx.

References addAtBegin(), createUndoLog(), DM_Transaction, OK, and printDebug.

Referenced by HashIndex::insert(), HashIndex::remove(), and HashIndex::update().

{
    DbRetVal rv = OK;
    UndoLogInfo *logInfo = createUndoLog(sysdb, type, data, size, &rv);
    if (logInfo == NULL) return rv;
    char **indPtr = (char**)((char*)logInfo + sizeof(UndoLogInfo));
    *indPtr = (char*)  indexPtr;
    addAtBegin(logInfo);
    printDebug(DM_Transaction, "creating logical undo log and append %x optype:%d",
                                               logInfo, type);
    return rv;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DbRetVal Transaction::appendUndoLog	(	Database *	sysdb,
		OperationType	type,
		void *	data,
		size_t	size
	)

Definition at line 105 of file Transaction.cxx.

References addAtBegin(), createUndoLog(), DM_Transaction, os::memcpy(), OK, and printDebug.

{
    DbRetVal rv =OK;
    UndoLogInfo *logInfo = createUndoLog(sysdb, type, data, size, &rv);
    if (logInfo == NULL) return rv;
    os::memcpy((char*)logInfo + sizeof(UndoLogInfo), data, size);
    addAtBegin(logInfo);
    printDebug(DM_Transaction, "creating undo log and append %x optype:%d",
                                               logInfo, type);
    return OK;
}

Here is the call graph for this function:

DbRetVal Transaction::applyUndoLogs

(

Database *

sysdb

)

Definition at line 233 of file Transaction.cxx.

References DeleteHashIndexOperation, DeleteOperation, Chunk::free(), Database::getSystemDatabaseChunk(), InsertHashIndexOperation, InsertOperation, os::memcpy(), OK, UndoLogInfo::opType_, popUndoLog(), UndoLogInfo::ptrToTuple_, UndoLogInfo::size_, UndoLogTableID, UpdateHashIndexOperation, and UpdateOperation.

Referenced by TransactionManager::rollback().

{
    Chunk *chunk = sysdb->getSystemDatabaseChunk(UndoLogTableID);
    UndoLogInfo *logInfo = NULL;
    while(NULL != (logInfo = popUndoLog()))
    {
        switch(logInfo->opType_)
        {
                case InsertOperation:
                *((int*)(logInfo->ptrToTuple_) - 1) = 0;
                //May memcpy is not needed as no one will update this
                //as lock is taken on this tuple
                os::memcpy(logInfo->ptrToTuple_, (char*) logInfo +
                            sizeof(UndoLogInfo), logInfo->size_);
                break;
                case DeleteOperation:
                *((int*)(logInfo->ptrToTuple_) - 1) = 1;
                os::memcpy(logInfo->ptrToTuple_, (char*) logInfo +
                            sizeof(UndoLogInfo), logInfo->size_);
                break;
                case UpdateOperation:
                os::memcpy(logInfo->ptrToTuple_, (char*) logInfo +
                            sizeof(UndoLogInfo), logInfo->size_);
                break;

                case InsertHashIndexOperation:
                //TODO
                break;
                case UpdateHashIndexOperation:
               //TODO
               break;
                case DeleteHashIndexOperation:
               //TODO
               break;
            }
        chunk->free(sysdb, logInfo);
    }
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

UndoLogInfo * Transaction::createUndoLog	(	Database *	sysdb,
		OperationType	type,
		void *	data,
		size_t	size,
		DbRetVal *	rv
	)

Definition at line 134 of file Transaction.cxx.

References Chunk::allocate(), Database::getSystemDatabaseChunk(), UndoLogInfo::next_, UndoLogInfo::opType_, UndoLogInfo::ptrToTuple_, UndoLogInfo::size_, and UndoLogTableID.

Referenced by appendLogicalUndoLog(), and appendUndoLog().

{
    Chunk *chunk = sysdb->getSystemDatabaseChunk(UndoLogTableID);
    UndoLogInfo *logInfo = (UndoLogInfo*)chunk->allocate(sysdb,
                                                size + sizeof(UndoLogInfo), rv);
    if (logInfo == NULL) return NULL;
    logInfo->opType_ = type;
    logInfo->ptrToTuple_ = data;
    logInfo->size_ = size;
    logInfo->next_ = NULL;
    return logInfo;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Transaction::findInHasList	(	Database *	sysdb,
		LockHashNode *	node
	)

Definition at line 94 of file Transaction.cxx.

References hasLockList_, TransHasNode::next_, and TransHasNode::node_.

Referenced by LockManager::getExclusiveLock(), LockManager::getSharedLock(), and LockManager::isExclusiveLocked().

{
    TransHasNode *iter  = hasLockList_;
    while (NULL != iter)
    {
        if (iter->node_ == node) return true;
        iter = iter->next_;
    }
    return false;
}

Here is the caller graph for this function:

DbRetVal Transaction::insertIntoHasList	(	Database *	sysdb,
		LockHashNode *	node
	)

Definition at line 23 of file Transaction.cxx.

References Chunk::allocate(), DM_Transaction, Database::getSystemDatabaseChunk(), hasLockList_, TransHasNode::next_, TransHasNode::node_, OK, printDebug, printError, and TransHasTableId.

{
    //allocate lock node
    Chunk *chunk = sysdb->getSystemDatabaseChunk(TransHasTableId);
    DbRetVal rv = OK;
    TransHasNode *hasNode = (TransHasNode*)chunk->allocate(sysdb, &rv);
    if (NULL == hasNode)
    {
        printError(rv, "Could not allocate Lock node");
        return rv;
    }
    printDebug(DM_Transaction, "insertIntoHasList new TransHasNode created:%x",
                                                       hasNode);
    hasNode->node_ = node;
    hasNode->next_ = NULL;
    if (NULL == hasLockList_)
    {
        printDebug(DM_Transaction, "hasLockList is null:It is now %x",hasNode);
        hasLockList_ = hasNode;
        return OK;
    }

    TransHasNode *it = hasLockList_;
    while (NULL != it->next_) { it = it->next_; }
    it->next_ = hasNode;
    printDebug(DM_Transaction, "Added to hasLockList at end:%x",it);
    return OK;
}

Here is the call graph for this function:

int Transaction::noOfUndoLogs

(

)

Definition at line 169 of file Transaction.cxx.

References firstUndoLog_, and UndoLogInfo::next_.

Referenced by TransactionManager::printDebugInfo(), and TransactionManager::printUsageStatistics().

{
    UndoLogInfo *iter = firstUndoLog_;
    int count =0;
    while(NULL != iter)
    {
        count++;
        iter = iter->next_;
    }
    return count;
}

Here is the caller graph for this function:

UndoLogInfo * Transaction::popUndoLog

(

)

Definition at line 156 of file Transaction.cxx.

References firstUndoLog_, and UndoLogInfo::next_.

Referenced by applyUndoLogs(), and removeUndoLogs().

{
    UndoLogInfo *iter = firstUndoLog_, *prev = firstUndoLog_;
    if(NULL != iter)
    {
        prev = iter;
        iter = iter->next_;
    }
    firstUndoLog_ = iter;
    return prev;

}

Here is the caller graph for this function:

void Transaction::printDebugInfo

(

Database *

sysdb

)

Definition at line 180 of file Transaction.cxx.

References firstUndoLog_, Database::getSystemDatabaseChunk(), hasLockList_, TransHasNode::print(), UndoLogInfo::print(), LockHashNode::print(), Chunk::totalPages(), TransHasTableId, UndoLogTableID, and waitLock_.

Referenced by TransactionManager::printDebugInfo().

{
   printf("<TransactionInfo>\n");
   if (waitLock_ != NULL) 
   {
       printf("<WaitLock>");
       waitLock_->print();
       printf("</WaitLock>");

   }
   printf("<UndoLogs>\n");
   Chunk *chunk = sysdb->getSystemDatabaseChunk(UndoLogTableID);
   printf("  <TotalPages> %d </TotalPages>\n", chunk->totalPages());
   UndoLogInfo *iter = firstUndoLog_;
   int count =0;
   while(NULL != iter)
   {
      iter->print();
      iter = iter->next_;
      count++;
   }
   printf("</TotalNodes> %d </TotalNodes>\n", count);
   printf("</UndoLogs>\n");

   printf("<TransHasList>\n");
   chunk = sysdb->getSystemDatabaseChunk(TransHasTableId);
   printf("  <TotalPages> %d </TotalPages>\n", chunk->totalPages());
   TransHasNode *hasIter  = hasLockList_;
   count =0;
   while (NULL != hasIter)
   {
       hasIter->print();
       hasIter = hasIter->next_;
       count++;
   }
   printf("</TotalNodes> %d </TotalNodes>\n", count);
   printf("</TransHasList>\n");

   printf("</TransactionInfo>\n");
   return ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DbRetVal Transaction::releaseAllLocks

(

LockManager *

lockManager_

)

Definition at line 78 of file Transaction.cxx.

References DM_Transaction, Chunk::free(), Database::getSystemDatabaseChunk(), hasLockList_, TransHasNode::next_, OK, printDebug, LockManager::releaseLock(), LockManager::systemDatabase_, and TransHasTableId.

Referenced by TransactionManager::commit(), and TransactionManager::rollback().

{
    Database *sysdb =lockManager_->systemDatabase_;
    Chunk *chunk = sysdb->getSystemDatabaseChunk(TransHasTableId);
    TransHasNode *iter  = hasLockList_, *prev;
    while (NULL != iter)
    {
        prev = iter;
        iter = iter->next_;
        printDebug(DM_Transaction, "Releasing lock %x",prev->node_->ptrToTuple_);
        lockManager_->releaseLock(prev->node_->ptrToTuple_);
        chunk->free(sysdb, prev);
    }
    hasLockList_ = NULL;
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DbRetVal Transaction::removeFromHasList	(	Database *	sysdb,
		void *	tuple
	)

Definition at line 52 of file Transaction.cxx.

References ErrNotFound, Chunk::free(), Database::getSystemDatabaseChunk(), hasLockList_, TransHasNode::next_, TransHasNode::node_, OK, printError, LockHashNode::ptrToTuple_, and TransHasTableId.

{
    Chunk *chunk = sysdb->getSystemDatabaseChunk(TransHasTableId);
    TransHasNode *iter = hasLockList_, *prev = hasLockList_;
    if (NULL == iter)
    {
        printError(ErrNotFound, "There are no tuple lock in has list.");
        return ErrNotFound;
    }
    while (iter != NULL)
    {
        if (tuple == iter->node_->ptrToTuple_)
        {
            prev->next_ = iter->next_;
            chunk->free(sysdb, iter);
            if (iter == hasLockList_) hasLockList_ = NULL;
            return OK;
        }
        prev = iter;
        iter = iter->next_;
    }
    printError(ErrNotFound, "There are no tuple lock in has list.");
    return ErrNotFound;
}

Here is the call graph for this function:

DbRetVal Transaction::removeUndoLogs

(

Database *

sysdb

)

Definition at line 221 of file Transaction.cxx.

References Chunk::free(), Database::getSystemDatabaseChunk(), OK, popUndoLog(), and UndoLogTableID.

Referenced by TransactionManager::commit().

{
    Chunk *chunk = sysdb->getSystemDatabaseChunk(UndoLogTableID);
    UndoLogInfo *logInfo = NULL;
    while(NULL != (logInfo = popUndoLog()))
    {
        chunk->free(sysdb, logInfo);
    }
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Transaction::removeWaitLock

(

)

[inline]

Definition at line 77 of file Transaction.h.

References waitLock_.

{ waitLock_ = NULL; }

void Transaction::updateWaitLock

(

LockHashNode *

node

)

[inline]

Definition at line 76 of file Transaction.h.

References waitLock_.

{ waitLock_ = node; }

---

Field Documentation

UndoLogInfo* Transaction::firstUndoLog_

Definition at line 70 of file Transaction.h.

Referenced by addAtBegin(), noOfUndoLogs(), popUndoLog(), and printDebugInfo().

TransHasNode* Transaction::hasLockList_

Definition at line 68 of file Transaction.h.

Referenced by findInHasList(), insertIntoHasList(), printDebugInfo(), releaseAllLocks(), and removeFromHasList().

IsolationLevel Transaction::isoLevel_

Definition at line 66 of file Transaction.h.

Referenced by TransactionManager::startTransaction().

int Transaction::status_

Definition at line 64 of file Transaction.h.

Referenced by TransactionManager::commit(), ProcessManager::deregisterThread(), TransactionManager::printDebugInfo(), TransactionManager::printUsageStatistics(), TransactionManager::rollback(), and TransactionManager::startTransaction().

LockHashNode* Transaction::waitLock_

Definition at line 72 of file Transaction.h.

Referenced by TransactionManager::commit(), printDebugInfo(), removeWaitLock(), TransactionManager::rollback(), and updateWaitLock().

---

The documentation for this class was generated from the following files:

• include/Transaction.h
• src/server/Transaction.cxx

---