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 <os.h>
  17 #include <Statement.h>
  18 #include <TableImpl.h>
  19 #include <OrderTableImpl.h>
  20
  21 SelStatement::SelStatement()
  22 {
  23     parsedData = NULL;
  24     dbMgr = NULL;
  25     table = NULL;
  26     params = NULL;
  27     paramValues = NULL;
  28     totalParams = 0;
  29     bindFields = NULL;
  30     bindFieldValues = NULL;
  31     totalFields = 0;
  32     isPointReturned = false;
  33     handleAggWithTbl=false;
  34     numRecords = 0;
  35     isOffsetReached = false;
  36     isRecLimitReached = false;
  37     isExplain=false;
  38     isJoin=false;
  39 }
  40
  41 SelStatement::~SelStatement()
  42 {
  43     close();
  44     if (table) { table->close(); table = NULL; }
  45     if (totalParams) {
  46         free(params);
  47         params =  NULL;
  48         free(paramValues);
  49         paramValues = NULL;
  50     }
  51     if (totalFields)
  52     {
  53         free(bindFields);
  54         bindFields =  NULL;
  55         free(bindFieldValues);
  56         bindFieldValues = NULL;
  57
  58     }
  59 }
  60 DbRetVal SelStatement::getParamFldInfo(int paramNo, FieldInfo *&info)
  61 {
  62     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
  63     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
  64     if (NULL == cValue)
  65     {
  66         printError(ErrSysFatal, "condition value is null. Should never happen");
  67         return ErrSysFatal;
  68     }
  69     table->getFieldNameAlone(cValue->fName,info->fldName);
  70     info->type = cValue->type;
  71     info->length = cValue->length;
  72     info->isNull = cValue->isNullable;
  73     return OK;
  74 }
  75 DbRetVal SelStatement::execute(int &rowsAffected)
  76 {
  77     DbRetVal rv = OK;
  78     //copy param values to binded buffer
  79     ConditionValue *value;
  80     for (int i = 0; i < totalParams; i ++)
  81     {
  82         value = (ConditionValue*) params[i];
  83         if (paramValues[i] == NULL)
  84         {
  85             continue;
  86             //printError(ErrBadCall, "param values not set");
  87             //return ErrBadCall;
  88         }
  89         AllDataType::copyVal(value->value, paramValues[i], value->type, value->length);
  90     }
  91     //table->printPlan(0);
  92     //printf("Execute Called\n");
  93     rv = table->execute();
  94     numRecords = 0;
  95     isOffsetReached = false;
  96     isRecLimitReached = false;
  97
  98     if (isExplain) table->printPlan(0);
  99     return rv;
 100 }
 101
 102 DbRetVal SelStatement::setParam(int paramNo, void *value)
 103 {
 104     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 105     if (NULL == value) return ErrBadArg;
 106     paramValues[paramNo -1] = (char*) value;
 107     return OK;
 108 }
 109
 110 DbRetVal SelStatement::setShortParam(int paramNo, short value)
 111 {
 112     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 113     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 114     if (NULL == cValue)
 115     {
 116         printError(ErrSysFatal, "field value is null. Should never happen");
 117         return ErrSysFatal;
 118     }
 119     *(short*)cValue->value = value;
 120     return OK;
 121 }
 122
 123 DbRetVal SelStatement::setIntParam(int paramNo, int 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     *(int*)cValue->value = value;
 133     return OK;
 134 }
 135 DbRetVal SelStatement::setLongParam(int paramNo, long value)
 136 {
 137     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 138     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 139     if (NULL == cValue)
 140     {
 141         printError(ErrSysFatal, "condition value is null. Should never happen");
 142         return ErrSysFatal;
 143     }
 144     *(long*)cValue->value = value;
 145     return OK;
 146 }
 147
 148 DbRetVal SelStatement::setLongLongParam(int paramNo, long long 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     *(long long*)cValue->value = value;
 158     return OK;
 159 }
 160 DbRetVal SelStatement::setByteIntParam(int paramNo, ByteInt 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     *(ByteInt*)cValue->value = value;
 170     return OK;
 171 }
 172 DbRetVal SelStatement::setFloatParam(int paramNo, float 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     *(float*)cValue->value = value;
 182     return OK;
 183 }
 184 DbRetVal SelStatement::setDoubleParam(int paramNo, double 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     *(double*)cValue->value = value;
 194     return OK;
 195 }
 196 DbRetVal SelStatement::setStringParam(int paramNo, char *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     strcpy((char*)cValue->value, value);
 206     return OK;
 207 }
 208 DbRetVal SelStatement::setDateParam(int paramNo, Date 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     *(Date*)cValue->value = value;
 218     return OK;
 219 }
 220 DbRetVal SelStatement::setTimeParam(int paramNo, Time 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     *(Time*)cValue->value = value;
 230     return OK;
 231 }
 232 DbRetVal SelStatement::setTimeStampParam(int paramNo, TimeStamp value)
 233 {
 234     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 235     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 236     if (NULL == cValue)
 237     {
 238         printError(ErrSysFatal, "condition value is null. Should never happen");
 239         return ErrSysFatal;
 240     }
 241     *(TimeStamp*)cValue->value = value;
 242     return OK;
 243 }
 244
 245 DbRetVal SelStatement::setBinaryParam(int paramNo, void *value, int length)
 246 {
 247     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 248     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 249     if (NULL == cValue)
 250     {
 251         printError(ErrSysFatal, "condition value is null. Should never happen");
 252         return ErrSysFatal;
 253     }
 254     AllDataType::convertToBinary(cValue->value,value,typeString,cValue->length);
 255     return OK;
 256 }
 257
 258 DbRetVal SelStatement::setBindField(int colNo, void *value)
 259 {
 260     if (colNo <=0) return ErrBadArg;
 261     //TODO: check the upper limit
 262     //if (colNo > table->getFieldNameList().size()) return ErrBadArg;
 263     if (NULL == value) return ErrBadArg;
 264     bindFieldValues[colNo -1] = (char*) value;
 265     return OK;
 266 }
 267 bool SelStatement::isTableAlreadyPresent(char *tblName, char *aliasName)
 268 {
 269     ListIterator titer = parsedData->getTableNameList().getIterator();
 270     int count =0;
 271     while (titer.hasElement())
 272     {
 273         TableName *t  = (TableName*)titer.nextElement();
 274         if (strcmp(t->tblName, tblName) ==0 &&
 275             strcmp(t->aliasName, aliasName) ==0) count++;
 276     }
 277     if (count == 1) return false;
 278     return true;
 279 }
 280 DbRetVal SelStatement::openTables()
 281 {
 282     if (dbMgr == NULL) return ErrNoConnection;
 283     JoinTableImpl *jHdl = NULL;
 284     Table *tHdl = NULL, *prevHdl = NULL;
 285     isJoin = false;
 286     //check whether all the table exists
 287     ListIterator titer = parsedData->getTableNameList().getIterator();
 288     ListIterator jiter = parsedData->getJoinTypeList().getIterator();
 289     while (titer.hasElement())
 290     {
 291         TableName *t  = (TableName*)titer.nextElement();
 292         parsedData->setTableName(t->tblName);
 293         if (isTableAlreadyPresent(t->tblName, t->aliasName)) {
 294             printError(ErrSyntaxError,
 295                        "Referencing same table again %s", t->tblName);
 296             if (prevHdl) delete prevHdl;
 297             return ErrSyntaxError;
 298         }
 299         tHdl = dbMgr->openTable(t->tblName);
 300         if ( NULL == tHdl )
 301         {
 302             printError(ErrNotExists,
 303                        "Unable to open the table:Table not exists");
 304             if (prevHdl) delete prevHdl;
 305             return ErrNotExists;
 306         }
 307         TableImpl *tImpl=  (TableImpl*) tHdl;
 308         tImpl->setAliasName(t->aliasName);
 309         if (NULL != prevHdl)
 310         {
 311             isJoin = true;
 312             jHdl = new JoinTableImpl();
 313             jHdl->setTable(prevHdl, tHdl);
 314             JoinTypeNode *node = (JoinTypeNode*) jiter.nextElement();
 315             if (node == NULL) {
 316                 printError(ErrSyntaxError,
 317                            "Join Type and number of tables do not match");
 318                 delete jHdl;
 319                 return ErrSyntaxError;
 320             }
 321             jHdl->setJoinType(node->jType);
 322             prevHdl = jHdl;
 323             continue;
 324         }
 325         prevHdl = tHdl;
 326     }
 327
 328     if (isJoin) table = jHdl; else table = tHdl;
 329     return OK;
 330 }
 331 DbRetVal SelStatement::resolve()
 332 {
 333     DbRetVal rv = openTables();
 334     if (rv != OK) return rv;
 335     //get the fieldname list and validate field names
 336     ListIterator iter = parsedData->getFieldNameList().getIterator();
 337     FieldName *name = NULL;
 338     FieldInfo *fInfo = new FieldInfo();
 339     List bindFldList;
 340     bool isSingleTableNoGrp = false;
 341     if(parsedData->getTableNameList().size() == 1 &&
 342        parsedData->getGroupFieldNameList().size() == 0)
 343     {
 344         isSingleTableNoGrp = true;
 345     }
 346     AggTableImpl *aggTable = NULL;
 347     while (iter.hasElement())
 348     {
 349         name = (FieldName*)iter.nextElement();
 350         if (NULL == name)
 351         {
 352             dbMgr->closeTable(table);
 353             table = NULL;
 354             delete fInfo;
 355             printError(ErrSysFatal, "Should never happen. Field Name list has NULL");
 356             return ErrSysFatal;
 357         }
 358         bool isBindFld=false;
 359         if ('*' == name->fldName[0] && name->aType == AGG_UNKNOWN)
 360         {
 361             rv = resolveStar();
 362             if (rv != OK)
 363             {
 364                 dbMgr->closeTable(table);
 365                 table = NULL;
 366                 delete fInfo;
 367                 return rv;
 368             }
 369             if (parsedData->getGroupFieldNameList().size()!= 0
 370                             && !isSingleTableNoGrp)
 371             {
 372                 if (!aggTable)
 373                     aggTable = new AggTableImpl();
 374                 aggTable->setTable(table);
 375             }
 376             //as soon as it encounters *, it breaks the loop negleting other field names
 377             //as they all are deleted during resolveStar method.
 378             break;
 379         }else {
 380             if ('*' == name->fldName[0] && name->aType != AGG_COUNT) {return ErrSyntaxError;}
 381             rv = table->getFieldInfo(name->fldName, fInfo);
 382             if (ErrNotFound == rv || ErrNotExists == rv)
 383             {
 384                 if (aggTable) { delete aggTable; aggTable = NULL; }
 385                 else dbMgr->closeTable(table);
 386                 table = NULL;
 387                 delete fInfo;
 388                 printError(ErrSyntaxError, "Field %s does not exist in table",
 389                                         name->fldName);
 390                 return ErrSyntaxError;
 391             }
 392             FieldValue *newVal = new FieldValue();
 393             strcpy(newVal->fldName,name->fldName);
 394             newVal->parsedString = NULL;
 395             newVal->paramNo = 0;
 396             newVal->aType = name->aType;
 397             newVal->isInResSet = true;
 398             newVal->offset = fInfo->offset;
 399             newVal->isPrimary = fInfo->isPrimary;
 400             newVal->isUnique = fInfo->isUnique;
 401             newVal->isAutoIncrement = fInfo->isAutoIncrement;
 402             newVal->isDefault = fInfo->isDefault;
 403             if (newVal->isDefault)
 404                 strcpy(newVal->defValBuf, fInfo->defaultValueBuf);
 405             else newVal->defValBuf[0]='\0';
 406
 407             if (name->aType == AGG_COUNT) {
 408                 newVal->type = typeInt;
 409                 newVal->length = sizeof(int);
 410             }
 411             else if (name->aType == AGG_AVG) {
 412                 newVal->type = typeDouble;
 413                 newVal->length = sizeof(double);
 414                 if (!AllDataType::isValidFieldForAvg(fInfo->type)) {
 415                     printError(ErrBadArg, "Illegal operation for field %s",
 416                                                                fInfo->fldName);
 417                     dbMgr->closeTable(table);
 418                     if (aggTable) { delete aggTable; aggTable = NULL; }
 419                     table = NULL;
 420                     delete fInfo;
 421                     return ErrBadArg;
 422                 }
 423             }
 424             else {
 425                 newVal->type = fInfo->type;
 426                 newVal->length = fInfo->length;
 427             }
 428             newVal->isNullable = fInfo->isNull;
 429             FieldName *bFldName=NULL;
 430             ListIterator it = bindFldList.getIterator();
 431             while (it.hasElement())
 432             {
 433                 bFldName = (FieldName*)it.nextElement();
 434                 if(0==strcmp(bFldName->fldName,name->fldName) &&
 435                              name->aType == AGG_UNKNOWN)
 436                 {
 437                     newVal->value=table->getBindFldAddr(name->fldName);
 438                     newVal->isAllocVal=false;
 439                     isBindFld=true;
 440                     break;
 441                 }
 442             }
 443             if (!isBindFld) {
 444                 if ( name->aType == AGG_UNKNOWN ||
 445                                     (name->aType != AGG_COUNT &&
 446                                                    name->aType != AGG_AVG) ) {
 447                     if(newVal->type == typeBinary)
 448                         newVal->value = AllDataType::alloc(fInfo->type,
 449                                                            2 * fInfo->length);
 450                     else newVal->value = AllDataType::alloc(fInfo->type,
 451                                                             fInfo->length);
 452                 } else {
 453                     if (name->aType == AGG_AVG) {
 454                         newVal->value = AllDataType::alloc(typeDouble,
 455                                                             sizeof(double));
 456                         memset(newVal->value, 0, sizeof(double));
 457                     }
 458                     else if (name->aType == AGG_COUNT) {
 459                         newVal->value = AllDataType::alloc(typeInt,
 460                                                                sizeof(int));
 461                         memset(newVal->value, 0, sizeof(int));
 462                     }
 463
 464                 }
 465                 newVal->isAllocVal=true;
 466             }
 467             if (name->aType ==AGG_UNKNOWN &&
 468                             parsedData->getGroupFieldNameList().size()== 0) {
 469                 rv = table->bindFld(name->fldName, newVal->value);
 470                 if (OK !=rv) {
 471                    if (newVal->isAllocVal) free(newVal->value);
 472                    delete newVal;
 473                    delete fInfo;
 474                    return rv;
 475                }
 476             }
 477             else if (!isSingleTableNoGrp)
 478             {
 479                 if (!aggTable) {
 480                     aggTable = new AggTableImpl();
 481                     aggTable->setTable(table);
 482                 }
 483                 rv = aggTable->bindFld(name->fldName, name->aType, newVal->value);
 484                 if (OK !=rv) {
 485                     if (newVal->isAllocVal) free(newVal->value);
 486                     delete newVal; delete fInfo; delete aggTable;
 487                     aggTable = NULL; table = NULL;
 488                     return rv;
 489                 }
 490             }
 491             if (name->aType !=AGG_UNKNOWN && isSingleTableNoGrp)
 492                 handleAggWithTbl= true;
 493             parsedData->insertFieldValue(newVal);
 494         }
 495         if (!isBindFld) bindFldList.append(name);
 496     }
 497     bindFldList.reset();
 498
 499     //Check if the having list is present in projection list or not.
 500     //If not present bind here not to be printed in fetchAndPrint later.
 501     ListIterator hiter = parsedData->getHavingFieldNameList().getIterator();
 502     while (hiter.hasElement()) {
 503         FieldName *fnm = (FieldName *) hiter.nextElement();
 504         rv = table->getFieldInfo(fnm->fldName, fInfo);
 505         if (!isInProjectionList(fnm->fldName, fnm->aType)) {
 506             FieldValue *newVal = new FieldValue();
 507             strcpy(newVal->fldName,fnm->fldName);
 508             newVal->parsedString = NULL;
 509             newVal->paramNo = 0;
 510             newVal->aType = fnm->aType;
 511             newVal->isInResSet = false;
 512             newVal->isNullable = fInfo->isNull;
 513             newVal->offset = fInfo->offset;
 514             newVal->isPrimary = fInfo->isPrimary;
 515             newVal->isUnique = fInfo->isUnique;
 516             newVal->isAutoIncrement = fInfo->isAutoIncrement;
 517             if (fnm->aType == AGG_AVG) {
 518                 newVal->value = AllDataType::alloc(typeDouble, sizeof(double));
 519                 memset(newVal->value, 0, sizeof(double));
 520             } else if (fnm->aType == AGG_COUNT) {
 521                 newVal->value = AllDataType::alloc(typeInt, sizeof(int));
 522                 memset(newVal->value, 0, sizeof(int));
 523             } else {
 524                 newVal->value = AllDataType::alloc(fInfo->type, fInfo->length);
 525                 memset(newVal->value, 0, fInfo->length);
 526             }
 527             newVal->isAllocVal = true;
 528             parsedData->insertFieldValue(newVal);
 529             aggTable->bindFld(fnm->fldName, fnm->aType, newVal->value);
 530         }
 531     }
 532
 533     rv = setBindFieldAndValues();
 534     if (rv != OK)
 535     {
 536         delete fInfo;
 537         if (aggTable) { delete aggTable; aggTable = NULL; }
 538         else dbMgr->closeTable(table);
 539         table = NULL;
 540         return rv;
 541     }
 542
 543     table->setCondition(parsedData->getCondition());
 544
 545     rv = resolveForCondition();
 546     if (rv != OK)
 547     {
 548         delete fInfo;
 549         //TODO::free memory allocated for params
 550         if (aggTable) { delete aggTable; aggTable = NULL; }
 551         else {
 552             table->setCondition(NULL);
 553             dbMgr->closeTable(table);
 554         }
 555         table = NULL;
 556         return rv;
 557     }
 558     if (NULL == parsedData->getCondition()) parsedData->setCacheWorthy(false);
 559     rv = resolveGroupFld(aggTable);
 560     if (rv != OK)
 561     {
 562         delete fInfo;
 563         //TODO::free memory allocated for params
 564         if (aggTable) { delete aggTable; aggTable = NULL; }
 565         else if (table)
 566         {
 567             table->setCondition(NULL);
 568             dbMgr->closeTable(table);
 569         }
 570         table = NULL;
 571         return rv;
 572     }
 573
 574     rv = resolveOrderByFld();
 575     if (rv != OK)
 576     {
 577         delete fInfo;
 578         delete table;
 579         table = NULL;
 580         return rv;
 581     }
 582     rv = resolveDistinct();
 583     delete fInfo;
 584     if(parsedData->getExplain())  isExplain = true;
 585     return rv;
 586 }
 587 DbRetVal SelStatement::resolveDistinct()
 588 {
 589     if (!parsedData->getDistinct()) {
 590          return OK;
 591     }
 592     OrderTableImpl *orderTable = new OrderTableImpl();
 593     orderTable->setTable(table);
 594     orderTable->setProjList(parsedData->getFieldValueList());
 595     orderTable->setOrderByList(parsedData->getFieldValueList());
 596     orderTable->setDistinct();
 597     table = orderTable;
 598     handleAggWithTbl= false;
 599     return OK;
 600 }
 601
 602
 603 DbRetVal SelStatement::resolveOrderByFld()
 604 {
 605     if (0 == parsedData->getOrderFieldNameList().size()) {
 606          return OK;
 607     }
 608     OrderTableImpl *orderTable = new OrderTableImpl();
 609     orderTable->setTable(table);
 610     orderTable->setProjList(parsedData->getFieldValueList());
 611     ListIterator giter = parsedData->getOrderFieldNameList().getIterator();
 612     FieldName *name = NULL;
 613     DbRetVal rv = OK;
 614     FieldInfo *fInfo = new FieldInfo();
 615     while (giter.hasElement())
 616     {
 617         name = (FieldName*)giter.nextElement();
 618         rv = table->getFieldInfo(name->fldName, fInfo);
 619         if (ErrNotFound == rv || ErrNotExists == rv)
 620         {
 621             delete fInfo;
 622             printError(ErrSyntaxError, "Field %s does not exist in table",
 623                                         name->fldName);
 624             return ErrSyntaxError;
 625         }
 626         /*FieldValue *newVal = new FieldValue();
 627         strcpy(newVal->fldName,name->fldName);
 628         newVal->parsedString = NULL;
 629         newVal->paramNo = 0;
 630         newVal->type = fInfo->type;
 631         newVal->isNullable = fInfo->isNull;
 632         newVal->length = fInfo->length;
 633         if (newVal->type == typeBinary)
 634             newVal->value = AllDataType::alloc(fInfo->type, 2 * fInfo->length);
 635         else newVal->value = AllDataType::alloc(fInfo->type, fInfo->length);
 636         newVal->isAllocVal=true;
 637         parsedData->insertFieldValue(newVal);
 638         */
 639         if (name->aType == AGG_UNKNOWN) orderTable->setOrderBy(name->fldName);
 640         else orderTable->setOrderBy(name->fldName, true); //descending
 641     }
 642     delete fInfo;
 643     table = orderTable;
 644     handleAggWithTbl= false;
 645     return OK;
 646 }
 647
 648 DbRetVal SelStatement::resolveGroupFld(AggTableImpl *aggTable)
 649 {
 650     if (!aggTable) return OK;
 651
 652     //check whether all non aggregate projections are from group list
 653     ListIterator iter = parsedData->getFieldNameList().getIterator();
 654     ListIterator giter = parsedData->getGroupFieldNameList().getIterator();
 655     FieldName *name = NULL;
 656     while (iter.hasElement())
 657     {
 658         name = (FieldName*) iter.nextElement();
 659         if (name->aType == AGG_UNKNOWN && !isGroupFld(name->fldName) ) {
 660             printError(ErrSyntaxError, "Non aggregate projection contains non group field: %s", name->fldName);
 661             return ErrSyntaxError;
 662         }
 663     }
 664
 665     DbRetVal rv = OK;
 666     FieldInfo *fInfo = new FieldInfo();
 667     while (giter.hasElement())
 668     {
 669         name = (FieldName*)giter.nextElement();
 670         rv = table->getFieldInfo(name->fldName, fInfo);
 671         if (ErrNotFound == rv || ErrNotExists == rv)
 672         {
 673             delete fInfo;
 674             printError(ErrSyntaxError, "Field %s does not exist in table",
 675                                         name->fldName);
 676             return ErrSyntaxError;
 677         }
 678         FieldValue *newVal = new FieldValue();
 679         strcpy(newVal->fldName,name->fldName);
 680         newVal->parsedString = NULL;
 681         newVal->paramNo = 0;
 682         newVal->type = fInfo->type;
 683         newVal->isNullable = fInfo->isNull;
 684         newVal->length = fInfo->length;
 685         newVal->offset = fInfo->offset;
 686         newVal->isPrimary = fInfo->isPrimary;
 687         newVal->isUnique = fInfo->isUnique;
 688         newVal->isAutoIncrement = fInfo->isAutoIncrement;
 689         if (newVal->type == typeBinary)
 690             newVal->value = AllDataType::alloc(fInfo->type, 2 * fInfo->length);
 691         else newVal->value = AllDataType::alloc(fInfo->type, fInfo->length);
 692         newVal->isAllocVal=true;
 693         parsedData->insertFieldValue(newVal);
 694         aggTable->setGroup(name->fldName, newVal->value);
 695     }
 696     delete fInfo;
 697     aggTable->setCondition(parsedData->getHavingCondition());
 698     /*if (giter.hasElement())
 699     {
 700        printError(ErrSyntaxError, "Only one field allowed in group\n");
 701        return ErrSyntaxError;
 702     }*/
 703     table = aggTable;
 704     return OK;
 705 }
 706
 707 DbRetVal SelStatement::resolveStar()
 708 {
 709     DbRetVal rv = OK;
 710     parsedData->clearFieldNameList();
 711     FieldValue *newVal = NULL;
 712     List fNameList = table->getFieldNameList();
 713     ListIterator fNameIter = fNameList.getIterator();
 714     //fNameList.resetIter(); //do not remove this.
 715     FieldInfo *fInfo = new FieldInfo();
 716     for (int i = 0; i < fNameList.size() ; i++)
 717     {
 718         char *fName = ((Identifier*)(fNameIter.nextElement()))->name;
 719         rv = table->getFieldInfo(fName, fInfo);
 720         if (ErrNotFound == rv || ErrNotExists == rv)
 721         {
 722             delete fInfo;
 723             fNameList.reset();
 724             printError(ErrSysFatal, "Should never happen.");
 725             return ErrSysFatal;
 726         }
 727         newVal = new FieldValue();
 728         strcpy(newVal->fldName,fName);
 729         newVal->parsedString = NULL;
 730         newVal->paramNo = 0;
 731         newVal->type = fInfo->type;
 732         newVal->length = fInfo->length;
 733         newVal->offset = fInfo->offset;
 734         newVal->isPrimary = fInfo->isPrimary;
 735         newVal->isUnique = fInfo->isUnique;
 736         newVal->isAutoIncrement = fInfo->isAutoIncrement;
 737
 738         // for binary datatype input buffer size should be 2 times the length
 739         if(newVal->type == typeBinary)
 740             newVal->value = AllDataType::alloc(fInfo->type, 2 * fInfo->length);
 741         else newVal->value = AllDataType::alloc(fInfo->type, fInfo->length);
 742         newVal->isAllocVal=true;
 743         newVal->isInResSet = true;
 744         parsedData->insertFieldValue(newVal);
 745         parsedData->insertField(fName);
 746         rv = table->bindFld(fName, newVal->value);
 747         if (rv != OK) {
 748             delete fInfo;
 749             return rv;
 750         }
 751     }
 752     fNameIter.reset();
 753     while (fNameIter.hasElement())
 754         delete (Identifier *) fNameIter.nextElement();
 755     fNameList.reset();
 756     delete fInfo;
 757     return OK;
 758 }
 759
 760 DbRetVal SelStatement::setBindFieldAndValues()
 761 {
 762     totalFields = parsedData->getFieldNameList().size();
 763     bindFields = (FieldValue**) malloc ( totalFields * sizeof(FieldValue*));
 764     bindFieldValues = (char**) malloc( totalFields * sizeof(char*));
 765     memset(bindFields, 0, totalFields * sizeof(FieldValue*));
 766     memset(bindFieldValues, 0, totalFields * sizeof(char*));
 767     ListIterator valIter = parsedData->getFieldValueList().getIterator();
 768     int colNo =0;
 769     FieldValue *value = NULL;
 770     //The second condition colNo < totalFields is important for projection list
 771     //might not contain the binded having field.
 772     while(valIter.hasElement() && colNo < totalFields)
 773     {
 774         value = (FieldValue*) valIter.nextElement();
 775         if (value == NULL)
 776         {
 777             free(bindFields); bindFields = NULL;
 778             free(bindFieldValues); bindFieldValues = NULL;
 779             printError(ErrSysFatal, "Should never happen. value NULL after iteration");
 780             return ErrSysFatal;
 781         }
 782         bindFields[colNo++] = value;
 783     }
 784     return OK;
 785 }
 786
 787
 788 DbRetVal SelStatement::resolveForCondition()
 789 {
 790     //get the fieldname list and validate field names
 791     ListIterator iter = parsedData->getConditionValueList().getIterator();
 792
 793     ConditionValue *value;
 794     FieldInfo *fInfo = new FieldInfo();
 795     int paramPos =1;
 796     DbRetVal rv = OK;
 797     while (iter.hasElement())
 798     {
 799         value = (ConditionValue*) iter.nextElement();
 800         if (NULL == value)
 801         {
 802             delete fInfo;
 803             printError(ErrSysFatal, "Should never happen.");
 804             return ErrSysFatal;
 805         }
 806         if(!value->isFunctionInvolve){
 807             rv = table->getFieldInfo(value->fName, fInfo);
 808             if (ErrNotFound == rv || ErrNotExists == rv)
 809             {
 810                 delete fInfo;
 811                 printError(ErrSyntaxError, "Field %s does not exist in table",
 812                                         value->fName);
 813                 return ErrSyntaxError;
 814             }
 815             if (value->aType == AGG_AVG) {
 816                 value->type = typeDouble;
 817                 value->length = sizeof(double);
 818             } else if (value->aType == AGG_COUNT) {
 819                 value->type = typeInt;
 820                 value->length = sizeof(int);
 821             } else {
 822                 value->type = fInfo->type;
 823                 value->length = fInfo->length;
 824             }
 825             value->isNullable = fInfo->isNull;
 826         }else{
 827              value->type = AllDataType::getCsqlTypeFromFunctionTypeForComparision(parsedData->getFunctionType());
 828         }
 829         value->value = AllDataType::alloc(value->type, value->length);
 830         //table->bindFld(name->fldName, value->value);
 831         if(value->paramNo ==1) continue;//For Predecate t1.f1=t2.f1
 832         if (value->parsedString == NULL)
 833         {
 834             delete fInfo;
 835             printError(ErrSyntaxError, "Condition value should not be NULL");
 836             return ErrSyntaxError;
 837         }
 838         if (value->parsedString[0] == '?')
 839         {
 840                 //if(!value->opLike) // checks if 'LIKE' operator is used
 841                 value->paramNo = paramPos++;
 842         }
 843         if (!value->paramNo) {
 844                 // for valid Integer
 845             if (value->type  == typeDate || value->type == typeTime ||
 846                 value->type == typeTimeStamp)
 847                 parsedData->setCacheWorthy(false);
 848                 if((value->type == typeInt) || (value->type==typeShort) ||
 849                 (value->type==typeByteInt) || (value->type==typeLongLong) ||
 850                                                      (value->type==typeLong)) {
 851                     int len=strlen(value->parsedString);
 852                     for(int n=0;n<len;n++){
 853                         int p=value->parsedString[n];
 854                         if(!(p>=48 && p<=57 || p==45)) return ErrBadArg;
 855                     }
 856                 }
 857
 858                 // Here for binary dataType it is not strcpy'd bcos internally memcmp is done for predicates like f2 = 'abcd' where f2 is binary
 859             AllDataType::strToValue(value->value, value->parsedString, value->type, value->length);
 860             }
 861     }
 862     delete fInfo;
 863     totalParams = paramPos -1;
 864     if (0 == totalParams) return OK;
 865     params = (void**) malloc ( totalParams * sizeof(FieldValue*));
 866     paramValues = (char**) malloc( totalParams * sizeof(char*));
 867     memset(params, 0, totalParams * sizeof(FieldValue*));
 868     memset(paramValues, 0, totalParams * sizeof(char*));
 869     iter.reset();
 870     while(iter.hasElement())
 871     {
 872         value = (ConditionValue*) iter.nextElement();
 873         if (value == NULL)
 874         {
 875             free(params); params = NULL;
 876             free(paramValues); paramValues = NULL;
 877             printError(ErrSysFatal, "Should never happen. value NULL after iteration");
 878             return ErrSysFatal;
 879         }
 880         if (value->paramNo) params[value->paramNo - 1] = value;
 881     }
 882     return OK;
 883 }
 884 bool SelStatement::isGroupFld(char *fieldName)
 885 {
 886     ListIterator giter = parsedData->getGroupFieldNameList().getIterator();
 887     FieldName *name = NULL;
 888     while (giter.hasElement())
 889     {
 890         name = (FieldName*) giter.nextElement();
 891         if (0 == strcmp(name->fldName, fieldName)) return true;
 892     }
 893     return false;
 894 }
 895
 896 void* SelStatement::handleSingleTableAggWithoutGroup()
 897 {
 898     if (isPointReturned) return NULL;
 899     TableImpl *tblImpl = (TableImpl*)table;
 900     ListIterator iter = parsedData->getFieldNameList().getIterator();
 901     int i=0;
 902     DbRetVal rv = OK;
 903     FieldName *name;
 904     FieldValue *fVal = NULL;
 905     bool noRec = false;
 906     while (iter.hasElement())
 907     {
 908         name = (FieldName*) iter.nextElement();
 909         fVal = bindFields[i];
 910
 911         rv = tblImpl->fetchAgg(name->fldName, name->aType, fVal->value, noRec);
 912         if (OK != rv) return NULL;
 913         i++;
 914         tblImpl->closeScan();
 915         tblImpl->execute();
 916     }
 917     isPointReturned = true;
 918     if(noRec && name->aType != AGG_COUNT) return NULL;
 919     return fVal;
 920 }
 921 void* SelStatement::fetch()
 922 {
 923     void *tuple = NULL;
 924     if(handleAggWithTbl)
 925     {
 926        tuple = handleSingleTableAggWithoutGroup();
 927        if (NULL == tuple) return NULL;
 928     }else {
 929         if (isOffsetReached) {
 930             if (!isRecLimitReached) {
 931                 tuple = table->fetch();
 932                 if (NULL != tuple) numRecords++;
 933                 if (numRecords == parsedData->getLimit()) isRecLimitReached=true;
 934             }
 935         }
 936         else {
 937           int recordOffset =0;
 938           while(recordOffset <= parsedData->getOffset()) {
 939             tuple = table->fetch();
 940             if (NULL == tuple) break;
 941             recordOffset++;
 942           }
 943           isOffsetReached = true;
 944           if (NULL != tuple) numRecords++;
 945           if (numRecords == parsedData->getLimit()) isRecLimitReached=true;
 946         }
 947     }
 948     if (NULL == tuple) return NULL;
 949
 950     //copy values to binded buffer
 951     FieldValue *value;
 952     for (int i = 0; i < totalFields; i++)
 953     {
 954         value = bindFields[i];
 955         if (bindFieldValues[i] == NULL)
 956         {
 957             printError(ErrBadCall, "Fields are not binded properly. Should never happen");
 958             return NULL;
 959         }
 960         AllDataType::copyVal(bindFieldValues[i], value->value, value->type, value->length);
 961     }
 962     return tuple;
 963 }
 964
 965 void* SelStatement::fetch(DbRetVal &rv)
 966 {
 967     void *tuple = NULL;
 968     if(handleAggWithTbl)
 969     {
 970         tuple = handleSingleTableAggWithoutGroup();
 971         if (NULL == tuple) return NULL;
 972     }else {
 973         if (isOffsetReached) {
 974             if (!isRecLimitReached) {
 975                 tuple = table->fetch(rv);
 976                 if (NULL != tuple) numRecords++;
 977                 if (numRecords == parsedData->getLimit()) isRecLimitReached=true;
 978             }
 979         } else {
 980             int recordOffset =0;
 981             while(recordOffset <= parsedData->getOffset()) {
 982                 tuple = table->fetch(rv);
 983                 if (NULL == tuple) break;
 984                 recordOffset++;
 985             }
 986             isOffsetReached = true;
 987             if (NULL != tuple) numRecords++;
 988             if (numRecords == parsedData->getLimit()) isRecLimitReached=true;
 989         }
 990     }
 991     if (NULL == tuple) return NULL;
 992     //copy values to binded buffer
 993     FieldValue *value;
 994     for (int i = 0; i < totalFields; i++)
 995     {
 996         value = bindFields[i];
 997         if (bindFieldValues[i] == NULL)
 998         {
 999             printError(ErrBadCall, "Fields are not binded properly. Should never happen %d", i);
1000             return NULL;
1001         }
1002                 AllDataType::copyVal(bindFieldValues[i], value->value, value->type, value->length);
1003     }
1004     return tuple;
1005 }
1006
1007 DbRetVal SelStatement::close()
1008 {
1009     isPointReturned = false;
1010     if (table) return table->closeScan();
1011     else return OK;
1012 }
1013
1014 void* SelStatement::getParamValuePtr( int pos )
1015 {
1016     ConditionValue *p = (ConditionValue*) params [pos-1];
1017     return ( (void*) p->value );
1018 }
1019
1020 char* SelStatement::getFieldName ( int pos )
1021 {
1022     //TODO::if not yet prepared return error
1023     //TODO::check the upper limit for projpos
1024     ListIterator iter = parsedData->getFieldNameList().getIterator();
1025     int position = 1;
1026     while (iter.hasElement())
1027     {
1028         FieldName *name = (FieldName*) iter.nextElement();
1029         if (position == pos) {
1030               if (NULL == name)
1031               {
1032                   printError(ErrSysFatal, "Should never happen. Field Name list has NULL");
1033                   return (char*) 0;
1034               }
1035               return name->fldName;
1036         }
1037         position++;
1038     }
1039     return (char*) 0;
1040 }
1041
1042 DataType SelStatement::getFieldType( int pos )
1043 {
1044     FieldValue *v = bindFields[pos];
1045     return ( (DataType) v->type );
1046 }
1047
1048 int SelStatement::getFieldLength( int pos )
1049 {
1050     FieldValue *v = bindFields[pos];
1051     return ( (int) v->type );
1052 }
1053
1054 void* SelStatement::fetchAndPrint(bool SQL)
1055 {
1056     void *tuple = NULL;
1057     if(handleAggWithTbl)
1058     {
1059        tuple = handleSingleTableAggWithoutGroup();
1060     }else {
1061         if (isOffsetReached) {
1062             if (!isRecLimitReached) {
1063                 tuple = table->fetch();
1064                 if (NULL != tuple) numRecords++;
1065                 if (numRecords == parsedData->getLimit()) isRecLimitReached=true;
1066             }
1067         }
1068         else {
1069           int recordOffset =0;
1070           while(recordOffset <= parsedData->getOffset()) {
1071             tuple = table->fetch();
1072             if (NULL == tuple) break;
1073             recordOffset++;
1074           }
1075           isOffsetReached = true;
1076           if (NULL != tuple) numRecords++;
1077           if (numRecords == parsedData->getLimit()) isRecLimitReached=true;
1078         }
1079     }
1080     if (NULL == tuple) return NULL;
1081     FieldValue *value;
1082     bool nullValueSet;
1083     char stmt[128];
1084     if (SQL) {
1085         sprintf(stmt, "INSERT INTO %s VALUES(", table->getName());
1086         printf("%s", stmt);
1087     }
1088     for (int i = 0; i < totalFields; i++)
1089     {
1090         value = bindFields[i];
1091         if (!value->isInResSet) continue;
1092         nullValueSet = table->isFldNull(value->fldName);
1093         if (nullValueSet) {
1094             if (SQL) {
1095                 if (i==0)
1096                     printf("NULL");
1097                 else
1098                     printf(", NULL");
1099             }
1100             else if (value->aType != AGG_COUNT) printf("NULL\t");
1101             else printf("0\t");
1102         }
1103         else  {
1104             if (SQL) {
1105                 switch(value->type)
1106                 {
1107                     case typeString:
1108                     case typeVarchar:
1109                     case typeBinary:
1110                     case typeDate:
1111                     case typeTime:
1112                     case typeTimeStamp:
1113                     {
1114                         if (i==0)
1115                             printf(" '");
1116                         else
1117                             printf(", '");
1118                         break;
1119                     }
1120                     default:
1121                     {
1122                         if (i!=0)
1123                            printf(",");
1124                     }
1125                 }
1126             }
1127             AllDataType::printVal(value->value, value->type, value->length);
1128             if (SQL) {
1129                 switch(value->type)
1130                 {
1131                     case typeString:
1132                     case typeVarchar:
1133                     case typeBinary:
1134                     case typeDate:
1135                     case typeTime:
1136                     case typeTimeStamp:
1137                         printf("'");
1138                 }
1139             } else printf("\t");
1140         }
1141     }
1142     if (SQL) printf(");\n");
1143     return tuple;
1144 }
1145
1146 void* SelStatement::next()
1147 {
1148     if(handleAggWithTbl)
1149     {
1150        return handleSingleTableAggWithoutGroup();
1151     }
1152     return( table->fetch() );
1153 }
1154
1155
1156 void* SelStatement::getFieldValuePtr( int pos )
1157 {
1158     FieldValue *v = bindFields[pos];
1159     return ( (void*) v->value );
1160 }
1161
1162 void* SelStatement::getFieldValuePtr( char *name )
1163 {
1164     FieldValue *value;
1165     char fName[IDENTIFIER_LENGTH];
1166     for (int i = 0; i < totalFields; i++)
1167     {
1168         value = bindFields[i];
1169         table->getFieldNameAlone(value->fldName,fName);
1170         if (strcmp(fName,name)==0)
1171         {
1172             return ( (void*) value->value );
1173         }
1174
1175     }
1176     return NULL;
1177 }
1178 void SelStatement::getProjFieldType(int *data)
1179 {
1180     FieldValue *value;
1181     for (int i = 0; i < totalFields; i++)
1182     {
1183         value = bindFields[i];
1184         data[i+1] = value->type;
1185     }
1186 }
1187
1188 int SelStatement::noOfProjFields()
1189 {
1190     return totalFields;
1191 }
1192
1193 DbRetVal SelStatement::getProjFldInfo (int projpos, FieldInfo *&fInfo)
1194 {
1195
1196     DbRetVal rv = OK;
1197     //TODO::if not yet prepared return error
1198     //TODO::check the upper limit for projpos
1199     if (projpos < 0 || projpos >totalFields) return ErrBadArg;
1200     FieldValue *value = bindFields[projpos-1];
1201     fInfo->type = value->type;
1202     fInfo->length= value->length;
1203     fInfo->isNull = value->isNullable;
1204     fInfo->aType = value->aType;
1205     fInfo->offset = value->offset;
1206     fInfo->isPrimary = value->isPrimary;
1207     fInfo->isUnique = value->isUnique;
1208     fInfo->isAutoIncrement= value->isAutoIncrement;
1209     fInfo->isDefault = value->isDefault;
1210     if (fInfo->aType == AGG_UNKNOWN) {
1211         strcpy(fInfo->fldName, value->fldName);
1212         if (fInfo->isDefault) strcpy(fInfo->defaultValueBuf, value->defValBuf);
1213         return OK;
1214     }
1215     switch(fInfo->aType)
1216     {
1217        case AGG_COUNT:
1218            sprintf(fInfo->fldName, "COUNT(%s)",  value->fldName);
1219            fInfo->type = typeInt;
1220            fInfo->length = sizeof(int);
1221            break;
1222        case AGG_MIN:
1223            sprintf(fInfo->fldName, "MIN(%s)",  value->fldName);
1224            break;
1225        case AGG_MAX:
1226            sprintf(fInfo->fldName, "MAX(%s)",  value->fldName);
1227            break;
1228        case AGG_SUM:
1229            sprintf(fInfo->fldName, "SUM(%s)",  value->fldName);
1230            break;
1231        case AGG_AVG:
1232            sprintf(fInfo->fldName, "AVG(%s)",  value->fldName);
1233            fInfo->type = typeDouble;
1234            fInfo->length = sizeof(double);
1235            break;
1236        default:
1237            strcpy(fInfo->fldName, value->fldName);
1238            break;
1239     }
1240     return rv;
1241 }
1242 int SelStatement::getFldPos(char *name)
1243 {
1244     return table->getFldPos(name);
1245 }
1246
1247 bool SelStatement::isInProjectionList(char *name, AggType aType)
1248 {
1249     ListIterator iter = parsedData->getFieldNameList().getIterator();
1250     FieldName *fldName = NULL;
1251     while (iter.hasElement()) {
1252         fldName = (FieldName*) iter.nextElement();
1253         if ((strcmp(fldName->fldName, name)==0) && fldName->aType == aType) {
1254             return true;
1255         }
1256     }
1257     return false;
1258 }
1259