include/TableImpl.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 TABLE_IMPL_H
  17 #define TABLE_IMPL_H
  18 #include<os.h>
  19 #include<DataType.h>
  20 #include<Transaction.h>
  21 #include<Database.h>
  22 #include<Index.h>
  23 #include<CatalogTables.h>
  24 #include<Info.h>
  25 #include<Debug.h>
  26 #include<DatabaseManagerImpl.h>
  27 #include<Predicate.h>
  28 enum ScanType
  29 {
  30     fullTableScan = 0,
  31     hashIndexScan,
  32     treeIndexScan,
  33     unknownScan
  34 };
  35
  36 class Predicate;
  37
  38 class TupleIterator
  39 {
  40     Predicate *pred_;
  41     ScanType scanType_;
  42     ChunkIterator *cIter;
  43     BucketIter *bIter;
  44     IndexInfo *info;
  45     void *chunkPtr_;
  46     int procSlot;
  47
  48     TupleIterator(){}
  49     public:
  50
  51     TupleIterator(Predicate *p, ScanType t, IndexInfo *i, void *cptr, int pslot)
  52     { bIter = NULL; pred_ = p ; scanType_ = t; info = i; chunkPtr_ = cptr; procSlot =pslot;}
  53
  54     ~TupleIterator()
  55         {
  56         if (bIter) delete bIter;
  57         bIter = NULL;
  58     }
  59
  60     DbRetVal open();
  61     void* next();
  62     DbRetVal close();
  63
  64 };
  65 class TableImpl:public Table
  66 {
  67     private:
  68
  69
  70     LockManager *lMgr_;
  71     Transaction **trans;
  72     //This is pointer to the pointer stored in the
  73     //Transaction manager.
  74     //If the transaction commits/aborts this pointer changes
  75     //and this will get that newly allocated transaction
  76
  77     char tblName_[IDENTIFIER_LENGTH];
  78     int tblID_;
  79     size_t length_; //length of the tuple
  80     int numFlds_;
  81     void* chunkPtr_;
  82     void *curTuple_; //holds the current tuple ptr. moved during fetch() calls
  83
  84     Predicate *pred_;
  85     ScanType scanType_;
  86     //ChunkIterator *iter;
  87     //BucketIter *bIter;
  88
  89     TupleIterator *iter;
  90
  91     bool undoFlag;
  92
  93     public:
  94     FieldList fldList_;
  95     int numIndexes_;
  96     char** indexPtr_; // array of index ptrs to the catalog table for the indexes of this table.
  97     IndexInfo **idxInfo;
  98     int useIndex_;//offet in the above array indexPtr_ for scan
  99     bool isPlanCreated;
 100
 101     Database *db_;
 102     Database *sysDB_;
 103
 104     //Either one of the below is populated based on the no of fields and
 105     //is used for tuple insertions
 106     bool isIntUsedForNULL;
 107     int iNullInfo;
 108     char *cNullInfo;
 109     int iNotNullInfo;
 110     char *cNotNullInfo;
 111
 112     private:
 113
 114     //copy Values from binded buffer to tuple pointed by arg
 115     DbRetVal copyValuesFromBindBuffer(void *tuple, bool isInsert=true);
 116     DbRetVal copyValuesToBindBuffer(void *tuple);
 117     void setNullBit(int fldpos);
 118
 119     DbRetVal insertIndexNode(Transaction *trans, void *indexPtr, IndexInfo *info, void *tuple);
 120     DbRetVal updateIndexNode(Transaction *trans, void *indexPtr, IndexInfo *info, void *tuple);
 121     DbRetVal deleteIndexNode(Transaction *trans, void *indexPtr, IndexInfo *info, void *tuple);
 122
 123     DbRetVal createPlan();
 124     Chunk* getSystemTableChunk(CatalogTableID id)
 125     {
 126         return sysDB_->getSystemDatabaseChunk(id);
 127     }
 128
 129     public:
 130     TableImpl() { db_ = NULL; chunkPtr_ = NULL; iter = NULL;
 131         idxInfo = NULL; indexPtr_ = NULL; scanType_ = unknownScan;
 132         pred_ = NULL; useIndex_ = -1; numFlds_ = 0;
 133         iNullInfo = 0; cNullInfo = NULL; isIntUsedForNULL = true;
 134         iNotNullInfo = 0; cNotNullInfo = NULL;
 135         isPlanCreated = false; undoFlag = true;}
 136     ~TableImpl();
 137
 138     void setDB(Database *db) { db_ = db; }
 139     void setSystemDB(Database *db) { sysDB_ = db; }
 140     void setLockManager(LockManager *lmgr) { lMgr_ = lmgr; }
 141     void setTrans(Transaction **t) { trans = t; }
 142
 143     DataType getFieldType(const char *name)
 144         { return fldList_.getFieldType(name);   }
 145     int getFieldOffset(const char *name)
 146         { return fldList_.getFieldOffset(name); }
 147     size_t getFieldLength(const char *name)
 148         { return fldList_.getFieldLength(name); }
 149
 150     DbRetVal getFieldInfo(const char *fieldName,  FieldInfo *&info)
 151         { return fldList_.getFieldInfo(fieldName, info); }
 152
 153     List getFieldNameList();
 154
 155     // search predicate
 156      void setCondition(Condition *p)
 157      { isPlanCreated = false; if (p) pred_ = p->getPredicate(); else pred_ = NULL;}
 158
 159     //binding
 160     DbRetVal bindFld(const char *name, void *val);
 161
 162     void markFldNull(const char *name);
 163     void markFldNull(int colpos);
 164     bool isFldNull(const char *name);
 165     bool isFldNull(int colpos);
 166
 167
 168     void clearFldNull(const char *name);
 169     void clearFldNull(int colpos);
 170
 171
 172     DbRetVal insertTuple();
 173     DbRetVal updateTuple();
 174
 175     DbRetVal deleteTuple();
 176     int deleteWhere();
 177     int truncate();
 178
 179     DbRetVal execute();
 180
 181     void* fetch();
 182     void* fetch(DbRetVal &rv);
 183     void* fetchNoBind();
 184     void* fetchNoBind(DbRetVal &rv);
 185
 186     DbRetVal close();
 187
 188
 189     long spaceUsed();
 190     long numTuples();
 191     int pagesUsed();
 192     void printInfo();
 193
 194     DbRetVal lock(bool shared);
 195     DbRetVal unlock();
 196
 197     DbRetVal setUndoLogging(bool flag) { undoFlag = flag; }
 198
 199     void printSQLIndexString();
 200     char* getName() { return tblName_; }
 201     void setTableInfo(char *name, int tblid, size_t  length,
 202                        int numFld, int numIdx, void *chunk);
 203     friend class DatabaseManagerImpl;
 204 };
 205
 206
 207 #endif