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 DbRetVal FieldList::getFieldInfo(const char *fldName, FieldInfo *&info)
 131 {
 132
 133     FieldNode *iter = head;
 134     while(iter != NULL)
 135     {
 136         if (0 == strcmp(iter->fldDef.fldName_, fldName))
 137         {
 138             strcpy(info->fldName , iter->fldDef.fldName_);
 139             info->length = iter->fldDef.length_;
 140             info->type   = iter->fldDef.type_;
 141             info->offset = iter->fldDef.offset_;
 142             info->isDefault = iter->fldDef.isDefault_;
 143             strcpy(info->defaultValueBuf, iter->fldDef.defaultValueBuf_);
 144             info->isNull = iter->fldDef.isNull_;
 145             info->isPrimary = iter->fldDef.isPrimary_;
 146             info->isUnique = iter->fldDef.isUnique_;
 147             return OK;
 148         }
 149         iter = iter ->next;
 150     }
 151     return ErrNotFound;
 152 }
 153
 154 int FieldList::getFieldOffset(const char *fldName)
 155 {
 156     FieldNode *iter = head;
 157     int offset = 0;
 158     while(iter != NULL)
 159     {
 160         if (0 == strcmp(iter->fldDef.fldName_, fldName))
 161         {
 162             return offset;
 163         }
 164         offset = offset + os::align(iter->fldDef.length_);
 165         iter = iter ->next;
 166         }
 167         return -1;
 168 }
 169 int FieldList::getFieldOffset(int fldpos)
 170 {
 171     if (fldpos < 1) return -1;
 172     FieldNode *iter = head;
 173     int offset = 0;
 174     int counter =0;
 175     while(iter != NULL)
 176     {
 177         if (counter == fldpos -1)
 178         {
 179             return offset;
 180         }
 181         offset = offset + os::align(iter->fldDef.length_);
 182         iter = iter ->next;
 183         counter++;
 184     }
 185     return -1;
 186 }
 187
 188 //Returns position of field in the list
 189 //Count starting from 1
 190 //-1 if field not found in the list
 191 int FieldList::getFieldPosition(const char *fldName)
 192 {
 193     int position = 1;
 194     FieldNode *iter = head;
 195     while(iter != NULL)
 196     {
 197         if (0 == strcmp(iter->fldDef.fldName_, fldName))
 198             return position;
 199         position++;
 200         iter  = iter->next;
 201     }
 202
 203     return -1;
 204 }
 205
 206 int FieldList::getTupleSize()
 207 {
 208     FieldNode *iter = head;
 209     int offset = 0;
 210     while(iter != NULL)
 211     {
 212         offset = offset + os::align(iter->fldDef.length_);
 213         iter = iter ->next;
 214     }
 215     return offset;
 216 }
 217
 218
 219
 220 DataType FieldList::getFieldType(const char *fldName)
 221 {
 222     FieldNode *iter = head;
 223     int offset = 0;
 224     while(iter != NULL)
 225     {
 226         if (0 == strcmp(iter->fldDef.fldName_, fldName))
 227         {
 228             return iter->fldDef.type_;
 229         }
 230         iter = iter ->next;
 231         }
 232     return typeUnknown;
 233 }
 234
 235 //-1->if field not present in list
 236 size_t FieldList::getFieldLength(const char *fldName)
 237 {
 238     FieldNode *iter = head;
 239     int offset = 0;
 240     while(iter != NULL)
 241     {
 242         if (0 == strcmp(iter->fldDef.fldName_, fldName))
 243         {
 244             return iter->fldDef.length_;
 245         }
 246         iter = iter ->next;
 247     }
 248     return -1;
 249 }
 250
 251
 252 //No check for duplicates
 253 //TODO::User exposed so check for duplicates
 254 DbRetVal FieldNameList::append(const char *name)
 255 {
 256     FieldNameNode *newNode = new FieldNameNode();
 257     strcpy(newNode->fldName, name);
 258     newNode->next = NULL;
 259     //If this is the first node, set it as head
 260     if (NULL == head) { head = newNode; return OK; }
 261
 262     FieldNameNode *it = head;
 263     while (NULL != it->next) it = it->next;
 264     it->next = newNode;
 265     return OK;
 266 }
 267 //-1 -> if there is nothing in list
 268 //-2 -> if it is not present in list
 269 DbRetVal FieldNameList::remove(const char* name)
 270 {
 271     if (NULL == head)
 272     {
 273             printError(ErrNotExists, "List is empty");
 274             return ErrNotExists;
 275         }
 276     FieldNameNode *ite = head, *prev = head;
 277     while (ite->next != NULL)
 278     {
 279         if (0 == strcmp(ite->fldName, name))
 280         {
 281             prev->next = ite->next;
 282             delete ite;
 283         }
 284         prev = ite;
 285         ite = ite->next;
 286     }
 287     if( ite == head) // there is only one node in the list
 288     {
 289         if (0 == strcmp(ite->fldName, name))
 290         {
 291             delete head;
 292             head = NULL;
 293             return OK;
 294         }
 295
 296     }
 297     if( prev == head) // there are only two node in the list
 298     {
 299         if (0 == strcmp(ite->fldName, name))
 300         {
 301             head->next = NULL;
 302             delete ite;
 303             return OK;
 304         }
 305     }
 306         printError(ErrNotFound, "Field name %s not present in the list", name);
 307         return ErrNotFound;
 308 }
 309
 310 DbRetVal FieldNameList::removeAll()
 311 {
 312     if (NULL == head) return OK;
 313     FieldNameNode *iter = head, *next = head;
 314     while (iter->next != NULL)
 315     {
 316         next = iter->next;
 317         delete iter;
 318         iter = next;
 319     }
 320     delete iter;  //deleting the last element
 321     head = NULL;
 322     return OK;
 323 }
 324
 325 char* FieldNameList::nextFieldName()
 326 {
 327     if (iter == NULL) return NULL;
 328     FieldNameNode *node = iter;
 329     iter = iter ->next;
 330     return node->fldName;
 331 }
 332
 333 int FieldNameList::size()
 334 {
 335     FieldNameNode *it = head;
 336     if (NULL == it) return 0;
 337     int count = 1;
 338     while (NULL != it->next) {it = it->next; count++;}
 339     return count;
 340 }