include/Index.h

   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 #ifndef INDEX_H
  17 #define INDEX_H
  18 #include<DataType.h>
  19 #include<Debug.h>
  20 #include<Info.h>
  21
  22
  23 class Chunk;
  24 class Database;
  25 class Transaction;
  26 class TableImpl;
  27 class CINDEX;
  28
  29 class Bucket
  30 {
  31     public:
  32     Mutex mutex_;
  33     void *bucketList_;
  34 };
  35 class HashIndexNode
  36 {
  37     public:
  38     void *ptrToKey_;
  39     void *ptrToTuple_;
  40     HashIndexNode *next_;
  41 };
  42
  43 class IndexInfo;
  44 class TreeNode
  45 {
  46     public:
  47     Mutex mutex_;
  48     void *min_;
  49     void *max_;
  50     int noElements_;
  51     int balance_;
  52     TreeNode *next_;
  53     TreeNode *prev_;
  54     //Note::after this array of pointer to tuples are stored
  55
  56     DbRetVal insert(Database *db, IndexInfo *info, void *indexPtr, void *tuple);
  57     DbRetVal insert(int position, Database *db, IndexInfo *indInfo, CINDEX *iptr, void *tuple, TreeNode *iter);
  58     DbRetVal remove(Database *db, IndexInfo *info, void *indexPtr, void *tuple);
  59     DbRetVal update(Database *db, IndexInfo *info, void *indexPtr, void *tuple);
  60     void displayAll(IndexInfo *indInfo, void *indexPtr);
  61     void displayAll(int offset);
  62 };
  63
  64 class BucketIter
  65 {
  66     HashIndexNode *iter;
  67     public:
  68     BucketIter(){}
  69     BucketIter(HashIndexNode *head) { iter = head;}
  70     HashIndexNode* next();
  71     friend class BucketList;
  72 };
  73 class BucketList
  74 {
  75     HashIndexNode *head;
  76     public:
  77     BucketList(){ head = NULL;}
  78     BucketList(HashIndexNode *h){ head = h; }
  79     void *getBucketListHead(){ return head;}
  80     DbRetVal insert(Chunk *chunk, Database *db, void *key, void *tuple);
  81     DbRetVal remove(Chunk *chunk, Database *db, void *key);
  82     BucketIter getIterator()
  83     {
  84         BucketIter it;
  85         it.iter = head;
  86         return it;
  87     }
  88
  89 };
  90 class HashIndex;
  91 class IndexInfo;
  92 class HashIndexInfo;
  93 class TreeIndex;
  94 class Index
  95 {
  96     // create (one) object for each indexing mechanisms here
  97     // Also need to make changes to getIndex() and destroy() methods
  98     // accordingly for new index machanism.
  99     static HashIndex *hIdx;
 100     static TreeIndex *tIdx;
 101     static long usageCount;
 102     public:
 103     static Index* getIndex(IndexType type);
 104     static void init() { usageCount++; }
 105     static void destroy() {
 106          usageCount--;
 107          if(!usageCount) {
 108             if(!hIdx) { delete hIdx; hIdx=NULL; }
 109          }
 110     }
 111     virtual DbRetVal insert(TableImpl *tbl, Transaction *tr, void *indexPtr, IndexInfo *info, void *tuple, bool undoFlag)=0;
 112     virtual DbRetVal remove(TableImpl *tbl, Transaction *tr, void *indexPtr, IndexInfo *info, void *tuple, bool undoFlag)=0;
 113     virtual DbRetVal update(TableImpl *tbl, Transaction *tr, void *indexPtr, IndexInfo *info, void *tuple, bool undoFlag)=0;
 114 };
 115 class HashIndex : public Index
 116 {
 117
 118     public:
 119     DbRetVal insert(TableImpl *tbl, Transaction *tr, void *indexPtr, IndexInfo *info, void *tuple, bool undoFlag);
 120     DbRetVal remove(TableImpl *tbl, Transaction *tr, void *indexPtr, IndexInfo *info, void *tuple, bool undoFlag);
 121     DbRetVal update(TableImpl *tbl, Transaction *tr, void *indexPtr, IndexInfo *info, void *tuple, bool undoFlag);
 122     static unsigned int computeHashBucket(DataType type, void *key, int noOfBuckets, int length=0);
 123     static DbRetVal insertLogicalUndoLog(Database *sysdb, void *info);
 124     static DbRetVal deleteLogicalUndoLog(Database *sysdb, void *info);
 125 };
 126
 127 class TreeIndex : public Index
 128 {
 129
 130     TreeNode* locateNode(TreeNode *iter, void *tuple, IndexInfo *indInfo);
 131     DbRetVal removeElement(Database *db, TreeNode *iter, void *tuple, HashIndexInfo *info);
 132     public:
 133     DbRetVal insert(TableImpl *tbl, Transaction *tr, void *indexPtr, IndexInfo *info, void *tuple, bool undoFlag);
 134     DbRetVal remove(TableImpl *tbl, Transaction *tr, void *indexPtr, IndexInfo *info, void *tuple, bool undoFlag);
 135     DbRetVal update(TableImpl *tbl, Transaction *tr, void *indexPtr, IndexInfo *info, void *tuple, bool undoFlag);
 136
 137 };
 138 class TreeIter
 139 {
 140     TreeNode *iter;
 141     int fldOffset;
 142     DataType type;
 143     int length;
 144     ComparisionOp op;
 145     bool asc;
 146     void *searchKey;
 147     bool firstCall;
 148     int nodeOffset;
 149     bool recordsOver;
 150
 151     void* locateNode();
 152     void* locateElement();
 153
 154     public:
 155     TreeIter(){}
 156     TreeIter(TreeNode *head) { iter = head; firstCall = true; recordsOver=false;}
 157     void setSearchKey(void *key, ComparisionOp cop, bool ascending = true)
 158     {
 159         searchKey = key; op = cop; asc =ascending;
 160     }
 161     void setFldOffset(int off) { fldOffset = off; }
 162     void setTypeLength(DataType t, int l) { type =t ; length =l; }
 163     void* prev();
 164     void* next();
 165     void nextNode();
 166 };
 167
 168 enum IndexIntType
 169 {
 170         hashOneField = 1,
 171         hash = 2,
 172         tree = 3
 173
 174 };
 175 class IndexInfo
 176 {
 177     public:
 178     IndexType indType;
 179 };
 180
 181 //Used by TableImpl to cache information related to hash indexes on that table
 182 class HashIndexInfo :public IndexInfo
 183 {
 184     public:
 185     FieldList idxFldList;
 186     char *indexPtr;
 187     int noOfBuckets;
 188     Bucket* buckets;
 189     int fldOffset;
 190     bool isUnique;
 191     DataType type;
 192     int compLength;
 193     void print()
 194     {
 195         printf("HashIndexInfo indexPtr:%x noOfBuckets:%d buckets:%x \n",indexPtr, noOfBuckets, buckets);
 196     }
 197 };
 198 #endif
 199