src/server/Database.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<Database.h>
  17 #include<os.h>
  18 #include<CatalogTables.h>
  19 #include<Transaction.h>
  20 #include<Lock.h>
  21 #include<Debug.h>
  22 #include<Config.h>
  23 #include<Process.h>
  24
  25 const char* Database::getName()
  26 {
  27     return metaData_->dbName_;
  28 }
  29
  30 int Database::getDatabaseID()
  31 {
  32     return metaData_->dbID_;
  33 }
  34
  35 size_t Database::getMaxSize()
  36 {
  37     return metaData_->maxSize_;
  38 }
  39
  40 size_t Database::getCurrentSize()
  41 {
  42     return metaData_->curSize_;
  43
  44 }
  45 Page* Database::getCurrentPage()
  46 {
  47     return metaData_->curPage_;
  48
  49 }
  50 Page* Database::getFirstPage()
  51 {
  52     return metaData_->firstPage_;
  53
  54 }
  55 int Database::getMaxChunks()
  56 {
  57     return metaData_->maxChunks_;
  58 }
  59 Chunk* Database::getHashIndexChunk()
  60 {
  61     return metaData_->hashIndexChunk_;
  62 }
  63
  64 void Database::setDatabaseID(int id)
  65 {
  66     metaData_->dbID_ = id;
  67 }
  68 void Database::setName(const char *name)
  69 {
  70     strcpy(metaData_->dbName_ , name);
  71 }
  72 void Database::setCurrentSize(size_t size)
  73 {
  74     metaData_->curSize_ = size;
  75 }
  76 void Database::setCurrentPage(Page *page)
  77 {
  78     metaData_->curPage_ = page;
  79 }
  80 void Database::setFirstPage(Page *page)
  81 {
  82     metaData_->firstPage_ = page;
  83 }
  84 void Database::setMaxSize(size_t size)
  85 {
  86     metaData_->maxSize_ = size;
  87 }
  88 void Database::setMaxChunks(int chunks)
  89 {
  90     metaData_->maxChunks_ = chunks;
  91 }
  92 void Database::setHashIndexChunk(Chunk *ch)
  93 {
  94     metaData_->hashIndexChunk_ = ch;
  95 }
  96
  97
  98 int Database::initAllocDatabaseMutex()
  99 {
 100     return metaData_->dbAllocMutex_.init();
 101 }
 102 DbRetVal Database::getAllocDatabaseMutex()
 103 {
 104     int ret= metaData_->dbAllocMutex_.tryLock();
 105     if (ret) return ErrSysInternal; else return OK;
 106 }
 107 DbRetVal Database::releaseAllocDatabaseMutex()
 108 {
 109     metaData_->dbAllocMutex_.releaseLock();
 110     return OK;
 111 }
 112
 113
 114
 115 int Database::initTransTableMutex()
 116 {
 117     return metaData_->dbTransTableMutex_.init();
 118 }
 119 DbRetVal Database::getTransTableMutex()
 120 {
 121     int ret = metaData_->dbTransTableMutex_.tryLock();
 122     if (ret) return ErrSysInternal; else return OK;
 123 }
 124 DbRetVal Database::releaseTransTableMutex()
 125 {
 126     metaData_->dbTransTableMutex_.releaseLock();
 127     return OK;
 128 }
 129
 130
 131
 132 int Database::initProcessTableMutex()
 133 {
 134     return metaData_->dbProcTableMutex_.init();
 135 }
 136 DbRetVal Database::getProcessTableMutex()
 137 {
 138     int ret = metaData_->dbProcTableMutex_.tryLock();
 139     if (ret) return ErrSysInternal; else return OK;
 140 }
 141 DbRetVal Database::releaseProcessTableMutex()
 142 {
 143     metaData_->dbProcTableMutex_.releaseLock();
 144     return OK;
 145 }
 146
 147
 148
 149 int Database::initDatabaseMutex()
 150 {
 151     return metaData_->dbMutex_.init();
 152 }
 153 DbRetVal Database::getDatabaseMutex()
 154 {
 155     int ret = metaData_->dbMutex_.tryLock();
 156     if (ret) return ErrSysInternal; else return OK;
 157 }
 158 DbRetVal Database::releaseDatabaseMutex()
 159 {
 160     metaData_->dbMutex_.releaseLock();
 161     return OK;
 162 }
 163
 164 // Gets the free page
 165 // Each page is segmented by PAGE_SIZE, so it checks the pageInfo
 166 // of each page to determine if the page is free
 167 // Algorithm is to scan through the pageInfo objects stored at
 168 // address (db start address + i * PAGE_SIZE) where i = 1..n till end
 169 // database
 170 // But in case of large tuples, pages are merged, so there wont be
 171 // PageInfo object on pages which are merged.
 172 // These pages are skipped by checking the nextPageAfterMerge_ of PageInfo
 173
 174 //NOTE::IMPORTANT::assumes alloc database lock is taken before calling this
 175 Page* Database::getFreePage()
 176 {
 177     Page* page = getFirstPage();
 178     printDebug(DM_Alloc, "Database::getFreePage firstPage:%x",page);
 179     PageInfo* pageInfo = ((PageInfo*)page);
 180
 181     while( 1 == pageInfo->isUsed_)
 182     {
 183         //If any pages are merged to store data larger than PAGE_SIZE
 184         //move to the next page after the merge and check whether it is used
 185         if ( pageInfo->nextPageAfterMerge_ == NULL) {
 186             pageInfo = (PageInfo*)((char*)pageInfo + PAGE_SIZE);
 187             printDebug(DM_Alloc,"Normal Page:Moving to page:%x",pageInfo);
 188         }
 189         else {
 190             pageInfo = (PageInfo*)pageInfo->nextPageAfterMerge_;
 191             printDebug(DM_Alloc,"Merged Page:Moving to page:%x",pageInfo);
 192         }
 193         if (!isValidAddress((char*) pageInfo))
 194         {
 195             //printError(ErrSysInternal,"Invalid address %x",pageInfo);
 196             return NULL;
 197         }
 198
 199     }
 200     if (!isValidAddress(((char*) pageInfo) + PAGE_SIZE))
 201     {
 202         printError(ErrSysInternal, "Invalid address %x",((char*) pageInfo) + PAGE_SIZE);
 203         return NULL;
 204     }
 205     setCurrentPage((Page*) pageInfo);
 206     printDebug(DM_Alloc,"Database::getFreePage returning page:%x",pageInfo);
 207     return (Page*) pageInfo ;
 208 }
 209
 210 //Used by tuples more than PAGE_SIZE
 211 //NOTE::IMPORTANT::assumes alloc database lock is taken before calling this
 212 Page* Database::getFreePage(size_t size)
 213 {
 214     Page* page = getFirstPage();
 215     PageInfo* pageInfo = ((PageInfo*)page);
 216     int multiple = size / PAGE_SIZE;
 217     int offset = ((multiple + 1) * PAGE_SIZE);
 218     printDebug(DM_Alloc, "Database::getFreePage firstPage:%x size:%d",page, size);
 219
 220     while(true){
 221         while( 1 == pageInfo->isUsed_)
 222         {
 223             //If any pages are merged to store data larger than PAGE_SIZE
 224             //move to the next page after the merge and check whether it is used
 225             if ( pageInfo->nextPageAfterMerge_ == NULL) {
 226                 pageInfo = (PageInfo*)((char*)pageInfo + PAGE_SIZE);
 227                 printDebug(DM_Alloc,"Normal Page:Moving to page:%x",pageInfo);
 228             }
 229             else {
 230                 pageInfo = (PageInfo*)pageInfo->nextPageAfterMerge_;
 231                 printDebug(DM_Alloc,"Merged Page:Moving to page:%x",pageInfo);
 232             }
 233         }
 234         int i = 0;
 235         PageInfo *pInfo = pageInfo;
 236         if (!isValidAddress(((char*)pInfo) + offset))
 237         {
 238             printError(ErrSysInternal,"Invalid address %x",((char*)pInfo) + offset);
 239             return NULL;
 240         }
 241         for (i = 0; i< multiple + 1; i++)
 242         {
 243             if (1 == pInfo->isUsed_) break;
 244             pInfo = (PageInfo*)((char*)pInfo + PAGE_SIZE);
 245         }
 246         if ( i == (multiple + 1))  break;
 247     }
 248
 249     printDebug(DM_Alloc,"Database::getFreePage returning page:%x",pageInfo);
 250     setCurrentPage((Page*) pageInfo);
 251     return (Page*) pageInfo ;
 252 }
 253
 254
 255 //called only in case of system database to create and initialize the chunk
 256 //information
 257 DbRetVal Database::createSystemDatabaseChunk(AllocType type, size_t size, int id)
 258 {
 259
 260     Chunk *chunk;
 261     if (-1 == id )
 262     {
 263         printError(ErrSysFatal, "Database ID corrupted");
 264         return ErrSysFatal;
 265     }
 266     chunk = getSystemDatabaseChunk(id);
 267
 268     if (FixedSizeAllocator == type) chunk->setSize(size);
 269     //getDatabaseMutex();
 270     if (chunk->allocSize_ > PAGE_SIZE)
 271         chunk->curPage_ = getFreePage(chunk->allocSize_);
 272     else
 273          chunk->curPage_ = getFreePage();
 274     if ( chunk->curPage_ == NULL)
 275     {
 276        //releaseDatabaseMutex();
 277        printError(ErrNoMemory, "No free pages in database: Database full");
 278        return ErrNoMemory;
 279     }
 280
 281     chunk->firstPage_ = chunk->curPage_;
 282     PageInfo* firstPageInfo = ((PageInfo*)chunk->firstPage_);
 283     firstPageInfo->setFirstPageAsUsed();
 284     chunk->setChunkID(id);
 285     chunk->setAllocType(type);
 286     printDebug(DM_Database, "Creating System Database Chunk:%d Size:%d",id, chunk->allocSize_);
 287     if (chunk->allocSize_ > PAGE_SIZE)
 288     {
 289         int multiple = os::floor(chunk->allocSize_ / PAGE_SIZE);
 290         int offset = ((multiple + 1) * PAGE_SIZE);
 291         firstPageInfo->nextPageAfterMerge_ = ((char*)firstPageInfo)+ offset;
 292     }
 293
 294     if (0 == size)
 295     {
 296         VarSizeInfo *varInfo = (VarSizeInfo*)(((char*)firstPageInfo) + sizeof(PageInfo));
 297         varInfo->isUsed_ = 0;
 298         varInfo->size_ = PAGE_SIZE - sizeof(PageInfo) - sizeof(VarSizeInfo);
 299
 300     }
 301     //releaseDatabaseMutex();
 302     return OK;
 303 }
 304
 305 //This is never called currently. If situation arises will be coded later.
 306 DbRetVal Database::deleteSystemDatabaseChunk(int id)
 307 {
 308     Chunk *chunk = getSystemDatabaseChunk(id);
 309     chunk->setChunkID(-1);
 310     chunk->setSize(0);
 311     chunk->setAllocType(UnknownAllocator);
 312     //TODO::
 313     //chunk->pageList_
 314     //walk though the pageList ptr and get all the page pointers
 315     //then free all the pages used to store this by setting the
 316     //start of page to notused
 317     chunk->firstPage_ = NULL;
 318     chunk->curPage_ = NULL;
 319     return OK;
 320 }
 321
 322
 323 void Database::createAllCatalogTables()
 324 {
 325     //These are special chunks which hold catalog tables and other information
 326     //
 327     // chunk id 0 ->userChunkTable
 328     // chunk id 1 ->lockBucketHash
 329     // chunk id 2 ->lockTable
 330     //
 331     // chunk id 10->DATABASE
 332     // chunk id 11->USER
 333     // chunk id 12->TABLE
 334     // chunk id 13->FIELD
 335     // chunk id 14->ACCESS
 336
 337     createSystemTables();
 338     createMetaDataTables();
 339 }
 340 void Database::createSystemTables()
 341 {
 342     createSystemDatabaseChunk(FixedSizeAllocator,
 343                                   sizeof(Chunk), UserChunkTableId);
 344     createSystemDatabaseChunk(FixedSizeAllocator,
 345                                   sizeof(Bucket) * LOCK_BUCKET_SIZE,
 346                                   LockTableHashBucketId);
 347     createSystemDatabaseChunk(FixedSizeAllocator,
 348                                   sizeof(Mutex)* LOCK_BUCKET_SIZE,
 349                                   LockTableMutexId);
 350     createSystemDatabaseChunk(FixedSizeAllocator,
 351                                   sizeof(LockHashNode), LockTableId);
 352     createSystemDatabaseChunk(FixedSizeAllocator,
 353                                   sizeof(TransHasNode), TransHasTableId);
 354
 355     createSystemDatabaseChunk(VariableSizeAllocator,
 356                                   0, UndoLogTableID);
 357 }
 358 void Database::createMetaDataTables()
 359 {
 360     createSystemDatabaseChunk(FixedSizeAllocator,
 361                                   sizeof(DATABASEFILE), DatabaseTableId);
 362     createSystemDatabaseChunk(FixedSizeAllocator,
 363                                   sizeof(USER), UserTableId);
 364     createSystemDatabaseChunk(FixedSizeAllocator,
 365                                   sizeof(TABLE), TableTableId);
 366     createSystemDatabaseChunk(FixedSizeAllocator,
 367                                   sizeof(FIELD), FieldTableId);
 368     createSystemDatabaseChunk(FixedSizeAllocator,
 369                                   sizeof(ACCESS), AccessTableId);
 370     createSystemDatabaseChunk(FixedSizeAllocator,
 371                                   sizeof(INDEX), IndexTableId);
 372     createSystemDatabaseChunk(FixedSizeAllocator,
 373                                   sizeof(INDEXFIELD), IndexFieldTableId);
 374 }
 375
 376 //used in case of system database
 377 Chunk* Database::getSystemDatabaseChunk(int id)
 378 {
 379     size_t offset = os::alignLong(sizeof (DatabaseMetaData)) +
 380                         id * sizeof (Chunk);
 381     return (Chunk*)(((char*) metaData_) +  offset);
 382 }
 383
 384
 385 //used in case of system database
 386 Transaction* Database::getSystemDatabaseTrans(int slot)
 387 {
 388     size_t offset = os::alignLong(sizeof (DatabaseMetaData)) +
 389                     os::alignLong(MAX_CHUNKS * sizeof (Chunk)) +
 390                         slot  * sizeof (Transaction);
 391     return (Transaction*)(((char*) metaData_) +  offset);
 392 }
 393
 394 //used in case of system database
 395 ThreadInfo* Database::getThreadInfo(int slot)
 396 {
 397     size_t offset = os::alignLong(sizeof (DatabaseMetaData));
 398     offset = offset + os::alignLong( MAX_CHUNKS  * sizeof (Chunk));
 399     offset = offset + os::alignLong( Conf::config.getMaxTrans()   * sizeof(Transaction));
 400     offset = offset + slot * sizeof (ThreadInfo);
 401     return (ThreadInfo*)(((char*) metaData_) +  offset);
 402 }
 403
 404 bool Database::isValidAddress(void* addr)
 405 {
 406     if ((char*) addr > ((char*)getMetaDataPtr())  + getMaxSize())
 407         return false;
 408     else
 409         return true;
 410 }
 411
 412 //should be called only on system database
 413 void* Database::allocLockHashBuckets()
 414 {
 415     Chunk *chunk = getSystemDatabaseChunk(LockTableHashBucketId);
 416     void *ptr = chunk->allocate(this);
 417     if (NULL == ptr)
 418     {
 419         printError(ErrNoMemory, "Chunk Allocation failed for lock hash bucket catalog table");
 420     }
 421     return ptr;
 422 }
 423
 424 Bucket* Database::getLockHashBuckets()
 425 {
 426     Chunk *tChunk = getSystemDatabaseChunk(LockTableHashBucketId);
 427     ChunkIterator iter = tChunk->getIterator();
 428     return (Bucket*)iter.nextElement();
 429 }
 430