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 renameIndex(const char *oldName,const char *newName);
 113     DbRetVal getChunkAndTblPtr(const char *name, void *&chunk, void *&tptr, void*&vcchunk);
 114     DbRetVal setChunkPtr(const char *name, void *firstPage, void *curPage);
 115     List getTableList();
 116 };
 117
 118
 119 class CFIELD
 120 {
 121     public:
 122     char fldName_[IDENTIFIER_LENGTH];
 123     int tblID_;      //table id where this field resides
 124     void* tblPtr_;    //pointer to tuple in catalog table TABLE
 125     DataType type_;
 126     size_t length_;  //length of the field
 127     size_t offset_;  //offset (in bytes) into tuple
 128     //currently default value is supported for string and binary
 129     //less than length 32 bytes
 130     char defaultValueBuf_[DEFAULT_VALUE_BUF_LENGTH];
 131     long long autoVal_;//[DEFAULT_VALUE_BUF_LENGTH];
 132     int width_;
 133     int scale_;
 134     bool isNull_;
 135     bool isPrimary_;
 136     bool isUnique_;
 137     bool isDefault_;
 138     bool isAutoIncrement_;
 139 };
 140
 141 class CatalogTableFIELD
 142 {
 143     Database *systemDatabase_;
 144     public:
 145     CatalogTableFIELD(Database *db) { systemDatabase_  = db; }
 146
 147     //returns -1 on error
 148     DbRetVal insert(FieldIterator &iter, int tblID, void *tblPtr);
 149
 150     DbRetVal remove(void *tblPtr);
 151
 152     //II argument is OUT parameter
 153     //field list is populated from the catalog table for
 154     // the table pointed by tblPtr
 155     void *getFieldInfo( void* tblPtr, FieldList &list);
 156
 157     //array is OUT param
 158     //returns the pointer to fields for the corresponding name
 159     //in field name list as an array
 160     DbRetVal getFieldPtrs(FieldNameList &fldList,void *tptr, char **&array);
 161     DbRetVal renameField(const char *tableName, const char *oldName, const char *newName);
 162 };
 163
 164 class CUSER
 165 {
 166     public:
 167     char userName_[IDENTIFIER_LENGTH];
 168     char password_[IDENTIFIER_LENGTH];
 169 };
 170
 171 class CatalogTableUSER
 172 {
 173     Database *systemDatabase_;
 174     public:
 175     CatalogTableUSER(Database *db) { systemDatabase_  = db; }
 176
 177     //returns -1 on error
 178     DbRetVal insert(const char *name, const char *pass);
 179     DbRetVal authenticate(const char *name, const char *pass,
 180                      bool &isAuthenticated, bool &isDba);
 181     DbRetVal remove(const char *name);
 182     DbRetVal changePass(const char *name, const char *pass);
 183     List getUserList();
 184 };
 185
 186 class CACCESS
 187 {
 188     public:
 189     char userName_[IDENTIFIER_LENGTH];
 190     char dbName_[IDENTIFIER_LENGTH];
 191 };
 192
 193 class CDATABASEFILE
 194 {
 195     public:
 196     int dbID_;
 197     char dbName_[IDENTIFIER_LENGTH];
 198     int maxChunks_;
 199     size_t maxSize_;  //maximum size of database
 200     caddr_t dbStart_; //address where the database is mapped
 201 };
 202
 203
 204 class CINDEX
 205 {
 206     public:
 207     char indName_[IDENTIFIER_LENGTH];
 208     int tblID_;      //table id of the table
 209     void* tblPtr_;    //pointer to tuple in catalog table TABLE
 210     IndexType indexType_;
 211     void* chunkPtr_; //pointer to the index chunk
 212     int numFlds_;
 213     int noOfBuckets_;
 214     bool isUnique_;
 215     void *hashNodeChunk_;
 216     void *fstIndFld_;//pointer to fisrt index field
 217 };
 218
 219 class CatalogTableINDEX
 220 {
 221     Database *systemDatabase_;
 222     public:
 223     CatalogTableINDEX(Database *db) { systemDatabase_  = db; }
 224
 225
 226     //last arg is OUT parameter which will give the pointer to
 227     //the index tuple
 228     DbRetVal insert(const char *name, void *tblPtr, int numFlds, bool isUnique,
 229                      void* chunk, int bucketSize, void *hChunk, void *&tupleptr);
 230
 231     //Second argument is OUT parameter which will contain the
 232     //chunk pointer of this table
 233     //Third argument is OUT parameter which will contain the
 234     //pointer to the removed tuple
 235     DbRetVal remove(const char *name, void *&chunk, void *&hchunk, void *&iptr);
 236     DbRetVal get(const char *name, void *&chunk, void *&hchunk, void *&iptr);
 237     DbRetVal setChunkPtr(const char *name, ObjectType tp, void *chunk, void *firstPage, void *curPage);
 238
 239     //get the number of indexes on table pointed by tblPtr
 240     int getNumIndexes(void *tblPtr);
 241
 242     char* getIndexName(void *tblPtr, int pos);
 243
 244     //gets all the index ptrs as array for the table pointed by tblPtr
 245     void getIndexPtrs(void *tblPtr, char **&array);
 246
 247     static ChunkIterator getIterator(void *iptr);
 248     static int getNoOfBuckets(void *iptr);
 249     static int getUnique(void *iptr);
 250     static char* getName(void *iptr);
 251     static int getOffsetOfFirstField(void *iptr);
 252     static IndexType getType(void *iptr);
 253 };
 254
 255
 256 class CINDEXFIELD
 257 {
 258     public:
 259     void* indexPtr; //pointer to tuple in catalog table INDEX
 260     void* tablePtr; //pointer to tuple in catalog table TABLE
 261     void* fieldPtr; //pointer to tuple in catalog table FIELD
 262     CINDEXFIELD *next;
 263 };
 264
 265 class CatalogTableINDEXFIELD
 266 {
 267     Database *systemDatabase_;
 268     public:
 269     CatalogTableINDEXFIELD(Database *db) { systemDatabase_  = db; }
 270
 271     DbRetVal insert(FieldNameList &fldList, void *indexPtr,
 272                                void *tblPtr, char **&fptr);
 273
 274     DbRetVal remove(void *iptr);
 275
 276     DbRetVal getFieldNameAndType(void *iptr, char *&name, DataType &type);
 277     DbRetVal getFieldInfo(void *index, FieldList &list);
 278     void printAllIndex();
 279     ListIterator getIndexListIterater(char *name);
 280
 281 };
 282
 283 class CFK
 284 {
 285     public:
 286     char fkName_[IDENTIFIER_LENGTH];
 287     void* pkTblPtr_;
 288     void* fkTblPtr_;
 289 };
 290
 291 class CatalogTableFK
 292 {
 293     Database *systemDatabase_;
 294     public:
 295     CatalogTableFK(Database *db) { systemDatabase_  = db; }
 296     DbRetVal insert(char *name, void *tFkPtr,void *tPkPtr);
 297     DbRetVal remove(void *tptr);
 298     void *getFkCTable(void* tptr);
 299     int getNumFkTable(void *ctptr);
 300     bool isFkTable(void *ctptr);
 301     void getPkTableName(void *ctptr, char **&array);
 302     void getFkTableName(void *ctptr, char **&array);
 303     int getNoOfPkTable(void *ctptr);
 304     int getNoOfFkTable(void *ctptr);
 305     DbRetVal getPkFkFieldInfo(void *cpkptr, void *cfkptr, FieldNameList &pklist,FieldNameList &pklist1);
 306 };
 307
 308 class CFKFIELD
 309 {
 310    public:
 311    void* fkPtr_;//pointer to tuple in catalog table CFK
 312    void* pfFldPtr_;
 313    void* fkFldPtr_;
 314 };
 315
 316 class CatalogTableFKFIELD
 317 {
 318     Database *systemDatabase_;
 319     public:
 320     CatalogTableFKFIELD(Database *db) { systemDatabase_  = db; }
 321     DbRetVal insert(char *cFKName, char **fkFldPtrs, char **pkFldPtrs,int totalFld);
 322     DbRetVal remove(void *fptr);
 323 };
 324
 325 #endif