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 CatalogTableID
  34 {
  35     // chunk id 0 ->userChunkTable
  36     //
  37     // chunk id 10->DATABASE
  38     // chunk id 11->USER
  39     // chunk id 12->TABLE
  40     // chunk id 13->FIELD
  41     // chunk id 14->ACCESS
  42     // chunk id 15->INDEX
  43     // chunk id 16->INDEXFIELD
  44
  45     UserChunkTableId      =  0,
  46     LockTableHashBucketId =  1,
  47     LockTableMutexId      =  2,
  48     LockTableId           =  3,
  49     TransHasTableId       =  4,
  50     UndoLogTableID        =  5,
  51
  52
  53     DatabaseTableId  = 10,
  54     UserTableId      = 11,
  55     TableTableId     = 12,
  56     FieldTableId     = 13,
  57     AccessTableId    = 14,
  58     IndexTableId     = 15,
  59     IndexFieldTableId= 16
  60
  61 };
  62
  63
  64 class CTABLE
  65 {
  66     public:
  67     char tblName_[IDENTIFIER_LENGTH];
  68     int tblID_;
  69     size_t length_; //length of the tuple
  70     int numFlds_;
  71     int numIndexes_;
  72     void* chunkPtr_;
  73
  74 };
  75
  76 class CatalogTableTABLE
  77 {
  78     Database *systemDatabase_;
  79     public:
  80     CatalogTableTABLE(Database *db) { systemDatabase_  = db; }
  81
  82     //Last argument is OUT parameter which will contain the
  83     //pointer to the inserted tuple
  84     DbRetVal insert(const char *name, int id, size_t size,
  85                      int numFlds, void* chunk, void *&tptr);
  86
  87     //Second argument is OUT parameter which will contain the
  88     //chunk pointer of this table
  89     //Third argument is OUT parameter which will contain the
  90     //pointer to the removed tuple
  91     DbRetVal remove(const char *name, void *&chunk, void *&tptr);
  92
  93     DbRetVal getChunkAndTblPtr(const char *name, void *&chunk, void *&tptr);
  94
  95     List getTableList();
  96 };
  97
  98
  99 class CFIELD
 100 {
 101     public:
 102     char fldName_[IDENTIFIER_LENGTH];
 103     int tblID_;      //table id where this field resides
 104     void* tblPtr_;    //pointer to tuple in catalog table TABLE
 105     DataType type_;
 106     size_t length_;  //length of the field
 107     size_t offset_;  //offset (in bytes) into tuple
 108     //currently default value is supported for string and binary
 109     //less than length 32 bytes
 110     char defaultValueBuf_[DEFAULT_VALUE_BUF_LENGTH];
 111     bool isNull_;
 112     bool isPrimary_;
 113     bool isUnique_;
 114     bool isDefault_;
 115     int width_;
 116     int scale_;
 117 };
 118
 119 class CatalogTableFIELD
 120 {
 121     Database *systemDatabase_;
 122     public:
 123     CatalogTableFIELD(Database *db) { systemDatabase_  = db; }
 124
 125     //returns -1 on error
 126     DbRetVal insert(FieldIterator &iter, int tblID, void *tblPtr);
 127
 128     DbRetVal remove(void *tblPtr);
 129
 130     //II argument is OUT parameter
 131     //field list is populated from the catalog table for
 132     // the table pointed by tblPtr
 133     void getFieldInfo( void* tblPtr, FieldList &list);
 134
 135     //array is OUT param
 136     //returns the pointer to fields for the corresponding name
 137     //in field name list as an array
 138     DbRetVal getFieldPtrs(FieldNameList &fldList,void *tptr, char **&array);
 139 };
 140
 141 class CUSER
 142 {
 143     public:
 144     char userName_[IDENTIFIER_LENGTH];
 145     char password_[IDENTIFIER_LENGTH];
 146 };
 147
 148 class CatalogTableUSER
 149 {
 150     Database *systemDatabase_;
 151     public:
 152     CatalogTableUSER(Database *db) { systemDatabase_  = db; }
 153
 154     //returns -1 on error
 155     DbRetVal insert(const char *name, const char *pass);
 156     DbRetVal authenticate(const char *name, const char *pass,
 157                      bool &isAuthenticated, bool &isDba);
 158     DbRetVal remove(const char *name);
 159     DbRetVal changePass(const char *name, const char *pass);
 160
 161 };
 162
 163 class CACCESS
 164 {
 165     public:
 166     char userName_[IDENTIFIER_LENGTH];
 167     char dbName_[IDENTIFIER_LENGTH];
 168 };
 169
 170 class CDATABASEFILE
 171 {
 172     public:
 173     int dbID_;
 174     char dbName_[IDENTIFIER_LENGTH];
 175     int maxChunks_;
 176     size_t maxSize_;  //maximum size of database
 177     caddr_t dbStart_; //address where the database is mapped
 178 };
 179
 180
 181 class CINDEX
 182 {
 183     public:
 184     char indName_[IDENTIFIER_LENGTH];
 185     int tblID_;      //table id of the table
 186     void* tblPtr_;    //pointer to tuple in catalog table TABLE
 187     IndexType indexType_;
 188     void* chunkPtr_; //pointer to the index chunk
 189     int numFlds_;
 190     int noOfBuckets_;
 191     bool isUnique_;
 192     void *hashNodeChunk_;
 193     void *fstIndFld_;//pointer to fisrt index field
 194 };
 195
 196 class CatalogTableINDEX
 197 {
 198     Database *systemDatabase_;
 199     public:
 200     CatalogTableINDEX(Database *db) { systemDatabase_  = db; }
 201
 202
 203     //last arg is OUT parameter which will give the pointer to
 204     //the index tuple
 205     DbRetVal insert(const char *name, void *tblPtr, int numFlds, bool isUnique,
 206                      void* chunk, int bucketSize, void *hChunk, void *&tupleptr);
 207
 208     //Second argument is OUT parameter which will contain the
 209     //chunk pointer of this table
 210     //Third argument is OUT parameter which will contain the
 211     //pointer to the removed tuple
 212     DbRetVal remove(const char *name, void *&chunk, void *&hchunk, void *&iptr);
 213     DbRetVal get(const char *name, void *&chunk, void *&hchunk, void *&iptr);
 214
 215     //get the number of indexes on table pointed by tblPtr
 216     int getNumIndexes(void *tblPtr);
 217
 218     char* getIndexName(void *tblPtr, int pos);
 219
 220     //gets all the index ptrs as array for the table pointed by tblPtr
 221     void getIndexPtrs(void *tblPtr, char **&array);
 222
 223     static ChunkIterator getIterator(void *iptr);
 224     static int getNoOfBuckets(void *iptr);
 225     static int getUnique(void *iptr);
 226     static char* getName(void *iptr);
 227 };
 228
 229
 230 class CINDEXFIELD
 231 {
 232     public:
 233     void* indexPtr; //pointer to tuple in catalog table INDEX
 234     void* tablePtr; //pointer to tuple in catalog table TABLE
 235     void* fieldPtr; //pointer to tuple in catalog table FIELD
 236     CINDEXFIELD *next;
 237 };
 238
 239 class CatalogTableINDEXFIELD
 240 {
 241     Database *systemDatabase_;
 242     public:
 243     CatalogTableINDEXFIELD(Database *db) { systemDatabase_  = db; }
 244
 245     DbRetVal insert(FieldNameList &fldList, void *indexPtr,
 246                                void *tblPtr, char **&fptr);
 247
 248     DbRetVal remove(void *iptr);
 249
 250     DbRetVal getFieldNameAndType(void *iptr, char *&name, DataType &type);
 251     DbRetVal getFieldInfo(void *index, FieldList &list);
 252     void printAllIndex();
 253
 254 };
 255 #endif