src/sql/SelStatement.cxx

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by Prabakaran Thirumalai   *
   3  *   praba_tuty@yahoo.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 "Statement.h"
  17
  18 SelStatement::SelStatement()
  19 {
  20     parsedData = NULL;
  21     dbMgr = NULL;
  22     table = NULL;
  23     params = NULL;
  24     paramValues = NULL;
  25     totalParams = 0;
  26     bindFields = NULL;
  27     bindFieldValues = NULL;
  28     totalFields = 0;
  29 }
  30
  31 SelStatement::~SelStatement()
  32 {
  33     if (table) {
  34         table->setCondition(NULL);
  35         if (dbMgr) dbMgr->closeTable(table);
  36     }
  37     if (totalParams) {
  38         free(params);
  39         params =  NULL;
  40         free(paramValues);
  41         paramValues = NULL;
  42     }
  43     if (totalFields)
  44     {
  45         free(bindFields);
  46         bindFields =  NULL;
  47         free(bindFieldValues);
  48         bindFieldValues = NULL;
  49
  50     }
  51 }
  52 DbRetVal SelStatement::getParamFldInfo(int paramNo, FieldInfo *&info)
  53 {
  54     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
  55     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
  56     if (NULL == cValue)
  57     {
  58         printError(ErrSysFatal, "condition value is null. Should never happen");
  59         return ErrSysFatal;
  60     }
  61     info->type = cValue->type;
  62     info->length = cValue->length;
  63     return OK;
  64 }
  65 DbRetVal SelStatement::execute(int &rowsAffected)
  66 {
  67     DbRetVal rv = OK;
  68     //copy param values to binded buffer
  69     ConditionValue *value;
  70     for (int i = 0; i < totalParams; i ++)
  71     {
  72         value = (ConditionValue*) params[i];
  73         if (paramValues[i] == NULL)
  74         {
  75             continue;
  76             //printError(ErrBadCall, "param values not set");
  77             //return ErrBadCall;
  78         }
  79         AllDataType::copyVal(value->value, paramValues[i], value->type, value->length);
  80     }
  81     rv = table->execute();
  82     return rv;
  83 }
  84
  85 DbRetVal SelStatement::setParam(int paramNo, void *value)
  86 {
  87     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
  88     if (NULL == value) return ErrBadArg;
  89     paramValues[paramNo -1] = (char*) value;
  90     return OK;
  91 }
  92
  93 DbRetVal SelStatement::setShortParam(int paramNo, short value)
  94 {
  95     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
  96     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
  97     if (NULL == cValue)
  98     {
  99         printError(ErrSysFatal, "field value is null. Should never happen");
 100         return ErrSysFatal;
 101     }
 102     *(short*)cValue->value = value;
 103     return OK;
 104 }
 105
 106 DbRetVal SelStatement::setIntParam(int paramNo, int value)
 107 {
 108     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 109     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 110     if (NULL == cValue)
 111     {
 112         printError(ErrSysFatal, "condition value is null. Should never happen");
 113         return ErrSysFatal;
 114     }
 115     *(int*)cValue->value = value;
 116     return OK;
 117 }
 118 DbRetVal SelStatement::setLongParam(int paramNo, long value)
 119 {
 120     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 121     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 122     if (NULL == cValue)
 123     {
 124         printError(ErrSysFatal, "condition value is null. Should never happen");
 125         return ErrSysFatal;
 126     }
 127     *(long*)cValue->value = value;
 128     return OK;
 129 }
 130
 131 DbRetVal SelStatement::setLongLongParam(int paramNo, long long value)
 132 {
 133     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 134     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 135     if (NULL == cValue)
 136     {
 137         printError(ErrSysFatal, "condition value is null. Should never happen");
 138         return ErrSysFatal;
 139     }
 140     *(long long*)cValue->value = value;
 141     return OK;
 142 }
 143 DbRetVal SelStatement::setByteIntParam(int paramNo, ByteInt value)
 144 {
 145     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 146     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 147     if (NULL == cValue)
 148     {
 149         printError(ErrSysFatal, "condition value is null. Should never happen");
 150         return ErrSysFatal;
 151     }
 152     *(ByteInt*)cValue->value = value;
 153     return OK;
 154 }
 155 DbRetVal SelStatement::setFloatParam(int paramNo, float value)
 156 {
 157     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 158     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 159     if (NULL == cValue)
 160     {
 161         printError(ErrSysFatal, "condition value is null. Should never happen");
 162         return ErrSysFatal;
 163     }
 164     *(float*)cValue->value = value;
 165     return OK;
 166 }
 167 DbRetVal SelStatement::setDoubleParam(int paramNo, double value)
 168 {
 169     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 170     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 171     if (NULL == cValue)
 172     {
 173         printError(ErrSysFatal, "condition value is null. Should never happen");
 174         return ErrSysFatal;
 175     }
 176     *(double*)cValue->value = value;
 177     return OK;
 178 }
 179 DbRetVal SelStatement::setStringParam(int paramNo, char *value)
 180 {
 181     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 182     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 183     if (NULL == cValue)
 184     {
 185         printError(ErrSysFatal, "condition value is null. Should never happen");
 186         return ErrSysFatal;
 187     }
 188     strcpy((char*)cValue->value, value);
 189     return OK;
 190 }
 191 DbRetVal SelStatement::setDateParam(int paramNo, Date value)
 192 {
 193     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 194     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 195     if (NULL == cValue)
 196     {
 197         printError(ErrSysFatal, "condition value is null. Should never happen");
 198         return ErrSysFatal;
 199     }
 200     *(Date*)cValue->value = value;
 201     return OK;
 202 }
 203 DbRetVal SelStatement::setTimeParam(int paramNo, Time value)
 204 {
 205     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 206     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 207     if (NULL == cValue)
 208     {
 209         printError(ErrSysFatal, "condition value is null. Should never happen");
 210         return ErrSysFatal;
 211     }
 212     *(Time*)cValue->value = value;
 213     return OK;
 214 }
 215 DbRetVal SelStatement::setTimeStampParam(int paramNo, TimeStamp value)
 216 {
 217     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 218     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 219     if (NULL == cValue)
 220     {
 221         printError(ErrSysFatal, "condition value is null. Should never happen");
 222         return ErrSysFatal;
 223     }
 224     *(TimeStamp*)cValue->value = value;
 225     return OK;
 226 }
 227
 228 DbRetVal SelStatement::setBinaryParam(int paramNo, void *value)
 229 {
 230     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 231     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 232     if (NULL == cValue)
 233     {
 234         printError(ErrSysFatal, "condition value is null. Should never happen");
 235         return ErrSysFatal;
 236     }
 237     memcpy(cValue->value, value, 2 * cValue->length);
 238     return OK;
 239 }
 240
 241 DbRetVal SelStatement::setBindField(int colNo, void *value)
 242 {
 243     if (colNo <=0) return ErrBadArg;
 244     //TODO: check the upper limit
 245     //if (colNo > table->getFieldNameList().size()) return ErrBadArg;
 246     if (NULL == value) return ErrBadArg;
 247     bindFieldValues[colNo -1] = (char*) value;
 248     return OK;
 249 }
 250
 251 DbRetVal SelStatement::resolve()
 252 {
 253     if (dbMgr == NULL) return ErrNoConnection;
 254     //check whether the table exists
 255     table = dbMgr->openTable(parsedData->getTableName());
 256     if (table == NULL)
 257     {
 258         printError(ErrNotExists, "Unable to open the table:Table not exists");
 259         return ErrNotExists;
 260     }
 261     List fNameList = table->getFieldNameList();
 262     ListIterator fNameIter = fNameList.getIterator();
 263     Identifier *elem = NULL;
 264     if (fNameIter.hasElement())
 265         elem = (Identifier*) fNameIter.nextElement();
 266     if (elem == NULL)
 267     {
 268         printError(ErrNotExists, "No fields present in the table %s", parsedData->getTableName());
 269         return ErrNotExists;
 270     }
 271
 272     //get the fieldname list and validate field names
 273     ListIterator iter = parsedData->getFieldNameList().getIterator();
 274     FieldName *name = NULL;
 275     FieldInfo *fInfo = new FieldInfo();
 276     DbRetVal rv = OK;
 277     bool aggFlag = false;
 278     AggTableImpl *aggTable = NULL;
 279     //TODO::Projection should have only aggregates and field names in
 280     // group by list only
 281     int groupFieldListSize =  parsedData->getGroupFieldNameList().size();
 282     if (groupFieldListSize !=0) {
 283        aggTable = new AggTableImpl();
 284        aggTable->setTable(table);
 285        aggFlag = true;
 286     }
 287     bool isGroupFldInProjection = false;
 288     while (iter.hasElement())
 289     {
 290         name = (FieldName*)iter.nextElement();
 291         if (NULL == name)
 292         {
 293             dbMgr->closeTable(table);
 294             table = NULL;
 295             delete fInfo;
 296             printError(ErrSysFatal, "Should never happen. Field Name list has NULL");
 297             return ErrSysFatal;
 298         }
 299         if ('*' == name->fldName[0] && name->aType != AGG_COUNT)
 300         {
 301             iter.reset();
 302             while (iter.hasElement())
 303                 delete (FieldName *) iter.nextElement();
 304             rv = resolveStar();
 305             if (rv != OK)
 306             {
 307                 dbMgr->closeTable(table);
 308                 table = NULL;
 309                 delete fInfo;
 310                 return rv;
 311             }
 312             //as soon as it encounters *, it breaks the loop negleting other field names
 313             //as they all are deleted during resolveStar method.
 314             break;
 315         } else {
 316             if ('*' == name->fldName[0]) strcpy(name->fldName, elem->name);
 317             rv = table->getFieldInfo(name->fldName, fInfo);
 318             if (ErrNotFound == rv)
 319             {
 320                 dbMgr->closeTable(table);
 321                 table = NULL;
 322                 delete fInfo;
 323                 printError(ErrSyntaxError, "Field %s does not exist in table",
 324                                         name->fldName);
 325                 return ErrSyntaxError;
 326             }
 327             FieldValue *newVal = new FieldValue();
 328             newVal->parsedString = NULL;
 329             newVal->paramNo = 0;
 330             newVal->type = fInfo->type;
 331             newVal->length = fInfo->length;
 332         // for binary datatype input buffer size should be 2 times the length
 333             if(newVal->type == typeBinary)
 334                 newVal->value = AllDataType::alloc(fInfo->type, 2 * fInfo->length);
 335             else newVal->value = AllDataType::alloc(fInfo->type, fInfo->length);
 336             parsedData->insertFieldValue(newVal);
 337             if (name->aType == AGG_UNKNOWN) {
 338                 if (groupFieldListSize == 0) {
 339                     table->bindFld(name->fldName, newVal->value);
 340                 }else {
 341                     //delete newVal;
 342                     FieldName *groupFldName = NULL;
 343                     ListIterator giter = parsedData->getGroupFieldNameList().
 344                                                          getIterator();
 345                     while (giter.hasElement())
 346                     {
 347                         groupFldName = (FieldName*)giter.nextElement();
 348                         if (strcmp(groupFldName->fldName, name->fldName) ==0) {
 349                              isGroupFldInProjection = true;
 350                              aggTable->setGroup(name->fldName, newVal->value);
 351                          }
 352                     }
 353                     if (!isGroupFldInProjection)
 354                     {
 355                         printError(ErrSyntax, "Projection should contain only group fields\n");
 356                         delete fInfo;
 357                         dbMgr->closeTable(table);
 358                         table = NULL;
 359                         return ErrSyntax;
 360                     }
 361                 }
 362             } else {
 363                if (!aggFlag) {
 364                   aggTable = new AggTableImpl();
 365                   aggTable->setTable(table);
 366                   aggFlag = true;
 367                }
 368                aggTable->bindFld(name->fldName, name->aType, newVal->value);
 369             }
 370         }
 371     }
 372
 373     rv = setBindFieldAndValues();
 374     if (rv != OK)
 375     {
 376         delete fInfo;
 377         dbMgr->closeTable(table);
 378         table = NULL;
 379         return rv;
 380     }
 381
 382     table->setCondition(parsedData->getCondition());
 383
 384     rv = resolveForCondition();
 385     if (rv != OK)
 386     {
 387         delete fInfo;
 388         //TODO::free memory allocated for params
 389         table->setCondition(NULL);
 390         dbMgr->closeTable(table);
 391         table = NULL;
 392     }
 393     if(aggFlag && !isGroupFldInProjection) {
 394         ListIterator giter = parsedData->getGroupFieldNameList().getIterator();
 395         while (giter.hasElement())
 396         {
 397             name = (FieldName*)giter.nextElement();
 398             rv = table->getFieldInfo(name->fldName, fInfo);
 399             if (ErrNotFound == rv)
 400             {
 401                 dbMgr->closeTable(table);
 402                 table = NULL;
 403                 delete fInfo;
 404                 delete aggTable;
 405                 printError(ErrSyntaxError, "Field %s does not exist in table",
 406                                         name->fldName);
 407                 return ErrSyntaxError;
 408             }
 409             FieldValue *newVal = new FieldValue();
 410             newVal->parsedString = NULL;
 411             newVal->paramNo = 0;
 412             newVal->type = fInfo->type;
 413             newVal->length = fInfo->length;
 414         // for binary datatype input buffer size should be 2 times the length
 415                         if (newVal->type == typeBinary)
 416                 newVal->value = AllDataType::alloc(fInfo->type, 2 * fInfo->length);
 417             else newVal->value = AllDataType::alloc(fInfo->type, fInfo->length);
 418             parsedData->insertFieldValue(newVal);
 419             aggTable->setGroup(name->fldName, newVal->value);
 420         }
 421     }
 422     if (aggFlag) {
 423         table = aggTable;
 424     }
 425     delete fInfo;
 426     return rv;
 427 }
 428 DbRetVal SelStatement::resolveStar()
 429 {
 430     DbRetVal rv = OK;
 431     parsedData->clearFieldNameList();
 432     List fNameList = table->getFieldNameList();
 433     ListIterator fNameIter = fNameList.getIterator();
 434     FieldValue *newVal = NULL;
 435     //fNameList.resetIter(); //do not remove this.
 436     FieldInfo *fInfo = new FieldInfo();
 437     for (int i = 0; i < fNameList.size() ; i++)
 438     {
 439         char *fName = ((Identifier*)(fNameIter.nextElement()))->name;
 440         rv = table->getFieldInfo(fName, fInfo);
 441         if (ErrNotFound == rv)
 442         {
 443             delete fInfo;
 444             fNameList.reset();
 445             printError(ErrSysFatal, "Should never happen.");
 446             return ErrSysFatal;
 447         }
 448         newVal = new FieldValue();
 449         newVal->parsedString = NULL;
 450         newVal->paramNo = 0;
 451         newVal->type = fInfo->type;
 452         newVal->length = fInfo->length;
 453         // for binary datatype input buffer size should be 2 times the length
 454                 if(newVal->type == typeBinary)
 455             newVal->value = AllDataType::alloc(fInfo->type, 2 * fInfo->length);
 456         else newVal->value = AllDataType::alloc(fInfo->type, fInfo->length);
 457         parsedData->insertFieldValue(newVal);
 458         parsedData->insertField(fName);
 459         table->bindFld(fName, newVal->value);
 460     }
 461     fNameIter.reset();
 462     while (fNameIter.hasElement())
 463         delete (Identifier *) fNameIter.nextElement();
 464     fNameList.reset();
 465     delete fInfo;
 466     return OK;
 467 }
 468
 469 DbRetVal SelStatement::setBindFieldAndValues()
 470 {
 471     totalFields = parsedData->getFieldNameList().size();
 472     bindFields = (FieldValue**) malloc ( totalFields * sizeof(FieldValue*));
 473     bindFieldValues = (char**) malloc( totalFields * sizeof(char*));
 474     memset(bindFields, 0, totalFields * sizeof(FieldValue*));
 475     memset(bindFieldValues, 0, totalFields * sizeof(char*));
 476     ListIterator valIter = parsedData->getFieldValueList().getIterator();
 477     int colNo =0;
 478     FieldValue *value = NULL;
 479     valIter.reset();
 480     while(valIter.hasElement())
 481     {
 482         value = (FieldValue*) valIter.nextElement();
 483         if (value == NULL)
 484         {
 485             free(bindFields); bindFields = NULL;
 486             free(bindFieldValues); bindFieldValues = NULL;
 487             printError(ErrSysFatal, "Should never happen. value NULL after iteration");
 488             return ErrSysFatal;
 489         }
 490         bindFields[colNo++ ] = value;
 491     }
 492     return OK;
 493 }
 494
 495
 496 DbRetVal SelStatement::resolveForCondition()
 497 {
 498     //get the fieldname list and validate field names
 499     ListIterator iter = parsedData->getConditionValueList().getIterator();
 500
 501     ConditionValue *value;
 502     FieldInfo *fInfo = new FieldInfo();
 503     int paramPos =1;
 504     DbRetVal rv = OK;
 505     while (iter.hasElement())
 506     {
 507         value = (ConditionValue*) iter.nextElement();
 508         if (NULL == value)
 509         {
 510             delete fInfo;
 511             printError(ErrSysFatal, "Should never happen.");
 512             return ErrSysFatal;
 513         }
 514         rv = table->getFieldInfo(value->fName, fInfo);
 515         if (ErrNotFound == rv)
 516         {
 517             delete fInfo;
 518             printError(ErrSyntaxError, "Field %s does not exist in table",
 519                                         value->fName);
 520             return ErrSyntaxError;
 521         }
 522         value->type = fInfo->type;
 523         value->length = fInfo->length;
 524         value->value = AllDataType::alloc(fInfo->type, fInfo->length);
 525         //table->bindFld(name->fldName, value->value);
 526         if (value->parsedString == NULL)
 527         {
 528             delete fInfo;
 529             printError(ErrSyntaxError, "Condition value should not be NULL");
 530             return ErrSyntaxError;
 531         }
 532         if (value->parsedString[0] == '?')
 533         {
 534                     if(!value->opLike) // checks if 'LIKE' operator is used
 535                 value->paramNo = paramPos++;
 536         }
 537         if (!value->paramNo) {
 538                     // Here for binary dataType it is not strcpy'd bcos internally memcmp is done for predicates like f2 = 'abcd' where f2 is binary
 539             AllDataType::strToValue(value->value, value->parsedString, fInfo->type, fInfo->length);
 540                 }
 541     }
 542     delete fInfo;
 543     totalParams = paramPos -1;
 544     if (0 == totalParams) return OK;
 545     params = (void**) malloc ( totalParams * sizeof(FieldValue*));
 546     paramValues = (char**) malloc( totalParams * sizeof(char*));
 547     memset(params, 0, totalParams * sizeof(FieldValue*));
 548     memset(paramValues, 0, totalParams * sizeof(char*));
 549     iter.reset();
 550     while(iter.hasElement())
 551     {
 552         value = (ConditionValue*) iter.nextElement();
 553         if (value == NULL)
 554         {
 555             free(params); params = NULL;
 556             free(paramValues); paramValues = NULL;
 557             printError(ErrSysFatal, "Should never happen. value NULL after iteration");
 558             return ErrSysFatal;
 559         }
 560         params[value->paramNo -1 ] = value;
 561     }
 562     return OK;
 563 }
 564
 565 void* SelStatement::fetch()
 566 {
 567     void *tuple = table->fetch();
 568     if (NULL == tuple) return NULL;
 569     //copy values to binded buffer
 570     FieldValue *value;
 571     for (int i = 0; i < totalFields; i++)
 572     {
 573         value = bindFields[i];
 574         if (bindFieldValues[i] == NULL)
 575         {
 576             printError(ErrBadCall, "Fields are not binded properly. Should never happen");
 577             return NULL;
 578         }
 579                 AllDataType::copyVal(bindFieldValues[i], value->value, value->type, value->length);
 580     }
 581     return tuple;
 582 }
 583
 584 void* SelStatement::fetch(DbRetVal &rv)
 585 {
 586     void *tuple = table->fetch(rv);
 587     if (NULL == tuple) return NULL;
 588     //copy values to binded buffer
 589     FieldValue *value;
 590     for (int i = 0; i < totalFields; i++)
 591     {
 592         value = bindFields[i];
 593         if (bindFieldValues[i] == NULL)
 594         {
 595             printError(ErrBadCall, "Fields are not binded properly. Should never happen");
 596             return NULL;
 597         }
 598                 AllDataType::copyVal(bindFieldValues[i], value->value, value->type, value->length);
 599     }
 600     return tuple;
 601 }
 602
 603 DbRetVal SelStatement::close()
 604 {
 605     return table->close();
 606 }
 607 void* SelStatement::getParamValuePtr( int pos )
 608 {
 609     ConditionValue *p = (ConditionValue*) params [pos-1];
 610     return ( (void*) p->value );
 611 }
 612
 613 char* SelStatement::getFieldName ( int pos )
 614 {
 615     //TODO::if not yet prepared return error
 616     //TODO::check the upper limit for projpos
 617     ListIterator iter = parsedData->getFieldNameList().getIterator();
 618     int position =0;
 619     while (iter.hasElement())
 620     {
 621         if (position == pos) {
 622               FieldName *name = (FieldName*) iter.nextElement();
 623               if (NULL == name)
 624               {
 625                   printError(ErrSysFatal, "Should never happen. Field Name list has NULL");
 626                   return (char*) 0;
 627               }
 628               return name->fldName;
 629       }
 630         position++;
 631     }
 632     return (char*) 0;
 633 }
 634
 635 DataType SelStatement::getFieldType( int pos )
 636 {
 637     FieldValue *v = bindFields[pos];
 638     return ( (DataType) v->type );
 639 }
 640
 641 int SelStatement::getFieldLength( int pos )
 642 {
 643     FieldValue *v = bindFields[pos];
 644     return ( (int) v->type );
 645 }
 646
 647 void* SelStatement::fetchAndPrint(bool SQL)
 648 {
 649     void *tuple = table->fetch();
 650     if (NULL == tuple) return NULL;
 651     FieldValue *value;
 652     bool nullValueSet;
 653     char stmt[128];
 654     if (SQL) {
 655         sprintf(stmt, "INSERT INTO %s VALUES(", table->getName());
 656         printf("%s", stmt);
 657     }
 658     for (int i = 0; i < totalFields; i++)
 659     {
 660         value = bindFields[i];
 661         nullValueSet = table->isFldNull(i+1);
 662         if (nullValueSet)
 663             if (SQL) {
 664                 if (i==0)
 665                     printf("NULL");
 666                 else
 667                     printf(", NULL");
 668             }
 669             else printf("NULL\t");
 670         else  {
 671             if (SQL) {
 672                 switch(value->type)
 673                 {
 674                     case typeString:
 675                     case typeBinary:
 676                     case typeDate:
 677                     case typeTime:
 678                     case typeTimeStamp:
 679                     {
 680                         if (i==0)
 681                             printf(" '");
 682                         else
 683                             printf(", '");
 684                         break;
 685                     }
 686                     default:
 687                     {
 688                         if (i!=0)
 689                            printf(",");
 690                     }
 691                 }
 692             }
 693             AllDataType::printVal(value->value, value->type, value->length);
 694             if (SQL) {
 695                 switch(value->type)
 696                 {
 697                     case typeString:
 698                     case typeBinary:
 699                     case typeDate:
 700                     case typeTime:
 701                     case typeTimeStamp:
 702                         printf("'");
 703                 }
 704             } else printf("\t");
 705         }
 706     }
 707     if (SQL) printf(");\n");
 708     return tuple;
 709 }
 710
 711 void* SelStatement::next()
 712 {
 713     return( table->fetch() );
 714 }
 715
 716 void* SelStatement::getFieldValuePtr( int pos )
 717 {
 718     FieldValue *v = bindFields[pos];
 719     return ( (void*) v->value );
 720 }
 721
 722 int SelStatement::noOfProjFields()
 723 {
 724     return totalFields;
 725 }
 726
 727 DbRetVal SelStatement::getProjFldInfo (int projpos, FieldInfo *&fInfo)
 728 {
 729     //TODO::if not yet prepared return error
 730     //TODO::check the upper limit for projpos
 731     ListIterator iter = parsedData->getFieldNameList().getIterator();
 732     FieldName *name = NULL;
 733     DbRetVal rv = OK;
 734     int position =0;
 735     while (iter.hasElement())
 736     {
 737         name = (FieldName*)iter.nextElement();
 738         if (NULL == name)
 739         {
 740             printError(ErrSysFatal, "Should never happen. Field Name list has NULL");
 741             return ErrSysFatal;
 742         }
 743         if (position == projpos) break;
 744         position++;
 745     }
 746
 747     rv = table->getFieldInfo(name->fldName, fInfo);
 748 }