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     DbRetVal rv = OK;
  28     TransHasNode *hasNode = (TransHasNode*)chunk->allocate(sysdb, &rv);
  29     if (NULL == hasNode)
  30     {
  31         printError(rv, "Could not allocate Lock node");
  32         return rv;
  33     }
  34     printDebug(DM_Transaction, "insertIntoHasList new TransHasNode created:%x",
  35                                                        hasNode);
  36     hasNode->node_ = node;
  37     hasNode->next_ = NULL;
  38     if (NULL == hasLockList_)
  39     {
  40         printDebug(DM_Transaction, "hasLockList is null:It is now %x",hasNode);
  41         hasLockList_ = hasNode;
  42         return OK;
  43     }
  44
  45     TransHasNode *it = hasLockList_;
  46     while (NULL != it->next_) { it = it->next_; }
  47     it->next_ = hasNode;
  48     printDebug(DM_Transaction, "Added to hasLockList at end:%x",it);
  49     return OK;
  50 }
  51
  52 DbRetVal Transaction::removeFromHasList(Database *sysdb, void *tuple)
  53 {
  54     Chunk *chunk = sysdb->getSystemDatabaseChunk(TransHasTableId);
  55     TransHasNode *iter = hasLockList_, *prev = hasLockList_;
  56     if (NULL == iter)
  57     {
  58         printError(ErrNotFound, "There are no tuple lock in has list.");
  59         return ErrNotFound;
  60     }
  61     while (iter != NULL)
  62     {
  63         if (tuple == iter->node_->ptrToTuple_)
  64         {
  65             prev->next_ = iter->next_;
  66             chunk->free(sysdb, iter);
  67             if (iter == hasLockList_) hasLockList_ = NULL;
  68             return OK;
  69         }
  70         prev = iter;
  71         iter = iter->next_;
  72     }
  73     printError(ErrNotFound, "There are no tuple lock in has list.");
  74     return ErrNotFound;
  75 }
  76
  77
  78 DbRetVal Transaction::releaseAllLocks(LockManager *lockManager_)
  79 {
  80     Database *sysdb =lockManager_->systemDatabase_;
  81     Chunk *chunk = sysdb->getSystemDatabaseChunk(TransHasTableId);
  82     TransHasNode *iter  = hasLockList_, *prev;
  83     while (NULL != iter)
  84     {
  85         prev = iter;
  86         iter = iter->next_;
  87         printDebug(DM_Transaction, "Releasing lock %x",prev->node_->ptrToTuple_);
  88         lockManager_->releaseLock(prev->node_->ptrToTuple_);
  89         chunk->free(sysdb, prev);
  90     }
  91     hasLockList_ = NULL;
  92     return OK;
  93 }
  94 bool Transaction::findInHasList(Database *sysdb, LockHashNode *node)
  95 {
  96     TransHasNode *iter  = hasLockList_;
  97     while (NULL != iter)
  98     {
  99         if (iter->node_ == node) return true;
 100         iter = iter->next_;
 101     }
 102     return false;
 103 }
 104
 105 DbRetVal Transaction::appendUndoLog(Database *sysdb, OperationType type,
 106                                                void *data, size_t size)
 107 {
 108     DbRetVal rv =OK;
 109     UndoLogInfo *logInfo = createUndoLog(sysdb, type, data, size, &rv);
 110     if (logInfo == NULL) return rv;
 111     os::memcpy((char*)logInfo + sizeof(UndoLogInfo), data, size);
 112     addAtBegin(logInfo);
 113     printDebug(DM_Transaction, "creating undo log and append %x optype:%d",
 114                                                logInfo, type);
 115     return OK;
 116 }
 117
 118
 119
 120 DbRetVal Transaction::appendLogicalUndoLog(Database *sysdb, OperationType type, void *data,
 121                        size_t size, void* indexPtr)
 122 {
 123     DbRetVal rv = OK;
 124     UndoLogInfo *logInfo = createUndoLog(sysdb, type, data, size, &rv);
 125     if (logInfo == NULL) return rv;
 126     char **indPtr = (char**)((char*)logInfo + sizeof(UndoLogInfo));
 127     *indPtr = (char*)  indexPtr;
 128     addAtBegin(logInfo);
 129     printDebug(DM_Transaction, "creating logical undo log and append %x optype:%d",
 130                                                logInfo, type);
 131     return rv;
 132 }
 133
 134 UndoLogInfo* Transaction::createUndoLog(Database *sysdb, OperationType type, void *data,
 135                        size_t size, DbRetVal *rv)
 136 {
 137     Chunk *chunk = sysdb->getSystemDatabaseChunk(UndoLogTableID);
 138     UndoLogInfo *logInfo = (UndoLogInfo*)chunk->allocate(sysdb,
 139                                                 size + sizeof(UndoLogInfo), rv);
 140     if (logInfo == NULL) {
 141         printError(*rv, "Unable to allocate undo log record\n");
 142         return NULL;
 143     }
 144     logInfo->opType_ = type;
 145     logInfo->ptrToTuple_ = data;
 146     logInfo->size_ = size;
 147     logInfo->next_ = NULL;
 148     return logInfo;
 149 }
 150
 151 void Transaction::addAtBegin(UndoLogInfo* logInfo)
 152 {
 153     //add it to the begin of the log list
 154     logInfo->next_ = firstUndoLog_;
 155     firstUndoLog_ = logInfo;
 156     return;
 157 }
 158
 159 UndoLogInfo* Transaction::popUndoLog()
 160 {
 161     UndoLogInfo *iter = firstUndoLog_, *prev = firstUndoLog_;
 162     if(NULL != iter)
 163     {
 164         prev = iter;
 165         iter = iter->next_;
 166     }
 167     firstUndoLog_ = iter;
 168     return prev;
 169
 170 }
 171
 172 int Transaction::noOfUndoLogs()
 173 {
 174     UndoLogInfo *iter = firstUndoLog_;
 175     int count =0;
 176     while(NULL != iter)
 177     {
 178         count++;
 179         iter = iter->next_;
 180     }
 181     return count;
 182 }
 183 void Transaction::printDebugInfo(Database *sysdb)
 184 {
 185    printf("<TransactionInfo>\n");
 186    if (waitLock_ != NULL)
 187    {
 188        printf("<WaitLock>");
 189        waitLock_->print();
 190        printf("</WaitLock>");
 191
 192    }
 193    printf("<UndoLogs>\n");
 194    Chunk *chunk = sysdb->getSystemDatabaseChunk(UndoLogTableID);
 195    printf("  <TotalPages> %d </TotalPages>\n", chunk->totalPages());
 196    UndoLogInfo *iter = firstUndoLog_;
 197    int count =0;
 198    while(NULL != iter)
 199    {
 200       iter->print();
 201       iter = iter->next_;
 202       count++;
 203    }
 204    printf("</TotalNodes> %d </TotalNodes>\n", count);
 205    printf("</UndoLogs>\n");
 206
 207    printf("<TransHasList>\n");
 208    chunk = sysdb->getSystemDatabaseChunk(TransHasTableId);
 209    printf("  <TotalPages> %d </TotalPages>\n", chunk->totalPages());
 210    TransHasNode *hasIter  = hasLockList_;
 211    count =0;
 212    while (NULL != hasIter)
 213    {
 214        hasIter->print();
 215        hasIter = hasIter->next_;
 216        count++;
 217    }
 218    printf("</TotalNodes> %d </TotalNodes>\n", count);
 219    printf("</TransHasList>\n");
 220
 221    printf("</TransactionInfo>\n");
 222    return ;
 223 }
 224 DbRetVal Transaction::removeUndoLogs(Database *sysdb)
 225 {
 226     Chunk *chunk = sysdb->getSystemDatabaseChunk(UndoLogTableID);
 227     UndoLogInfo *logInfo = NULL;
 228     while(NULL != (logInfo = popUndoLog()))
 229     {
 230         chunk->free(sysdb, logInfo);
 231     }
 232     return OK;
 233 }
 234
 235
 236 DbRetVal Transaction::applyUndoLogs(Database *sysdb)
 237 {
 238     Chunk *chunk = sysdb->getSystemDatabaseChunk(UndoLogTableID);
 239     UndoLogInfo *logInfo = NULL;
 240     while(NULL != (logInfo = popUndoLog()))
 241     {
 242         switch(logInfo->opType_)
 243         {
 244                 case InsertOperation:
 245                 *((int*)(logInfo->ptrToTuple_) - 1) = 0;
 246                 //May memcpy is not needed as no one will update this
 247                 //as lock is taken on this tuple
 248                 os::memcpy(logInfo->ptrToTuple_, (char*) logInfo +
 249                             sizeof(UndoLogInfo), logInfo->size_);
 250                 break;
 251                 case DeleteOperation:
 252                 *((int*)(logInfo->ptrToTuple_) - 1) = 1;
 253                 os::memcpy(logInfo->ptrToTuple_, (char*) logInfo +
 254                             sizeof(UndoLogInfo), logInfo->size_);
 255                 break;
 256                 case UpdateOperation:
 257                 os::memcpy(logInfo->ptrToTuple_, (char*) logInfo +
 258                             sizeof(UndoLogInfo), logInfo->size_);
 259                 break;
 260
 261                 case InsertHashIndexOperation:
 262                 //TODO
 263                 break;
 264                 case UpdateHashIndexOperation:
 265                //TODO
 266                break;
 267                 case DeleteHashIndexOperation:
 268                //TODO
 269                break;
 270             }
 271         chunk->free(sysdb, logInfo);
 272     }
 273     return OK;
 274 }