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::setBindField(int colNo, void *value)
 229 {
 230     if (colNo <=0) return ErrBadArg;
 231     //TODO: check the upper limit
 232     //if (colNo > table->getFieldNameList().size()) return ErrBadArg;
 233     if (NULL == value) return ErrBadArg;
 234     bindFieldValues[colNo -1] = (char*) value;
 235     return OK;
 236 }
 237
 238 DbRetVal SelStatement::resolve()
 239 {
 240     if (dbMgr == NULL) return ErrNoConnection;
 241     //check whether the table exists
 242     table = dbMgr->openTable(parsedData->getTableName());
 243     if (table == NULL)
 244     {
 245         printError(ErrNotExists, "Unable to open the table:Table not exists");
 246         return ErrNotExists;
 247     }
 248     //get the fieldname list and validate field names
 249     ListIterator iter = parsedData->getFieldNameList().getIterator();
 250     FieldName *name = NULL;
 251     FieldInfo *fInfo = new FieldInfo();
 252     DbRetVal rv = OK;
 253     while (iter.hasElement())
 254     {
 255         name = (FieldName*)iter.nextElement();
 256         if (NULL == name)
 257         {
 258             dbMgr->closeTable(table);
 259             table = NULL;
 260             delete fInfo;
 261             printError(ErrSysFatal, "Should never happen. Field Name list has NULL");
 262             return ErrSysFatal;
 263         }
 264         if ('*' == name->fldName[0])
 265         {
 266             iter.reset();
 267             while (iter.hasElement())
 268                 delete (FieldName *) iter.nextElement();
 269             rv = resolveStar();
 270             if (rv != OK)
 271             {
 272                 dbMgr->closeTable(table);
 273                 table = NULL;
 274                 delete fInfo;
 275                 return rv;
 276             }
 277             //as soon as it encounters *, it breaks the loop negleting other field names
 278             //as they all are deleted during resolveStar method.
 279             break;
 280         } else {
 281             rv = table->getFieldInfo(name->fldName, fInfo);
 282             if (ErrNotFound == rv)
 283             {
 284                 dbMgr->closeTable(table);
 285                 table = NULL;
 286                 delete fInfo;
 287                 printError(ErrSyntaxError, "Field %s does not exist in table",
 288                                         name->fldName);
 289                 return ErrSyntaxError;
 290             }
 291             FieldValue *newVal = new FieldValue();
 292             newVal->parsedString = NULL;
 293             newVal->paramNo = 0;
 294             newVal->type = fInfo->type;
 295             newVal->length = fInfo->length;
 296             newVal->value = AllDataType::alloc(fInfo->type, fInfo->length);
 297             parsedData->insertFieldValue(newVal);
 298             table->bindFld(name->fldName, newVal->value);
 299         }
 300     }
 301     delete fInfo;
 302
 303     rv = setBindFieldAndValues();
 304     if (rv != OK)
 305     {
 306         dbMgr->closeTable(table);
 307         table = NULL;
 308         return rv;
 309     }
 310
 311     table->setCondition(parsedData->getCondition());
 312
 313     rv = resolveForCondition();
 314     if (rv != OK)
 315     {
 316         //TODO::free memory allocated for params
 317         table->setCondition(NULL);
 318         dbMgr->closeTable(table);
 319         table = NULL;
 320     }
 321     return rv;
 322 }
 323 DbRetVal SelStatement::resolveStar()
 324 {
 325     DbRetVal rv = OK;
 326     parsedData->clearFieldNameList();
 327     List fNameList = table->getFieldNameList();
 328     ListIterator fNameIter = fNameList.getIterator();
 329     FieldValue *newVal = NULL;
 330     //fNameList.resetIter(); //do not remove this.
 331     FieldInfo *fInfo = new FieldInfo();
 332     for (int i = 0; i < fNameList.size() ; i++)
 333     {
 334         char *fName = ((Identifier*)(fNameIter.nextElement()))->name;
 335         rv = table->getFieldInfo(fName, fInfo);
 336         if (ErrNotFound == rv)
 337         {
 338             delete fInfo;
 339             fNameList.reset();
 340             printError(ErrSysFatal, "Should never happen.");
 341             return ErrSysFatal;
 342         }
 343         newVal = new FieldValue();
 344         newVal->parsedString = NULL;
 345         newVal->paramNo = 0;
 346         newVal->type = fInfo->type;
 347         newVal->length = fInfo->length;
 348         newVal->value = AllDataType::alloc(fInfo->type, fInfo->length);
 349         parsedData->insertFieldValue(newVal);
 350         parsedData->insertField(fName);
 351         table->bindFld(fName, newVal->value);
 352     }
 353     fNameIter.reset();
 354     while (fNameIter.hasElement())
 355         delete (Identifier *) fNameIter.nextElement();
 356     fNameList.reset();
 357     delete fInfo;
 358     return OK;
 359 }
 360
 361 DbRetVal SelStatement::setBindFieldAndValues()
 362 {
 363     totalFields = parsedData->getFieldNameList().size();
 364     bindFields = (FieldValue**) malloc ( totalFields * sizeof(FieldValue*));
 365     bindFieldValues = (char**) malloc( totalFields * sizeof(char*));
 366     memset(bindFields, 0, totalFields * sizeof(FieldValue*));
 367     memset(bindFieldValues, 0, totalFields * sizeof(char*));
 368     ListIterator valIter = parsedData->getFieldValueList().getIterator();
 369     int colNo =0;
 370     FieldValue *value = NULL;
 371     valIter.reset();
 372     while(valIter.hasElement())
 373     {
 374         value = (FieldValue*) valIter.nextElement();
 375         if (value == NULL)
 376         {
 377             free(bindFields); bindFields = NULL;
 378             free(bindFieldValues); bindFieldValues = NULL;
 379             printError(ErrSysFatal, "Should never happen. value NULL after iteration");
 380             return ErrSysFatal;
 381         }
 382         bindFields[colNo++ ] = value;
 383     }
 384     return OK;
 385 }
 386
 387
 388 DbRetVal SelStatement::resolveForCondition()
 389 {
 390     //get the fieldname list and validate field names
 391     ListIterator iter = parsedData->getConditionValueList().getIterator();
 392
 393     ConditionValue *value;
 394     FieldInfo *fInfo = new FieldInfo();
 395     int paramPos =1;
 396     DbRetVal rv = OK;
 397     while (iter.hasElement())
 398     {
 399         value = (ConditionValue*) iter.nextElement();
 400         if (NULL == value)
 401         {
 402             delete fInfo;
 403             printError(ErrSysFatal, "Should never happen.");
 404             return ErrSysFatal;
 405         }
 406         rv = table->getFieldInfo(value->fName, fInfo);
 407         if (ErrNotFound == rv)
 408         {
 409             delete fInfo;
 410             printError(ErrSyntaxError, "Field %s does not exist in table",
 411                                         value->fName);
 412             return ErrSyntaxError;
 413         }
 414         value->type = fInfo->type;
 415         value->length = fInfo->length;
 416         value->value = AllDataType::alloc(fInfo->type, fInfo->length);
 417         //table->bindFld(name->fldName, value->value);
 418         if (value->parsedString == NULL)
 419         {
 420             delete fInfo;
 421             printError(ErrSyntaxError, "Condition value should not be NULL");
 422             return ErrSyntaxError;
 423         }
 424         if (value->parsedString[0] == '?')
 425         {
 426             value->paramNo = paramPos++;
 427         }
 428         if (!value->paramNo)
 429             AllDataType::strToValue(value->value, value->parsedString, fInfo->type);
 430     }
 431     delete fInfo;
 432     totalParams = paramPos -1;
 433     if (0 == totalParams) return OK;
 434     params = (void**) malloc ( totalParams * sizeof(FieldValue*));
 435     paramValues = (char**) malloc( totalParams * sizeof(char*));
 436     memset(params, 0, totalParams * sizeof(FieldValue*));
 437     memset(paramValues, 0, totalParams * sizeof(char*));
 438     iter.reset();
 439     while(iter.hasElement())
 440     {
 441         value = (ConditionValue*) iter.nextElement();
 442         if (value == NULL)
 443         {
 444             free(params); params = NULL;
 445             free(paramValues); paramValues = NULL;
 446             printError(ErrSysFatal, "Should never happen. value NULL after iteration");
 447             return ErrSysFatal;
 448         }
 449         params[value->paramNo -1 ] = value;
 450     }
 451     return OK;
 452 }
 453
 454 void* SelStatement::fetch()
 455 {
 456     void *tuple = table->fetch();
 457     if (NULL == tuple) return NULL;
 458     //copy values to binded buffer
 459     FieldValue *value;
 460     for (int i = 0; i < totalFields; i++)
 461     {
 462         value = bindFields[i];
 463         if (bindFieldValues[i] == NULL)
 464         {
 465             printError(ErrBadCall, "Fields are not binded properly. Should never happen");
 466             return NULL;
 467         }
 468         AllDataType::copyVal(bindFieldValues[i], value->value, value->type, value->length);
 469     }
 470     return tuple;
 471 }
 472
 473 void* SelStatement::fetch(DbRetVal &rv)
 474 {
 475     void *tuple = table->fetch(rv);
 476     if (NULL == tuple) return NULL;
 477     //copy values to binded buffer
 478     FieldValue *value;
 479     for (int i = 0; i < totalFields; i++)
 480     {
 481         value = bindFields[i];
 482         if (bindFieldValues[i] == NULL)
 483         {
 484             printError(ErrBadCall, "Fields are not binded properly. Should never happen");
 485             return NULL;
 486         }
 487         AllDataType::copyVal(bindFieldValues[i], value->value, value->type, value->length);
 488     }
 489     return tuple;
 490 }
 491
 492 DbRetVal SelStatement::close()
 493 {
 494     return table->close();
 495 }
 496 void* SelStatement::getParamValuePtr( int pos )
 497 {
 498     ConditionValue *p = (ConditionValue*) params [pos-1];
 499     return ( (void*) p->value );
 500 }
 501
 502 char* SelStatement::getFieldName ( int pos )
 503 {
 504     //TODO::if not yet prepared return error
 505     //TODO::check the upper limit for projpos
 506     ListIterator iter = parsedData->getFieldNameList().getIterator();
 507     int position =0;
 508     while (iter.hasElement())
 509     {
 510         if (position == pos) {
 511               FieldName *name = (FieldName*) iter.nextElement();
 512               if (NULL == name)
 513               {
 514                   printError(ErrSysFatal, "Should never happen. Field Name list has NULL");
 515                   return (char*) 0;
 516               }
 517               return name->fldName;
 518       }
 519         position++;
 520     }
 521     return (char*) 0;
 522 }
 523
 524 DataType SelStatement::getFieldType( int pos )
 525 {
 526     FieldValue *v = bindFields[pos];
 527     return ( (DataType) v->type );
 528 }
 529
 530 int SelStatement::getFieldLength( int pos )
 531 {
 532     FieldValue *v = bindFields[pos];
 533     return ( (int) v->type );
 534 }
 535
 536 void* SelStatement::fetchAndPrint(bool SQL)
 537 {
 538     void *tuple = table->fetch();
 539     if (NULL == tuple) return NULL;
 540     FieldValue *value;
 541     bool nullValueSet;
 542     char stmt[128];
 543     if (SQL) {
 544         sprintf(stmt, "INSERT INTO %s VALUES(", table->getName());
 545         printf("%s", stmt);
 546     }
 547     for (int i = 0; i < totalFields; i++)
 548     {
 549         value = bindFields[i];
 550         nullValueSet = table->isFldNull(i+1);
 551         if (nullValueSet)
 552             if (SQL) {
 553                 if (i==0)
 554                     printf("NULL");
 555                 else
 556                     printf(", NULL");
 557             }
 558             else printf("NULL\t");
 559         else  {
 560             if (SQL) {
 561                 switch(value->type)
 562                 {
 563                     case typeString:
 564                     case typeDate:
 565                     case typeTime:
 566                     case typeTimeStamp:
 567                     {
 568                         if (i==0)
 569                             printf(" '");
 570                         else
 571                             printf(", '");
 572                         break;
 573                     }
 574                     default:
 575                     {
 576                         if (i!=0)
 577                            printf(",");
 578                     }
 579                 }
 580             }
 581             AllDataType::printVal(value->value, value->type, value->length);
 582             if (SQL) {
 583                 switch(value->type)
 584                 {
 585                     case typeString:
 586                     case typeDate:
 587                     case typeTime:
 588                     case typeTimeStamp:
 589                         printf("'");
 590                 }
 591             } else printf("\t");
 592         }
 593     }
 594     if (SQL) printf(");\n");
 595     return tuple;
 596 }
 597
 598 void* SelStatement::next()
 599 {
 600     return( table->fetch() );
 601 }
 602
 603 void* SelStatement::getFieldValuePtr( int pos )
 604 {
 605     FieldValue *v = bindFields[pos];
 606     return ( (void*) v->value );
 607 }
 608
 609 int SelStatement::noOfProjFields()
 610 {
 611     return totalFields;
 612 }
 613
 614 DbRetVal SelStatement::getProjFldInfo (int projpos, FieldInfo *&fInfo)
 615 {
 616     //TODO::if not yet prepared return error
 617     //TODO::check the upper limit for projpos
 618     ListIterator iter = parsedData->getFieldNameList().getIterator();
 619     FieldName *name = NULL;
 620     DbRetVal rv = OK;
 621     int position =0;
 622     while (iter.hasElement())
 623     {
 624         name = (FieldName*)iter.nextElement();
 625         if (NULL == name)
 626         {
 627             printError(ErrSysFatal, "Should never happen. Field Name list has NULL");
 628             return ErrSysFatal;
 629         }
 630         if (position == projpos) break;
 631         position++;
 632     }
 633
 634     rv = table->getFieldInfo(name->fldName, fInfo);
 635 }