include/CatalogTables.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
  17 #ifndef CATALOGTABLE_H
  18 #define CATALOGTABLE_H
  19
  20 #include<DataType.h>
  21 #include<os.h>
  22 #include<Index.h>
  23 #include<Debug.h>
  24 #include<Util.h>
  25
  26
  27 extern char ChunkName[MAX_CHUNKS][CHUNK_NAME_LEN];
  28 class FieldList;
  29 class FieldNameList;
  30 class FieldIterator;
  31 class ChunkIterator;
  32
  33 enum ObjectType
  34 {
  35     Tbl  = 0,
  36     hIdx = 1,
  37     tIdx = 2,
  38 };
  39
  40 struct Object
  41 {
  42     char name[64];
  43     ObjectType type;
  44     void *bucketChunk;
  45     void *firstPage;
  46     void *curPage;
  47 };
  48
  49 enum CatalogTableID
  50 {
  51     // chunk id 0 ->userChunkTable
  52     //
  53     // chunk id 10->DATABASE
  54     // chunk id 11->USER
  55     // chunk id 12->TABLE
  56     // chunk id 13->FIELD
  57     // chunk id 14->ACCESS
  58     // chunk id 15->INDEX
  59     // chunk id 16->INDEXFIELD
  60
  61     UserChunkTableId      =  0,
  62     LockTableHashBucketId =  1,
  63     LockTableMutexId      =  2,
  64     LockTableId           =  3,
  65     TransHasTableId       =  4,
  66     UndoLogTableID        =  5,
  67
  68
  69     DatabaseTableId  = 10,
  70     UserTableId      = 11,
  71     TableTableId     = 12,
  72     FieldTableId     = 13,
  73     AccessTableId    = 14,
  74     IndexTableId     = 15,
  75     IndexFieldTableId= 16,
  76     ForeignKeyTableId= 17,
  77     ForeignKeyFieldTableId= 18,
  78     LastCatalogID = 25 //marks the end of catalog chunk ID.
  79 };
  80
  81
  82 class CTABLE
  83 {
  84     public:
  85     char tblName_[IDENTIFIER_LENGTH];
  86     int tblID_;
  87     size_t length_; //length of the tuple
  88     int numFlds_;
  89     int numIndexes_;
  90     void* chunkPtr_;
  91     void* varcharChunkPtr_;
  92
  93 };
  94
  95 class CatalogTableTABLE
  96 {
  97     Database *systemDatabase_;
  98     public:
  99     CatalogTableTABLE(Database *db) { systemDatabase_  = db; }
 100
 101     //Last argument is OUT parameter which will contain the
 102     //pointer to the inserted tuple
 103     DbRetVal insert(const char *name, int id, size_t size,
 104                      int numFlds, void* chunk, void *&tptr, void *vcchunk);
 105
 106     //Second argument is OUT parameter which will contain the
 107     //chunk pointer of this table
 108     //Third argument is OUT parameter which will contain the
 109     //pointer to the removed tuple
 110     DbRetVal remove(const char *name, void *&chunk, void *&tptr);
 111     DbRetVal renameTable(const char *oldName,const char *newName);
 112     DbRetVal getChunkAndTblPtr(const char *name, void *&chunk, void *&tptr, void*&vcchunk);
 113     DbRetVal setChunkPtr(const char *name, void *firstPage, void *curPage);
 114     List getTableList();
 115 };
 116
 117
 118 class CFIELD
 119 {
 120     public:
 121     char fldName_[IDENTIFIER_LENGTH];
 122     int tblID_;      //table id where this field resides
 123     void* tblPtr_;    //pointer to tuple in catalog table TABLE
 124     DataType type_;
 125     size_t length_;  //length of the field
 126     size_t offset_;  //offset (in bytes) into tuple
 127     //currently default value is supported for string and binary
 128     //less than length 32 bytes
 129     char defaultValueBuf_[DEFAULT_VALUE_BUF_LENGTH];
 130     long long autoVal_;//[DEFAULT_VALUE_BUF_LENGTH];
 131     int width_;
 132     int scale_;
 133     bool isNull_;
 134     bool isPrimary_;
 135     bool isUnique_;
 136     bool isDefault_;
 137     bool isAutoIncrement_;
 138 };
 139
 140 class CatalogTableFIELD
 141 {
 142     Database *systemDatabase_;
 143     public:
 144     CatalogTableFIELD(Database *db) { systemDatabase_  = db; }
 145
 146     //returns -1 on error
 147     DbRetVal insert(FieldIterator &iter, int tblID, void *tblPtr);
 148
 149     DbRetVal remove(void *tblPtr);
 150
 151     //II argument is OUT parameter
 152     //field list is populated from the catalog table for
 153     // the table pointed by tblPtr
 154     void *getFieldInfo( void* tblPtr, FieldList &list);
 155
 156     //array is OUT param
 157     //returns the pointer to fields for the corresponding name
 158     //in field name list as an array
 159     DbRetVal getFieldPtrs(FieldNameList &fldList,void *tptr, char **&array);
 160     DbRetVal renameField(const char *tableName, const char *oldName, const char *newName);
 161 };
 162
 163 class CUSER
 164 {
 165     public:
 166     char userName_[IDENTIFIER_LENGTH];
 167     char password_[IDENTIFIER_LENGTH];
 168 };
 169
 170 class CatalogTableUSER
 171 {
 172     Database *systemDatabase_;
 173     public:
 174     CatalogTableUSER(Database *db) { systemDatabase_  = db; }
 175
 176     //returns -1 on error
 177     DbRetVal insert(const char *name, const char *pass);
 178     DbRetVal authenticate(const char *name, const char *pass,
 179                      bool &isAuthenticated, bool &isDba);
 180     DbRetVal remove(const char *name);
 181     DbRetVal changePass(const char *name, const char *pass);
 182     List getUserList();
 183 };
 184
 185 class CACCESS
 186 {
 187     public:
 188     char userName_[IDENTIFIER_LENGTH];
 189     char dbName_[IDENTIFIER_LENGTH];
 190 };
 191
 192 class CDATABASEFILE
 193 {
 194     public:
 195     int dbID_;
 196     char dbName_[IDENTIFIER_LENGTH];
 197     int maxChunks_;
 198     size_t maxSize_;  //maximum size of database
 199     caddr_t dbStart_; //address where the database is mapped
 200 };
 201
 202
 203 class CINDEX
 204 {
 205     public:
 206     char indName_[IDENTIFIER_LENGTH];
 207     int tblID_;      //table id of the table
 208     void* tblPtr_;    //pointer to tuple in catalog table TABLE
 209     IndexType indexType_;
 210     void* chunkPtr_; //pointer to the index chunk
 211     int numFlds_;
 212     int noOfBuckets_;
 213     bool isUnique_;
 214     void *hashNodeChunk_;
 215     void *fstIndFld_;//pointer to fisrt index field
 216 };
 217
 218 class CatalogTableINDEX
 219 {
 220     Database *systemDatabase_;
 221     public:
 222     CatalogTableINDEX(Database *db) { systemDatabase_  = db; }
 223
 224
 225     //last arg is OUT parameter which will give the pointer to
 226     //the index tuple
 227     DbRetVal insert(const char *name, void *tblPtr, int numFlds, bool isUnique,
 228                      void* chunk, int bucketSize, void *hChunk, void *&tupleptr);
 229
 230     //Second argument is OUT parameter which will contain the
 231     //chunk pointer of this table
 232     //Third argument is OUT parameter which will contain the
 233     //pointer to the removed tuple
 234     DbRetVal remove(const char *name, void *&chunk, void *&hchunk, void *&iptr);
 235     DbRetVal get(const char *name, void *&chunk, void *&hchunk, void *&iptr);
 236     DbRetVal setChunkPtr(const char *name, ObjectType tp, void *chunk, void *firstPage, void *curPage);
 237
 238     //get the number of indexes on table pointed by tblPtr
 239     int getNumIndexes(void *tblPtr);
 240
 241     char* getIndexName(void *tblPtr, int pos);
 242
 243     //gets all the index ptrs as array for the table pointed by tblPtr
 244     void getIndexPtrs(void *tblPtr, char **&array);
 245
 246     static ChunkIterator getIterator(void *iptr);
 247     static int getNoOfBuckets(void *iptr);
 248     static int getUnique(void *iptr);
 249     static char* getName(void *iptr);
 250     static int getOffsetOfFirstField(void *iptr);
 251     static IndexType getType(void *iptr);
 252 };
 253
 254
 255 class CINDEXFIELD
 256 {
 257     public:
 258     void* indexPtr; //pointer to tuple in catalog table INDEX
 259     void* tablePtr; //pointer to tuple in catalog table TABLE
 260     void* fieldPtr; //pointer to tuple in catalog table FIELD
 261     CINDEXFIELD *next;
 262 };
 263
 264 class CatalogTableINDEXFIELD
 265 {
 266     Database *systemDatabase_;
 267     public:
 268     CatalogTableINDEXFIELD(Database *db) { systemDatabase_  = db; }
 269
 270     DbRetVal insert(FieldNameList &fldList, void *indexPtr,
 271                                void *tblPtr, char **&fptr);
 272
 273     DbRetVal remove(void *iptr);
 274
 275     DbRetVal getFieldNameAndType(void *iptr, char *&name, DataType &type);
 276     DbRetVal getFieldInfo(void *index, FieldList &list);
 277     void printAllIndex();
 278     ListIterator getIndexListIterater(char *name);
 279
 280 };
 281
 282 class CFK
 283 {
 284     public:
 285     char fkName_[IDENTIFIER_LENGTH];
 286     void* pkTblPtr_;
 287     void* fkTblPtr_;
 288 };
 289
 290 class CatalogTableFK
 291 {
 292     Database *systemDatabase_;
 293     public:
 294     CatalogTableFK(Database *db) { systemDatabase_  = db; }
 295     DbRetVal insert(char *name, void *tFkPtr,void *tPkPtr);
 296     DbRetVal remove(void *tptr);
 297     void *getFkCTable(void* tptr);
 298     int getNumFkTable(void *ctptr);
 299     bool isFkTable(void *ctptr);
 300     void getPkTableName(void *ctptr, char **&array);
 301     void getFkTableName(void *ctptr, char **&array);
 302     int getNoOfPkTable(void *ctptr);
 303     int getNoOfFkTable(void *ctptr);
 304     DbRetVal getPkFkFieldInfo(void *cpkptr, void *cfkptr, FieldNameList &pklist,FieldNameList &pklist1);
 305 };
 306
 307 class CFKFIELD
 308 {
 309    public:
 310    void* fkPtr_;//pointer to tuple in catalog table CFK
 311    void* pfFldPtr_;
 312    void* fkFldPtr_;
 313 };
 314
 315 class CatalogTableFKFIELD
 316 {
 317     Database *systemDatabase_;
 318     public:
 319     CatalogTableFKFIELD(Database *db) { systemDatabase_  = db; }
 320     DbRetVal insert(char *cFKName, char **fkFldPtrs, char **pkFldPtrs,int totalFld);
 321     DbRetVal remove(void *fptr);
 322 };
 323
 324 #endif