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