src/storage/FieldList.cxx

   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 #include<Table.h>
  17 #include<Index.h>
  18 #include<CatalogTables.h>
  19 #include<Lock.h>
  20 #include<Debug.h>
  21
  22 //does not check for duplicates
  23 DbRetVal FieldList::append(FieldDef fDef)
  24 {
  25     FieldNode *newNode = new FieldNode();
  26     newNode->fldDef = fDef;
  27     newNode->next = NULL;
  28     //If this is the first node, set it as head
  29     if (NULL == head) { head = newNode; return OK; }
  30
  31     FieldNode *iter = head;
  32     while (NULL != iter->next) iter = iter->next;
  33     iter->next = newNode;
  34     return OK;
  35 }
  36
  37
  38 DbRetVal FieldList::remove(const char* fldName)
  39 {
  40     if (NULL == head)
  41     {
  42         printError(ErrNotExists, "There are no elements in the list. Empty list");
  43         return ErrNotExists;
  44     }
  45     FieldNode *iter = head, *prev = head;
  46     while (iter->next != NULL)
  47     {
  48         if (0 == strcmp(iter->fldDef.fldName_, fldName))
  49         {
  50             prev->next = iter->next;
  51             delete iter;
  52         }
  53         prev = iter;
  54         iter = iter->next;
  55     }
  56     if( iter == head) // there is only one node in the list
  57     {
  58         if (0 == strcmp(iter->fldDef.fldName_, fldName))
  59         {
  60             delete head;
  61             head = NULL;
  62             return OK;
  63         }
  64
  65     }
  66     if( prev == head) // there are only two node in the list
  67     {
  68         if (0 == strcmp(iter->fldDef.fldName_, fldName))
  69         {
  70             head->next = NULL;
  71             delete iter;
  72             return OK;
  73         }
  74     }
  75     printError(ErrNotFound, "There are no elements in the list");
  76     return ErrNotFound;
  77 }
  78
  79 DbRetVal FieldList::removeAll()
  80 {
  81     if (NULL == head) return OK;
  82     FieldNode *iter = head, *next = head;
  83     while (iter->next != NULL)
  84     {
  85         next = iter->next;
  86         delete iter;
  87         iter = next;
  88     }
  89     delete iter;  //deleting the last element
  90     head = NULL;
  91     return OK;
  92 }
  93
  94 int FieldList::size()
  95 {
  96     int size = 0;
  97     FieldNode *iter = head;
  98     while (iter!= NULL)
  99     {
 100        size++;
 101        iter = iter->next;
 102     }
 103     return size;
 104 }
 105
 106 //-1->if val is passed NULL
 107 //-2->if fld is not present
 108 DbRetVal FieldList::updateBindVal(const char *fldName, void *val,
 109                                                            bool isNullExplicit)
 110 {
 111     if (NULL == val && isNullExplicit == false)
 112     {
 113         printError(ErrBadArg, "Value passed is NULL");
 114         return ErrBadArg;
 115     }
 116     FieldNode *iter = head;
 117     while(NULL != iter)
 118     {
 119         if (strcmp(iter->fldDef.fldName_, fldName) == 0)
 120         {
 121             if (NULL == val) iter->fldDef.isNullExplicit_ = true;
 122             else iter->fldDef.bindVal_ = val;
 123             return OK;
 124         }
 125         iter = iter ->next;
 126     }
 127     printError(ErrNotFound, "Field not present in the list");
 128     return ErrNotFound;
 129 }
 130
 131 void *FieldList::getBindField(const char *fldName)
 132 {
 133         FieldNode *iter = head;
 134         while(NULL != iter)
 135         {
 136             if (strcmp(iter->fldDef.fldName_, fldName) == 0)
 137             {
 138                 return  iter->fldDef.bindVal_;
 139             }
 140             iter = iter ->next;
 141         }
 142         printError(ErrNotFound, "Field not present in the list");
 143         return NULL;
 144 }
 145
 146 void FieldList::fillFieldInfo(int fldpos, void *inp)
 147 {
 148     int pos=0;
 149     FieldNode *iter = head;
 150     while (pos <fldpos) { iter = iter->next; pos++; }
 151     FieldInfoValue *info = (FieldInfoValue*) inp;
 152     strcpy(info->fldName , iter->fldDef.fldName_);
 153     info->length = iter->fldDef.length_;
 154     info->type   = iter->fldDef.type_;
 155     info->offset = iter->fldDef.offset_;
 156     info->isNullable = iter->fldDef.isNull_;
 157     info->isPrimary = iter->fldDef.isPrimary_;
 158     info->isUnique = iter->fldDef.isUnique_;
 159     info->isAutoIncrement = iter->fldDef.isAutoIncrement_;
 160 }
 161
 162 DbRetVal FieldList::getFieldInfo(const char *fldName, FieldInfo *&info)
 163 {
 164
 165     FieldNode *iter = head;
 166     if ('*' == fldName[0])
 167     {
 168         //the above is for count(*)
 169         strcpy(info->fldName , iter->fldDef.fldName_);
 170         info->length = iter->fldDef.length_;
 171         info->type   = iter->fldDef.type_;
 172         info->offset = iter->fldDef.offset_;
 173         info->isDefault = iter->fldDef.isDefault_;
 174         if (info->isDefault)
 175             strcpy(info->defaultValueBuf, iter->fldDef.defaultValueBuf_);
 176         info->isNull = iter->fldDef.isNull_;
 177         info->isPrimary = iter->fldDef.isPrimary_;
 178         info->isUnique = iter->fldDef.isUnique_;
 179         info->isAutoIncrement = iter->fldDef.isAutoIncrement_;
 180         return OK;
 181
 182     }
 183     while(iter != NULL)
 184     {
 185         if (0 == strcmp(iter->fldDef.fldName_, fldName))
 186         {
 187             strcpy(info->fldName , iter->fldDef.fldName_);
 188             info->length = iter->fldDef.length_;
 189             info->type   = iter->fldDef.type_;
 190             info->offset = iter->fldDef.offset_;
 191             info->isDefault = iter->fldDef.isDefault_;
 192             strcpy(info->defaultValueBuf, iter->fldDef.defaultValueBuf_);
 193             info->isNull = iter->fldDef.isNull_;
 194             info->isPrimary = iter->fldDef.isPrimary_;
 195             info->isUnique = iter->fldDef.isUnique_;
 196             info->isAutoIncrement = iter->fldDef.isAutoIncrement_;
 197             return OK;
 198         }
 199         iter = iter ->next;
 200     }
 201     return ErrNotFound;
 202 }
 203
 204 int FieldList::getFieldOffset(const char *fldName)
 205 {
 206     FieldNode *iter = head;
 207     int offset = 0;
 208     while(iter != NULL)
 209     {
 210         if (0 == strcmp(iter->fldDef.fldName_, fldName))
 211         {
 212             return offset;
 213         }
 214         if (iter->fldDef.type_ != typeVarchar)
 215             offset = offset + iter->fldDef.length_;
 216         else offset = offset + sizeof(void *);
 217         iter = iter ->next;
 218         }
 219         return -1;
 220 }
 221
 222 int FieldList::getFieldOffset(int fldpos)
 223 {
 224     if (fldpos < 1) return -1;
 225     FieldNode *iter = head;
 226     int offset = 0;
 227     int counter =0;
 228     while(iter != NULL)
 229     {
 230         if (counter == fldpos -1)
 231         {
 232             return offset;
 233         }
 234         if (iter->fldDef.type_ != typeVarchar)
 235             offset = offset + iter->fldDef.length_;
 236         else offset = offset + sizeof(void *);
 237         iter = iter ->next;
 238         counter++;
 239     }
 240     return -1;
 241 }
 242
 243 //Returns position of field in the list
 244 //Count starting from 1
 245 //-1 if field not found in the list
 246 int FieldList::getFieldPosition(const char *fldName)
 247 {
 248     char onlyFldName[IDENTIFIER_LENGTH];
 249     Table::getFieldNameAlone((char*)fldName, onlyFldName);
 250     int position = 1;
 251     FieldNode *iter = head;
 252     while(iter != NULL)
 253     {
 254         if (0 == strcmp(iter->fldDef.fldName_, onlyFldName))
 255             return position;
 256         position++;
 257         iter  = iter->next;
 258     }
 259
 260     return -1;
 261 }
 262
 263 int FieldList::getTupleSize()
 264 {
 265     FieldNode *iter = head;
 266     int offset = 0;
 267     while(iter != NULL)
 268     {
 269         if (iter->fldDef.type_ == typeVarchar) offset += sizeof(void *);
 270         else offset = offset + iter->fldDef.length_;
 271         iter = iter->next;
 272     }
 273     return offset;
 274 }
 275
 276
 277
 278 DataType FieldList::getFieldType(const char *fldName)
 279 {
 280     FieldNode *iter = head;
 281     int offset = 0;
 282     while(iter != NULL)
 283     {
 284         if (0 == strcmp(iter->fldDef.fldName_, fldName))
 285         {
 286             return iter->fldDef.type_;
 287         }
 288         iter = iter ->next;
 289         }
 290     return typeUnknown;
 291 }
 292
 293 //-1->if field not present in list
 294 size_t FieldList::getFieldLength(const char *fldName)
 295 {
 296     FieldNode *iter = head;
 297     int offset = 0;
 298     while(iter != NULL)
 299     {
 300         if (0 == strcmp(iter->fldDef.fldName_, fldName))
 301         {
 302             return iter->fldDef.length_;
 303         }
 304         iter = iter ->next;
 305     }
 306     return -1;
 307 }
 308
 309
 310 //No check for duplicates
 311 //TODO::User exposed so check for duplicates
 312 DbRetVal FieldNameList::append(const char *name)
 313 {
 314     FieldNameNode *newNode = new FieldNameNode();
 315     strcpy(newNode->fldName, name);
 316     newNode->next = NULL;
 317     //If this is the first node, set it as head
 318     if (NULL == head) { head = newNode; return OK; }
 319
 320     FieldNameNode *it = head;
 321     while (NULL != it->next) it = it->next;
 322     it->next = newNode;
 323     return OK;
 324 }
 325
 326 //-1 -> if there is nothing in list
 327 //-2 -> if it is not present in list
 328 DbRetVal FieldNameList::remove(const char* name)
 329 {
 330     if (NULL == head)
 331     {
 332             printError(ErrNotExists, "List is empty");
 333             return ErrNotExists;
 334         }
 335     FieldNameNode *ite = head, *prev = head;
 336     while (ite->next != NULL)
 337     {
 338         if (0 == strcmp(ite->fldName, name))
 339         {
 340             prev->next = ite->next;
 341             delete ite;
 342         }
 343         prev = ite;
 344         ite = ite->next;
 345     }
 346     if( ite == head) // there is only one node in the list
 347     {
 348         if (0 == strcmp(ite->fldName, name))
 349         {
 350             delete head;
 351             head = NULL;
 352             return OK;
 353         }
 354
 355     }
 356     if( prev == head) // there are only two node in the list
 357     {
 358         if (0 == strcmp(ite->fldName, name))
 359         {
 360             head->next = NULL;
 361             delete ite;
 362             return OK;
 363         }
 364     }
 365         printError(ErrNotFound, "Field name %s not present in the list", name);
 366         return ErrNotFound;
 367 }
 368
 369 DbRetVal FieldNameList::removeAll()
 370 {
 371     if (NULL == head) return OK;
 372     FieldNameNode *iter = head, *next = head;
 373     while (iter->next != NULL)
 374     {
 375         next = iter->next;
 376         delete iter;
 377         iter = next;
 378     }
 379     delete iter;  //deleting the last element
 380     head = NULL;
 381     return OK;
 382 }
 383
 384 char* FieldNameList::nextFieldName()
 385 {
 386     if (iter == NULL) return NULL;
 387     FieldNameNode *node = iter;
 388     iter = iter ->next;
 389     return node->fldName;
 390 }
 391
 392 int FieldNameList::size()
 393 {
 394     FieldNameNode *it = head;
 395     if (NULL == it) return 0;
 396     int count = 1;
 397     while (NULL != it->next) {it = it->next; count++;}
 398     return count;
 399 }