src/server/Transaction.cxx

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by www.databasecache.com                           *
   3  *   Contact: praba_tuty@databasecache.com                                 *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15   ***************************************************************************/
  16 #include<Transaction.h>
  17 #include<Lock.h>
  18 #include<Database.h>
  19 #include<Allocator.h>
  20 #include<CatalogTables.h>
  21 #include<Debug.h>
  22
  23 DbRetVal Transaction::insertIntoHasList(Database *sysdb, LockHashNode *node)
  24 {
  25     //allocate lock node
  26     Chunk *chunk = sysdb->getSystemDatabaseChunk(TransHasTableId);
  27     TransHasNode *hasNode = (TransHasNode*)chunk->allocate(sysdb);
  28     if (NULL == hasNode)
  29     {
  30         printError(ErrNoMemory, "No memory to allocate Lock node");
  31         return ErrNoMemory;
  32     }
  33     printDebug(DM_Transaction, "insertIntoHasList new TransHasNode created:%x",
  34                                                        hasNode);
  35     hasNode->node_ = node;
  36     hasNode->next_ = NULL;
  37     if (NULL == hasLockList_)
  38     {
  39         printDebug(DM_Transaction, "hasLockList is null:It is now %x",hasNode);
  40         hasLockList_ = hasNode;
  41         return OK;
  42     }
  43
  44     TransHasNode *it = hasLockList_;
  45     while (NULL != it->next_) { it = it->next_; }
  46     it->next_ = hasNode;
  47     printDebug(DM_Transaction, "Added to hasLockList at end:%x",it);
  48     return OK;
  49 }
  50
  51 DbRetVal Transaction::removeFromHasList(Database *sysdb, void *tuple)
  52 {
  53     Chunk *chunk = sysdb->getSystemDatabaseChunk(TransHasTableId);
  54     TransHasNode *iter = hasLockList_, *prev = hasLockList_;
  55     if (NULL == iter)
  56     {
  57         printError(ErrNotFound, "There are no tuple lock in has list.");
  58         return ErrNotFound;
  59     }
  60     while (iter != NULL)
  61     {
  62         if (tuple == iter->node_->ptrToTuple_)
  63         {
  64             prev->next_ = iter->next_;
  65             chunk->free(sysdb, iter);
  66             if (iter == hasLockList_) hasLockList_ = NULL;
  67             return OK;
  68         }
  69         prev = iter;
  70         iter = iter->next_;
  71     }
  72     printError(ErrNotFound, "There are no tuple lock in has list.");
  73     return ErrNotFound;
  74 }
  75
  76
  77 DbRetVal Transaction::releaseAllLocks(LockManager *lockManager_)
  78 {
  79     Database *sysdb =lockManager_->systemDatabase_;
  80     Chunk *chunk = sysdb->getSystemDatabaseChunk(TransHasTableId);
  81     TransHasNode *iter  = hasLockList_, *prev;
  82     while (NULL != iter)
  83     {
  84         prev = iter;
  85         iter = iter->next_;
  86         printDebug(DM_Transaction, "Releasing lock %x",prev->node_->ptrToTuple_);
  87         lockManager_->releaseLock(prev->node_->ptrToTuple_);
  88         chunk->free(sysdb, prev);
  89     }
  90     hasLockList_ = NULL;
  91     return OK;
  92 }
  93 bool Transaction::findInHasList(Database *sysdb, LockHashNode *node)
  94 {
  95     TransHasNode *iter  = hasLockList_;
  96     while (NULL != iter)
  97     {
  98         if (iter->node_ == node) return true;
  99         iter = iter->next_;
 100     }
 101     return false;
 102 }
 103
 104 DbRetVal Transaction::appendUndoLog(Database *sysdb, OperationType type,
 105                                                void *data, size_t size)
 106 {
 107     UndoLogInfo *logInfo = createUndoLog(sysdb, type, data, size);
 108     if (logInfo == NULL) return ErrNoMemory;
 109     os::memcpy((char*)logInfo + sizeof(UndoLogInfo), data, size);
 110     addAtBegin(logInfo);
 111     printDebug(DM_Transaction, "creating undo log and append %x optype:%d",
 112                                                logInfo, type);
 113     return OK;
 114 }
 115
 116
 117
 118 DbRetVal Transaction::appendLogicalUndoLog(Database *sysdb, OperationType type, void *data,
 119                        size_t size, void* indexPtr)
 120 {
 121     UndoLogInfo *logInfo = createUndoLog(sysdb, type, data, size);
 122     if (logInfo == NULL) return ErrNoMemory;
 123     char **indPtr = (char**)((char*)logInfo + sizeof(UndoLogInfo));
 124     *indPtr = (char*)  indexPtr;
 125     addAtBegin(logInfo);
 126     printDebug(DM_Transaction, "creating logical undo log and append %x optype:%d",
 127                                                logInfo, type);
 128     return OK;
 129 }
 130
 131 UndoLogInfo* Transaction::createUndoLog(Database *sysdb, OperationType type, void *data,
 132                        size_t size)
 133 {
 134     Chunk *chunk = sysdb->getSystemDatabaseChunk(UndoLogTableID);
 135     UndoLogInfo *logInfo = (UndoLogInfo*)chunk->allocate(sysdb,
 136                                                 size + sizeof(UndoLogInfo));
 137     if (logInfo == NULL) return NULL;
 138     logInfo->opType_ = type;
 139     logInfo->ptrToTuple_ = data;
 140     logInfo->size_ = size;
 141     logInfo->next_ = NULL;
 142     return logInfo;
 143 }
 144
 145 void Transaction::addAtBegin(UndoLogInfo* logInfo)
 146 {
 147     //add it to the begin of the log list
 148     logInfo->next_ = firstUndoLog_;
 149     firstUndoLog_ = logInfo;
 150     return;
 151 }
 152
 153 UndoLogInfo* Transaction::popUndoLog()
 154 {
 155     UndoLogInfo *iter = firstUndoLog_, *prev = firstUndoLog_;
 156     if(NULL != iter)
 157     {
 158         prev = iter;
 159         iter = iter->next_;
 160     }
 161     firstUndoLog_ = iter;
 162     return prev;
 163
 164 }
 165
 166 int Transaction::noOfUndoLogs()
 167 {
 168     UndoLogInfo *iter = firstUndoLog_;
 169     int count =0;
 170     while(NULL != iter)
 171     {
 172         count++;
 173         iter = iter->next_;
 174     }
 175     return count;
 176 }
 177 void Transaction::printDebugInfo(Database *sysdb)
 178 {
 179    printf("<TransactionInfo>\n");
 180    if (waitLock_ != NULL)
 181    {
 182        printf("<WaitLock>");
 183        waitLock_->print();
 184        printf("</WaitLock>");
 185
 186    }
 187    printf("<UndoLogs>\n");
 188    Chunk *chunk = sysdb->getSystemDatabaseChunk(UndoLogTableID);
 189    printf("  <TotalPages> %d </TotalPages>\n", chunk->totalPages());
 190    UndoLogInfo *iter = firstUndoLog_;
 191    int count =0;
 192    while(NULL != iter)
 193    {
 194       iter->print();
 195       iter = iter->next_;
 196       count++;
 197    }
 198    printf("</TotalNodes> %d </TotalNodes>\n", count);
 199    printf("</UndoLogs>\n");
 200
 201    printf("<TransHasList>\n");
 202    chunk = sysdb->getSystemDatabaseChunk(TransHasTableId);
 203    printf("  <TotalPages> %d </TotalPages>\n", chunk->totalPages());
 204    TransHasNode *hasIter  = hasLockList_;
 205    count =0;
 206    while (NULL != hasIter)
 207    {
 208        hasIter->print();
 209        hasIter = hasIter->next_;
 210        count++;
 211    }
 212    printf("</TotalNodes> %d </TotalNodes>\n", count);
 213    printf("</TransHasList>\n");
 214
 215    printf("</TransactionInfo>\n");
 216    return ;
 217 }
 218 DbRetVal Transaction::removeUndoLogs(Database *sysdb)
 219 {
 220     Chunk *chunk = sysdb->getSystemDatabaseChunk(UndoLogTableID);
 221     UndoLogInfo *logInfo = NULL;
 222     while(NULL != (logInfo = popUndoLog()))
 223     {
 224         chunk->free(sysdb, logInfo);
 225     }
 226     return OK;
 227 }
 228
 229
 230 DbRetVal Transaction::applyUndoLogs(Database *sysdb)
 231 {
 232     Chunk *chunk = sysdb->getSystemDatabaseChunk(UndoLogTableID);
 233     UndoLogInfo *logInfo = NULL;
 234     while(NULL != (logInfo = popUndoLog()))
 235     {
 236         switch(logInfo->opType_)
 237         {
 238                 case InsertOperation:
 239                 *((int*)(logInfo->ptrToTuple_) - 1) = 0;
 240                 //May memcpy is not needed as no one will update this
 241                 //as lock is taken on this tuple
 242                 os::memcpy(logInfo->ptrToTuple_, (char*) logInfo +
 243                             sizeof(UndoLogInfo), logInfo->size_);
 244                 break;
 245                 case DeleteOperation:
 246                 *((int*)(logInfo->ptrToTuple_) - 1) = 1;
 247                 os::memcpy(logInfo->ptrToTuple_, (char*) logInfo +
 248                             sizeof(UndoLogInfo), logInfo->size_);
 249                 break;
 250                 case UpdateOperation:
 251                 os::memcpy(logInfo->ptrToTuple_, (char*) logInfo +
 252                             sizeof(UndoLogInfo), logInfo->size_);
 253                 break;
 254
 255                 case InsertHashIndexOperation:
 256                 //TODO
 257                 break;
 258                 case UpdateHashIndexOperation:
 259                //TODO
 260                break;
 261                 case DeleteHashIndexOperation:
 262                //TODO
 263                break;
 264             }
 265         chunk->free(sysdb, logInfo);
 266     }
 267     return OK;
 268 }