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
  28 class Bucket
  29 {
  30     public:
  31     Mutex mutex_;
  32     void *bucketList_;
  33 };
  34 class HashIndexNode
  35 {
  36     public:
  37     void *ptrToKey_;
  38     void *ptrToTuple_;
  39     HashIndexNode *next_;
  40 };
  41 class BucketIter
  42 {
  43     HashIndexNode *iter;
  44     public:
  45     BucketIter(){}
  46     BucketIter(HashIndexNode *head) { iter = head;}
  47     HashIndexNode* next();
  48     friend class BucketList;
  49 };
  50 class BucketList
  51 {
  52     HashIndexNode *head;
  53     public:
  54     BucketList(){ head = NULL;}
  55     BucketList(HashIndexNode *h){ head = h; }
  56     DbRetVal insert(Chunk *chunk, Database *db, void *key, void *tuple);
  57     DbRetVal remove(Chunk *chunk, Database *db, void *key);
  58     BucketIter getIterator()
  59     {
  60         BucketIter it;
  61         it.iter = head;
  62         return it;
  63     }
  64
  65 };
  66 class HashIndex;
  67 class IndexInfo;
  68 class Index
  69 {
  70     // create (one) object for each indexing mechanisms here
  71     // Also need to make changes to getIndex() and destroy() methods
  72     // accordingly for new index machanism.
  73     static HashIndex *hIdx;
  74     static long usageCount;
  75     public:
  76     static Index* getIndex(IndexType type);
  77     static void init() { usageCount++; }
  78     static void destroy() {
  79          usageCount--;
  80          if(!usageCount) {
  81             if(!hIdx) { delete hIdx; hIdx=NULL; }
  82          }
  83     }
  84     virtual DbRetVal insert(TableImpl *tbl, Transaction *tr, void *indexPtr, IndexInfo *info, void *tuple, bool undoFlag)=0;
  85     virtual DbRetVal remove(TableImpl *tbl, Transaction *tr, void *indexPtr, IndexInfo *info, void *tuple, bool undoFlag)=0;
  86     virtual DbRetVal update(TableImpl *tbl, Transaction *tr, void *indexPtr, IndexInfo *info, void *tuple, bool undoFlag)=0;
  87 };
  88 class HashIndex : public Index
  89 {
  90
  91     public:
  92     DbRetVal insert(TableImpl *tbl, Transaction *tr, void *indexPtr, IndexInfo *info, void *tuple, bool undoFlag);
  93     DbRetVal remove(TableImpl *tbl, Transaction *tr, void *indexPtr, IndexInfo *info, void *tuple, bool undoFlag);
  94     DbRetVal update(TableImpl *tbl, Transaction *tr, void *indexPtr, IndexInfo *info, void *tuple, bool undoFlag);
  95     static unsigned int computeHashBucket(DataType type, void *key, int noOfBuckets);
  96
  97 };
  98
  99 enum IndexIntType
 100 {
 101         hashOneField = 1,
 102         hash = 2,
 103         tree = 3
 104
 105 };
 106 class IndexInfo
 107 {
 108     public:
 109     IndexType type;
 110 };
 111
 112 //Used by TableImpl to cache information related to hash indexes on that table
 113 class SingleFieldHashIndexInfo :public IndexInfo
 114 {
 115     public:
 116     char  *fldName;
 117     DataType type ;
 118     char *indexPtr;
 119     int noOfBuckets;
 120     Bucket* buckets;
 121     int fldPos;
 122     bool isUnique;
 123     int offset;
 124     int length;
 125     void print()
 126     {
 127         printf("SingleFieldHashIndexInfo fldname:%s type:%d indexPtr:%x noOfBuckets:%d buckets:%x isUnique:%d\n", fldName, type, indexPtr, noOfBuckets, buckets, isUnique);
 128     }
 129 };
 130 #endif
 131