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 //-1->if val is passed NULL
  95 //-2->if fld is not present
  96 DbRetVal FieldList::updateBindVal(const char *fldName, void *val )
  97 {
  98     if (NULL == val)
  99     {
 100         printError(ErrBadArg, "Value passed is NULL");
 101         return ErrBadArg;
 102     }
 103     FieldNode *iter = head;
 104     while(NULL != iter)
 105     {
 106         if (strcmp(iter->fldDef.fldName_, fldName) == 0)
 107         {
 108             iter->fldDef.bindVal_ = val;
 109             return OK;
 110         }
 111         iter = iter ->next;
 112     }
 113     printError(ErrNotFound, "Field not present in the list");
 114     return ErrNotFound;
 115 }
 116 void *FieldList::getBindField(const char *fldName)
 117 {
 118         FieldNode *iter = head;
 119         while(NULL != iter)
 120         {
 121             if (strcmp(iter->fldDef.fldName_, fldName) == 0)
 122             {
 123                 return  iter->fldDef.bindVal_;
 124             }
 125             iter = iter ->next;
 126         }
 127         printError(ErrNotFound, "Field not present in the list");
 128         return NULL;
 129 }
 130 void FieldList::fillFieldInfo(int fldpos, void *inp)
 131 {
 132     int pos=0;
 133     FieldNode *iter = head;
 134     while (pos <fldpos) { iter = iter->next; pos++; }
 135     FieldInfoValue *info = (FieldInfoValue*) inp;
 136     strcpy(info->fldName , iter->fldDef.fldName_);
 137     info->length = iter->fldDef.length_;
 138     info->type   = iter->fldDef.type_;
 139     info->offset = iter->fldDef.offset_;
 140     info->isNullable = iter->fldDef.isNull_;
 141     info->isPrimary = iter->fldDef.isPrimary_;
 142     info->isUnique = iter->fldDef.isUnique_;
 143     info->isAutoIncrement = iter->fldDef.isAutoIncrement_;
 144 }
 145
 146 DbRetVal FieldList::getFieldInfo(const char *fldName, FieldInfo *&info)
 147 {
 148
 149     FieldNode *iter = head;
 150     if ('*' == fldName[0])
 151     {
 152         //the above is for count(*)
 153         strcpy(info->fldName , iter->fldDef.fldName_);
 154         info->length = iter->fldDef.length_;
 155         info->type   = iter->fldDef.type_;
 156         info->offset = iter->fldDef.offset_;
 157         info->isDefault = iter->fldDef.isDefault_;
 158         strcpy(info->defaultValueBuf, iter->fldDef.defaultValueBuf_);
 159         info->isNull = iter->fldDef.isNull_;
 160         info->isPrimary = iter->fldDef.isPrimary_;
 161         info->isUnique = iter->fldDef.isUnique_;
 162         info->isAutoIncrement = iter->fldDef.isAutoIncrement_;
 163         return OK;
 164
 165     }
 166     while(iter != NULL)
 167     {
 168         if (0 == strcmp(iter->fldDef.fldName_, fldName))
 169         {
 170             strcpy(info->fldName , iter->fldDef.fldName_);
 171             info->length = iter->fldDef.length_;
 172             info->type   = iter->fldDef.type_;
 173             info->offset = iter->fldDef.offset_;
 174             info->isDefault = iter->fldDef.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         iter = iter ->next;
 183     }
 184     return ErrNotFound;
 185 }
 186
 187 int FieldList::getFieldOffset(const char *fldName)
 188 {
 189     FieldNode *iter = head;
 190     int offset = 0;
 191     while(iter != NULL)
 192     {
 193         if (0 == strcmp(iter->fldDef.fldName_, fldName))
 194         {
 195             return offset;
 196         }
 197         offset = offset + iter->fldDef.length_;
 198         iter = iter ->next;
 199         }
 200         return -1;
 201 }
 202 int FieldList::getFieldOffset(int fldpos)
 203 {
 204     if (fldpos < 1) return -1;
 205     FieldNode *iter = head;
 206     int offset = 0;
 207     int counter =0;
 208     while(iter != NULL)
 209     {
 210         if (counter == fldpos -1)
 211         {
 212             return offset;
 213         }
 214         offset = offset + iter->fldDef.length_;
 215         iter = iter ->next;
 216         counter++;
 217     }
 218     return -1;
 219 }
 220
 221 //Returns position of field in the list
 222 //Count starting from 1
 223 //-1 if field not found in the list
 224 int FieldList::getFieldPosition(const char *fldName)
 225 {
 226     char onlyFldName[IDENTIFIER_LENGTH];
 227     Table::getFieldNameAlone((char*)fldName, onlyFldName);
 228     int position = 1;
 229     FieldNode *iter = head;
 230     while(iter != NULL)
 231     {
 232         if (0 == strcmp(iter->fldDef.fldName_, onlyFldName))
 233             return position;
 234         position++;
 235         iter  = iter->next;
 236     }
 237
 238     return -1;
 239 }
 240
 241 int FieldList::getTupleSize()
 242 {
 243     FieldNode *iter = head;
 244     int offset = 0;
 245     while(iter != NULL)
 246     {
 247         offset = offset + iter->fldDef.length_;
 248         iter = iter ->next;
 249     }
 250     return offset;
 251 }
 252
 253
 254
 255 DataType FieldList::getFieldType(const char *fldName)
 256 {
 257     FieldNode *iter = head;
 258     int offset = 0;
 259     while(iter != NULL)
 260     {
 261         if (0 == strcmp(iter->fldDef.fldName_, fldName))
 262         {
 263             return iter->fldDef.type_;
 264         }
 265         iter = iter ->next;
 266         }
 267     return typeUnknown;
 268 }
 269
 270 //-1->if field not present in list
 271 size_t FieldList::getFieldLength(const char *fldName)
 272 {
 273     FieldNode *iter = head;
 274     int offset = 0;
 275     while(iter != NULL)
 276     {
 277         if (0 == strcmp(iter->fldDef.fldName_, fldName))
 278         {
 279             return iter->fldDef.length_;
 280         }
 281         iter = iter ->next;
 282     }
 283     return -1;
 284 }
 285
 286
 287 //No check for duplicates
 288 //TODO::User exposed so check for duplicates
 289 DbRetVal FieldNameList::append(const char *name)
 290 {
 291     FieldNameNode *newNode = new FieldNameNode();
 292     strcpy(newNode->fldName, name);
 293     newNode->next = NULL;
 294     //If this is the first node, set it as head
 295     if (NULL == head) { head = newNode; return OK; }
 296
 297     FieldNameNode *it = head;
 298     while (NULL != it->next) it = it->next;
 299     it->next = newNode;
 300     return OK;
 301 }
 302 //-1 -> if there is nothing in list
 303 //-2 -> if it is not present in list
 304 DbRetVal FieldNameList::remove(const char* name)
 305 {
 306     if (NULL == head)
 307     {
 308             printError(ErrNotExists, "List is empty");
 309             return ErrNotExists;
 310         }
 311     FieldNameNode *ite = head, *prev = head;
 312     while (ite->next != NULL)
 313     {
 314         if (0 == strcmp(ite->fldName, name))
 315         {
 316             prev->next = ite->next;
 317             delete ite;
 318         }
 319         prev = ite;
 320         ite = ite->next;
 321     }
 322     if( ite == head) // there is only one node in the list
 323     {
 324         if (0 == strcmp(ite->fldName, name))
 325         {
 326             delete head;
 327             head = NULL;
 328             return OK;
 329         }
 330
 331     }
 332     if( prev == head) // there are only two node in the list
 333     {
 334         if (0 == strcmp(ite->fldName, name))
 335         {
 336             head->next = NULL;
 337             delete ite;
 338             return OK;
 339         }
 340     }
 341         printError(ErrNotFound, "Field name %s not present in the list", name);
 342         return ErrNotFound;
 343 }
 344
 345 DbRetVal FieldNameList::removeAll()
 346 {
 347     if (NULL == head) return OK;
 348     FieldNameNode *iter = head, *next = head;
 349     while (iter->next != NULL)
 350     {
 351         next = iter->next;
 352         delete iter;
 353         iter = next;
 354     }
 355     delete iter;  //deleting the last element
 356     head = NULL;
 357     return OK;
 358 }
 359
 360 char* FieldNameList::nextFieldName()
 361 {
 362     if (iter == NULL) return NULL;
 363     FieldNameNode *node = iter;
 364     iter = iter ->next;
 365     return node->fldName;
 366 }
 367
 368 int FieldNameList::size()
 369 {
 370     FieldNameNode *it = head;
 371     if (NULL == it) return 0;
 372     int count = 1;
 373     while (NULL != it->next) {it = it->next; count++;}
 374     return count;
 375 }