allocator fixes
[csql.git] / include / TableImpl.h
blob7157906603e8ea4b65d87daa0c7a235859871cee
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 #include<AggTableImpl.h>//for AggType
29 #ifndef SCANTYPE
30 enum ScanType
32 fullTableScan = 0,
33 hashIndexScan,
34 treeIndexScan,
35 unknownScan
37 #define SCANTYPE
38 #endif
40 static char ScanTypeNames[][10] =
42 "TableScan", "HashScan", "TreeScan", "Invalid"
45 class Predicate;
47 class TupleIterator
49 Predicate *pred_;
50 ScanType scanType_;
51 ChunkIterator *cIter;
52 BucketIter *bIter;
53 TreeIter *tIter;
54 IndexInfo *info;
55 char *keyBuffer;
56 char *keyPtr;
57 ComparisionOp op;
58 void *chunkPtr_;
59 int procSlot;
60 bool isBetween;
61 bool isPointLook;
62 bool shouldNullCheck;
63 bool isClosed;
64 TupleIterator() { }
65 public:
66 TupleIterator(Predicate *p, ScanType t, IndexInfo *i, void *cptr, int pslot,bool between , bool isPtLook,bool nullflag)
67 { bIter = new BucketIter();
68 cIter = new ChunkIterator();;
69 tIter = new TreeIter();
70 keyBuffer = NULL;
71 pred_ = p ; scanType_ = t; info = i; chunkPtr_ = cptr;
72 isClosed =true;
73 procSlot =pslot; isBetween=between; isPointLook=isPtLook; shouldNullCheck=nullflag;
75 DbRetVal setPlan();
77 ~TupleIterator()
79 if (bIter) { delete bIter; bIter = NULL; }
80 if (cIter) { delete cIter; cIter = NULL; }
81 if (tIter) { delete tIter; tIter = NULL; }
82 if (keyBuffer) { ::free(keyBuffer); keyBuffer = NULL; }
84 bool isIterClosed() { return isClosed; }
85 bool isBetInvolved(){ return isBetween;}
86 void setBetInvolved(bool between){ isBetween=between;}
87 bool isPointLookInvolved(){return isPointLook;}
88 DbRetVal open();
89 void* next();
90 void* prev();//used only for tree iter during deleteTuple
91 void reset();
92 DbRetVal close();
94 class TableImpl:public Table
96 private:
97 LockManager *lMgr_;
98 Transaction **trans;
99 //This is pointer to the pointer stored in the
100 //Transaction manager.
101 //If the transaction commits/aborts this pointer changes
102 //and this will get that newly allocated transaction
104 char tblName_[IDENTIFIER_LENGTH];
105 int tblID_;
106 size_t length_; //length of the tuple
107 int numFlds_;
108 void* chunkPtr_;
109 void* vcChunkPtr_;
110 void *curTuple_; //holds the current tuple ptr. moved during fetch() calls
112 Predicate *pred_;
113 List predList;
114 ScanType scanType_;
115 //ChunkIterator *iter;
116 //BucketIter *bIter;
118 TupleIterator *iter;
120 bool loadFlag;
121 char aliasName[IDENTIFIER_LENGTH];
123 public:
124 FieldList fldList_;
125 List bindList_;
126 void **bindListArray_;
127 int numBindFlds_;
128 int numIndexes_;
129 int numFkRelation_;
130 char** indexPtr_; // array of index ptrs to the catalog table for the indexes of this table.
131 IndexInfo **idxInfo;
132 int useIndex_;//offet in the above array indexPtr_ for scan
133 bool isPlanCreated;
134 bool isPointLook;
135 bool isBetween;
136 Database *db_;
137 Database *sysDB_;
138 void *ptrToAuto;
139 //Either one of the below is populated based on the no of fields and
140 //is used for tuple insertions
141 bool isIntUsedForNULL;
142 int iNullInfo;
143 char *cNullInfo;
144 int iNotNullInfo;
145 char *cNotNullInfo;
146 //Table *fkTbl;
147 List tblList;
148 List tblFkList;
149 bool isFkTbl;
150 bool isPkTbl;
151 bool shouldNullSearch;
152 private:
154 //copy Values from binded buffer to tuple pointed by arg
155 DbRetVal copyValuesFromBindBuffer(void *tuple, bool isInsert=true);
156 DbRetVal copyValuesToBindBuffer(void *tuple);
157 void setNullBit(int fldpos);
158 void clearNullBit(int fldpos);
159 DbRetVal insertIndexNode(Transaction *trans, void *indexPtr, IndexInfo *info, void *tuple);
160 DbRetVal updateIndexNode(Transaction *trans, void *indexPtr, IndexInfo *info, void *tuple);
161 DbRetVal deleteIndexNode(Transaction *trans, void *indexPtr, IndexInfo *info, void *tuple);
162 bool isFKTable(){return isFkTbl;};
163 DbRetVal createPlan();
164 Chunk* getSystemTableChunk(CatalogTableID id)
166 return sysDB_->getSystemDatabaseChunk(id);
168 DbRetVal trySharedLock(void *curTuple, Transaction **trans);
169 DbRetVal tryExclusiveLock(void *curTuple, Transaction **trans);
170 DbRetVal getCheckpointMutex();
173 public:
174 TableImpl() { db_ = NULL; chunkPtr_ = NULL; vcChunkPtr_=NULL; iter = NULL;
175 idxInfo = NULL; indexPtr_ = NULL; scanType_ = unknownScan;
176 pred_ = NULL; useIndex_ = -1; numFlds_ = 0; bindListArray_ = NULL;
177 iNullInfo = 0; cNullInfo = NULL; isIntUsedForNULL = true;
178 iNotNullInfo = 0; cNotNullInfo = NULL; curTuple_ = NULL;
179 isPlanCreated = false; loadFlag = false;isFkTbl=false;isPkTbl=false;numFkRelation_=0; shouldNullSearch = false;}
180 ~TableImpl();
182 void setDB(Database *db) { db_ = db; }
183 Database* getDB() { return db_;}
184 void setSystemDB(Database *db) { sysDB_ = db; }
185 void setLockManager(LockManager *lmgr) { lMgr_ = lmgr; }
186 void setTrans(Transaction **t) { trans = t; }
187 inline void setCurTuple(void *tuple){ curTuple_=tuple; }
188 DataType getFieldType(const char *name)
189 { return fldList_.getFieldType(name); }
190 int getFieldOffset(const char *name)
191 { return fldList_.getFieldOffset(name); }
192 size_t getFieldLength(const char *name)
193 { return fldList_.getFieldLength(name); }
194 int getNumFields() { return numFlds_; }
195 void fillFieldInfo(int pos, void* val)
196 { return fldList_.fillFieldInfo(pos,val); }
198 long long getLastInsertedVal(DbRetVal &rv);
199 DbRetVal getFieldInfo(const char *fieldName, FieldInfo *&info)
201 char tblName[IDENTIFIER_LENGTH];
202 char fldName[IDENTIFIER_LENGTH];
203 getTableNameAlone((char*)fieldName, tblName);
204 getFieldNameAlone((char*)fieldName, fldName);
205 if (0 == strcmp(tblName, "") || 0 ==strcmp(tblName, getName()) ||
206 0 == strcmp(tblName, getAliasName()))
207 return fldList_.getFieldInfo(fldName, info);
208 else
209 return ErrNotExists;
212 List getFieldNameList();
214 // search predicate
215 void setCondition(Condition *p);
216 //{ isPlanCreated = false; if (p) pred_ = p->getPredicate(); else pred_ = NULL;}
218 //binding
219 DbRetVal bindFld(const char *name, void *val, bool isNullExpl=false);
220 void *getBindFldAddr(const char *name);
221 int getFldPos(char *name);
222 DbRetVal markFldNull(const char *name);
223 DbRetVal markFldNull(int colpos);
224 bool isFldNull(const char *name);
225 bool isFldNull(int colpos);
227 void clearFldNull(const char *name);
228 void clearFldNull(int colpos);
229 void resetNullinfo();
230 DbRetVal insertTuple();
231 DbRetVal updateTuple();
233 DbRetVal deleteTuple();
234 int deleteWhere();
235 int truncate();
237 DbRetVal execute();
238 bool isPkTableHasRecord(char *name,TableImpl *fkTbl,bool isInsert);
239 bool isFkTableHasRecord(char *name,TableImpl *fkTbl);
240 void* fetch();
241 void* fetch(DbRetVal &rv);
242 void* fetchNoBind();
243 void* fetchNoBind(DbRetVal &rv);
244 DbRetVal fetchAgg(const char *fldName, AggType aType, void *buf, bool &noRec);
246 DbRetVal close();
247 DbRetVal closeScan();
250 long spaceUsed();
251 long numTuples();
252 int pagesUsed();
253 void printInfo();
254 void printPlan(int space);
256 DbRetVal lock(bool shared);
257 DbRetVal unlock();
259 DbRetVal setUndoLogging(bool flag) { loadFlag = flag; return OK;}
261 void printSQLIndexString(FILE *fp, int fd);
262 void printSQLForeignString();
263 DbRetVal optimize();
264 bool isTableInvolved(char *tblName);
265 bool pushPredicate(Predicate *pred);
266 void setPredicate(Predicate *pred);
267 ScanType getScanType() { return scanType_; }
268 bool hasIndex(char *fldName);
269 IndexType getIndexType(char *fldName, int* pos);
270 void addPredicate(char *fName, ComparisionOp op, void *buf);
271 DbRetVal compact();
272 DbRetVal compactIndexNode( void *indexPtr);
273 char* getName() { return tblName_; }
274 char* getAliasName() { return aliasName; }
275 void setAliasName(char *name);
276 void setTableInfo(char *name, int tblid, size_t length,
277 int numFld, int numIdx, void *chunk, void *vcchunk);
278 void setLoading(bool flag) { loadFlag = flag; }
279 friend class DatabaseManagerImpl;
283 #endif