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