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