src/sql/UpdStatement.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 <Info.h>
  18
  19 UpdStatement::UpdStatement()
  20 {
  21     parsedData = NULL;
  22     dbMgr = NULL;
  23     table = NULL;
  24     params = NULL;
  25     paramValues = NULL;
  26     totalParams = 0;
  27     totalAssignParams =0;
  28 }
  29
  30 UpdStatement::~UpdStatement() {
  31     if (table) { table->close(); table = NULL; }
  32     if (totalParams) {
  33         //TODO::below free cause memory corruption.
  34         free(params);
  35         params =  NULL;
  36         free(paramValues);
  37         paramValues = NULL;
  38         }
  39 }
  40 void* UpdStatement::getParamValuePtr( int pos )
  41 {
  42     ConditionValue *cValue;
  43     UpdateFieldValue *uValue;
  44     if (pos <= totalAssignParams) {
  45         uValue = (UpdateFieldValue*) params[pos-1];
  46       return( (void*) uValue->value );
  47     } else {
  48         cValue = (ConditionValue*) params[pos-1];
  49       return( (void*) cValue->value );
  50     }
  51 }
  52
  53 DbRetVal UpdStatement::getParamFldInfo(int paramPos, FieldInfo *&info)
  54 {
  55     if (paramPos <=0 || paramPos > totalParams) return ErrBadArg;
  56     if (NULL == params[paramPos-1])
  57     {
  58         printError(ErrSysFatal, "param not set. Should never happen");
  59         return ErrSysFatal;
  60     }
  61
  62     ConditionValue *cValue;
  63     UpdateFieldValue *uValue;
  64     if (paramPos <= totalAssignParams) {
  65         uValue = (UpdateFieldValue*) params[paramPos-1];
  66         table->getFieldNameAlone(uValue->fldName,info->fldName);
  67         info->type = uValue->type;
  68         info->length = uValue->length;
  69         info->isNull = uValue->isNullable;
  70     } else {
  71         cValue = (ConditionValue*) params[paramPos-1];
  72         table->getFieldNameAlone(cValue->fName,info->fldName);
  73         info->type = cValue->type;
  74         info->length = cValue->length;
  75         info->isNull = cValue->isNullable;
  76     }
  77     return OK;
  78
  79 }
  80 DbRetVal UpdStatement::execute(int &rowsAffected)
  81 {
  82     DbRetVal rv = OK;
  83     //copy param values to binded buffer
  84     ConditionValue *cValue;
  85     UpdateFieldValue *uValue;
  86
  87     for (int i = 0; i < totalParams; i ++)
  88     {
  89         if (i < totalAssignParams) {
  90             uValue = (UpdateFieldValue*) params[i];
  91             if (paramValues[i] == NULL)
  92             {
  93                 continue;
  94                 //printError(ErrBadCall, "param values not set");
  95                 //return ErrBadCall;
  96             }
  97             AllDataType::copyVal(uValue->value, paramValues[i], uValue->type, uValue->length);
  98         } else {
  99             cValue = (ConditionValue*) params[i];
 100             if (paramValues[i] == NULL)
 101             {
 102                 continue;
 103                 //printError(ErrBadCall, "param values not set");
 104                 //return ErrBadCall;
 105             }
 106             AllDataType::copyVal(cValue->value, paramValues[i], cValue->type, cValue->length);
 107         }
 108     }
 109     rv = table->execute();
 110     if (rv != OK) return rv;
 111     rowsAffected = 0;
 112     void *tuple;
 113     ListIterator iter = parsedData->getUpdateFieldValueList().getIterator();
 114     bool nullFlag;
 115     while(true)
 116     {
 117         tuple = (char*)table->fetchNoBind(rv);
 118         if (rv != OK) break;
 119         if (tuple == NULL) {break;}
 120         iter.reset();
 121         while (iter.hasElement())
 122         {
 123             uValue = (UpdateFieldValue*) iter.nextElement();
 124             if(uValue->expre!=NULL)
 125             {
 126                 nullFlag=false;
 127                 uValue->expre->setTuple(tuple);
 128                 uValue->expre->setTable(table);
 129                 AllDataType::copyVal(uValue->value,(uValue->expre)->evaluate(uValue->type,nullFlag),uValue->type, uValue->length);
 130                 uValue->expre->memFree();
 131                 if(nullFlag)
 132                 {
 133                     rv=table->markFldNull(uValue->fldName);
 134                     if(rv==ErrNullViolation){return ErrNullViolation;}
 135                 }
 136             }
 137         }
 138         rv = table->updateTuple();
 139         if (rv != OK) break;
 140         rowsAffected++;
 141     }
 142     table->closeScan();
 143     return rv;
 144 }
 145
 146
 147 DbRetVal UpdStatement::setParam(int paramNo, void *value)
 148 {
 149     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 150     if (NULL == value) return ErrBadArg;
 151     paramValues[paramNo -1] = (char*) value;
 152     return OK;
 153 }
 154
 155 DbRetVal UpdStatement::setShortParam(int paramNo, short value)
 156 {
 157     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 158     if (NULL == params[paramNo-1])
 159     {
 160         printError(ErrSysFatal, "param not set. Should never happen");
 161         return ErrSysFatal;
 162     }
 163
 164     ConditionValue *cValue;
 165     UpdateFieldValue *uValue;
 166     if (paramNo <= totalAssignParams) {
 167         uValue = (UpdateFieldValue*) params[paramNo-1];
 168         *(short*)uValue->value = value;
 169     } else {
 170         cValue = (ConditionValue*) params[paramNo-1];
 171         *(short*)cValue->value = value;
 172     }
 173     return OK;
 174 }
 175
 176
 177 DbRetVal UpdStatement::setIntParam(int paramNo, int value)
 178 {
 179     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 180     if (NULL == params[paramNo-1])
 181     {
 182         printError(ErrSysFatal, "param not set. Should never happen");
 183         return ErrSysFatal;
 184     }
 185     ConditionValue *cValue;
 186     UpdateFieldValue *uValue;
 187     if (paramNo <= totalAssignParams) {
 188         uValue = (UpdateFieldValue*) params[paramNo-1];
 189         *(int*)uValue->value = value;
 190     } else {
 191         cValue = (ConditionValue*) params[paramNo-1];
 192         *(int*)cValue->value = value;
 193     }
 194     return OK;
 195 }
 196
 197 DbRetVal UpdStatement::setLongParam(int paramNo, long value)
 198 {
 199     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 200     if (NULL == params[paramNo-1])
 201     {
 202         printError(ErrSysFatal, "param not set. Should never happen");
 203         return ErrSysFatal;
 204     }
 205
 206     ConditionValue *cValue;
 207     UpdateFieldValue *uValue;
 208     if (paramNo <= totalAssignParams) {
 209         uValue = (UpdateFieldValue*) params[paramNo-1];
 210         *(long*)uValue->value = value;
 211     } else {
 212         cValue = (ConditionValue*) params[paramNo-1];
 213         *(long*)cValue->value = value;
 214     }
 215     return OK;
 216 }
 217
 218 DbRetVal UpdStatement::setLongLongParam(int paramNo, long long value)
 219 {
 220     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 221     if (NULL == params[paramNo-1])
 222     {
 223         printError(ErrSysFatal, "param not set. Should never happen");
 224         return ErrSysFatal;
 225     }
 226
 227     ConditionValue *cValue;
 228     UpdateFieldValue *uValue;
 229     if (paramNo <= totalAssignParams) {
 230         uValue = (UpdateFieldValue*) params[paramNo-1];
 231         *(long long*)uValue->value = value;
 232     } else {
 233         cValue = (ConditionValue*) params[paramNo-1];
 234         *(long long*)cValue->value = value;
 235     }
 236     return OK;
 237 }
 238
 239 DbRetVal UpdStatement::setByteIntParam(int paramNo, ByteInt value)
 240 {
 241     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 242     if (NULL == params[paramNo-1])
 243     {
 244         printError(ErrSysFatal, "param not set. Should never happen");
 245         return ErrSysFatal;
 246     }
 247
 248     ConditionValue *cValue;
 249     UpdateFieldValue *uValue;
 250     if (paramNo <= totalAssignParams) {
 251         uValue = (UpdateFieldValue*) params[paramNo-1];
 252         *(ByteInt*)uValue->value = value;
 253     } else {
 254         cValue = (ConditionValue*) params[paramNo-1];
 255         *(ByteInt*)cValue->value = value;
 256     }
 257     return OK;
 258 }
 259
 260 DbRetVal UpdStatement::setFloatParam(int paramNo, float value)
 261 {
 262     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 263     if (NULL == params[paramNo-1])
 264     {
 265         printError(ErrSysFatal, "param not set. Should never happen");
 266         return ErrSysFatal;
 267     }
 268
 269     ConditionValue *cValue;
 270     UpdateFieldValue *uValue;
 271     if (paramNo <= totalAssignParams) {
 272         uValue = (UpdateFieldValue*) params[paramNo-1];
 273         *(float*)uValue->value = value;
 274     } else {
 275         cValue = (ConditionValue*) params[paramNo-1];
 276         *(float*)cValue->value = value;
 277     }
 278     return OK;
 279 }
 280
 281
 282 DbRetVal UpdStatement::setDoubleParam(int paramNo, double value)
 283 {
 284     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 285     if (NULL == params[paramNo-1])
 286     {
 287         printError(ErrSysFatal, "param not set. Should never happen");
 288         return ErrSysFatal;
 289     }
 290
 291     ConditionValue *cValue;
 292     UpdateFieldValue *uValue;
 293     if (paramNo <= totalAssignParams) {
 294         uValue = (UpdateFieldValue*) params[paramNo-1];
 295         *(double*)uValue->value = value;
 296     } else {
 297         cValue = (ConditionValue*) params[paramNo-1];
 298         *(double*)cValue->value = value;
 299     }
 300     return OK;
 301 }
 302
 303 DbRetVal UpdStatement::setStringParam(int paramNo, char *value)
 304 {
 305     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 306     if (NULL == params[paramNo-1])
 307     {
 308         printError(ErrSysFatal, "param not set. Should never happen");
 309         return ErrSysFatal;
 310     }
 311
 312     ConditionValue *cValue;
 313     UpdateFieldValue *uValue;
 314     if (paramNo <= totalAssignParams) {
 315         uValue = (UpdateFieldValue*) params[paramNo-1];
 316         strcpy((char*)uValue->value, value);
 317     } else {
 318         cValue = (ConditionValue*) params[paramNo-1];
 319         strcpy((char*)cValue->value, value);
 320     }
 321     return OK;
 322 }
 323
 324
 325 DbRetVal UpdStatement::setDateParam(int paramNo, Date value)
 326 {
 327     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 328     if (NULL == params[paramNo-1])
 329     {
 330         printError(ErrSysFatal, "param not set. Should never happen");
 331         return ErrSysFatal;
 332     }
 333
 334     ConditionValue *cValue;
 335     UpdateFieldValue *uValue;
 336     if (paramNo <= totalAssignParams) {
 337         uValue = (UpdateFieldValue*) params[paramNo-1];
 338         *(Date*)uValue->value = value;
 339     } else {
 340         cValue = (ConditionValue*) params[paramNo-1];
 341         *(Date*)cValue->value = value;
 342     }
 343     return OK;
 344 }
 345
 346 DbRetVal UpdStatement::setTimeParam(int paramNo, Time value)
 347 {
 348     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 349     if (NULL == params[paramNo-1])
 350     {
 351         printError(ErrSysFatal, "param not set. Should never happen");
 352         return ErrSysFatal;
 353     }
 354
 355     ConditionValue *cValue;
 356     UpdateFieldValue *uValue;
 357     if (paramNo <= totalAssignParams) {
 358         uValue = (UpdateFieldValue*) params[paramNo-1];
 359         *(Time*)uValue->value = value;
 360     } else {
 361         cValue = (ConditionValue*) params[paramNo-1];
 362         *(Time*)cValue->value = value;
 363     }
 364     return OK;
 365 }
 366
 367
 368 DbRetVal UpdStatement::setTimeStampParam(int paramNo, TimeStamp value)
 369 {
 370     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 371     if (NULL == params[paramNo-1])
 372     {
 373         printError(ErrSysFatal, "param not set. Should never happen");
 374         return ErrSysFatal;
 375     }
 376
 377     ConditionValue *cValue;
 378     UpdateFieldValue *uValue;
 379     if (paramNo <= totalAssignParams) {
 380         uValue = (UpdateFieldValue*) params[paramNo-1];
 381         *(TimeStamp*)uValue->value = value;
 382     } else {
 383         cValue = (ConditionValue*) params[paramNo-1];
 384         *(TimeStamp*)cValue->value = value;
 385     }
 386     return OK;
 387 }
 388
 389 DbRetVal UpdStatement::setBinaryParam(int paramNo, void *value)
 390 {
 391     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 392     if (NULL == params[paramNo-1])
 393     {
 394         printError(ErrSysFatal, "param not set. Should never happen");
 395         return ErrSysFatal;
 396     }
 397
 398     ConditionValue *cValue;
 399     UpdateFieldValue *uValue;
 400     if (paramNo <= totalAssignParams) {
 401         uValue = (UpdateFieldValue*) params[paramNo-1];
 402         memcpy(uValue->value, value, 2 * uValue->length);
 403     } else {
 404         cValue = (ConditionValue*) params[paramNo-1];
 405         AllDataType::convertToBinary(cValue->value,value,typeString,cValue->length);
 406     }
 407     return OK;
 408 }
 409
 410 DbRetVal UpdStatement::resolve()
 411 {
 412     if (dbMgr == NULL) return ErrNoConnection;
 413     //check whether the table exists
 414     table = dbMgr->openTable(parsedData->getTableName());
 415     if (table == NULL)
 416     {
 417         printError(ErrNotExists, "Unable to open the table:Table not exists");
 418         return ErrNotExists;
 419     }
 420
 421     table->setCondition(parsedData->getCondition());
 422
 423     DbRetVal rv = resolveForAssignment();
 424     if (rv != OK)
 425     {
 426         //TODO::free memory allocated for params
 427         table->setCondition(NULL);
 428         dbMgr->closeTable(table);
 429         table = NULL;
 430     }
 431     return rv;
 432 }
 433
 434 DbRetVal UpdStatement::resolveForAssignment()
 435 {
 436     //get the fieldname list and validate field names
 437     ListIterator iter = parsedData->getUpdateFieldValueList().getIterator();
 438
 439     UpdateFieldValue *value;
 440     FieldInfo *fInfo = new FieldInfo();
 441     int paramPos =1;
 442     DbRetVal rv = OK;
 443     while (iter.hasElement())
 444     {
 445         value = (UpdateFieldValue*) iter.nextElement();
 446         if (NULL == value)
 447         {
 448             delete fInfo;
 449             printError(ErrSysFatal, "Should never happen.");
 450             return ErrSysFatal;
 451         }
 452         rv = table->getFieldInfo(value->fldName, fInfo);
 453         if (ErrNotFound == rv)
 454         {
 455             delete fInfo;
 456             printError(ErrSyntaxError, "Field %s does not exist in table",
 457                                         value->fldName);
 458             return ErrSyntaxError;
 459         }
 460         if (fInfo->isUnique) {
 461             delete fInfo;
 462             printError(ErrUnique, "Unique field %s cannot be updated", value->fldName);
 463             return ErrUnique;
 464         }
 465         value->type = fInfo->type;
 466         value->length = fInfo->length;
 467         value->isNullable = fInfo->isNull;
 468         // for binary datatype input buffer size should be 2 times the length
 469         if (value->type == typeBinary)
 470                     value->value = AllDataType::alloc(fInfo->type, 2 * fInfo->length);
 471         else value->value = AllDataType::alloc(fInfo->type, fInfo->length);
 472         table->bindFld(value->fldName, value->value);
 473         if( NULL != value->expre )
 474         {
 475             (value->expre)->convertStrToVal(value->type);
 476             continue;
 477         }
 478         if (value->parsedString == NULL)
 479         {
 480             if (fInfo->isNull) { delete fInfo; return ErrNullViolation; }
 481             table->markFldNull(value->fldName);
 482             continue;
 483         }
 484         if (value->parsedString[0] == '?')
 485         {
 486             value->paramNo = paramPos++;
 487         }
 488         if (!value->paramNo) {
 489             // for binary datatype buffer is just strcpy'd. It will be converted into binary datatype in copyValuesToBindBuffer in DBAPI
 490             if (value->type == typeBinary)
 491                 strncpy((char *)value->value, value->parsedString, 2 * fInfo->length);
 492             else AllDataType::strToValue(value->value, value->parsedString, fInfo->type, value->length);
 493                 }
 494     }
 495     totalAssignParams = paramPos -1;
 496
 497
 498     //get the fieldname list and validate field names
 499     ListIterator cIter = parsedData->getConditionValueList().getIterator();
 500     ConditionValue *cValue = NULL;
 501     while (cIter.hasElement())
 502     {
 503         cValue = (ConditionValue*) cIter.nextElement();
 504         if (NULL == cValue)
 505         {
 506             delete fInfo;
 507             printError(ErrSysFatal, "Should never happen.");
 508             return ErrSysFatal;
 509         }
 510         rv = table->getFieldInfo(cValue->fName, fInfo);
 511         if (ErrNotFound == rv)
 512         {
 513             delete fInfo;
 514             printError(ErrSyntaxError, "Field %s does not exist in table",
 515                                         cValue->fName);
 516             return ErrSyntaxError;
 517         }
 518         cValue->type = fInfo->type;
 519         cValue->length = fInfo->length;
 520         cValue->isNullable = fInfo->isNull;
 521         // for binary datatype input buffer size should be 2 times the length
 522         if (cValue->type == typeBinary)
 523         {
 524             if(cValue->parsedString[0] == '?')
 525                 cValue->value = AllDataType::alloc(fInfo->type, fInfo->length);
 526             else
 527                 cValue->value = AllDataType::alloc(fInfo->type, 2 * fInfo->length);
 528         }
 529         else cValue->value = AllDataType::alloc(fInfo->type, fInfo->length);
 530         if(cValue->paramNo == 1){continue;}
 531         if (cValue->parsedString == NULL)
 532         {
 533             delete fInfo;
 534             printError(ErrSyntaxError, "Condition value should not be NULL");
 535             return ErrSyntaxError;
 536         }
 537
 538         if (cValue->parsedString[0] == '?')
 539         {
 540                     if(! cValue->opLike) // checks if 'LIKE' operator is used
 541                 cValue->paramNo = paramPos++;
 542         }
 543         if (!cValue->paramNo) {
 544                     // Here for binary dataType it is not strcpy'd bcos internally memcmp is done for predicates like f2 = 'abcd' where f2 is binary
 545                         AllDataType::strToValue(cValue->value, cValue->parsedString, fInfo->type, fInfo->length);
 546         }
 547         }
 548
 549     delete fInfo;
 550     totalParams = paramPos -1;
 551     if (0 == totalParams) return OK;
 552     params = (void**) malloc ( totalParams * sizeof(FieldValue*));
 553     paramValues = (char**) malloc( totalParams * sizeof(char*));
 554
 555     memset(params, 0, totalParams * sizeof(FieldValue*));
 556     memset(paramValues, 0, totalParams * sizeof(char*));
 557
 558     iter.reset();
 559     while(iter.hasElement())
 560     {
 561         value = (UpdateFieldValue*) iter.nextElement();
 562         if (value == NULL)
 563         {
 564             free(params); params = NULL;
 565             free(paramValues); paramValues = NULL;
 566             printError(ErrSysFatal, "Should never happen. value NULL after iteration");
 567             return ErrSysFatal;
 568         }
 569         if (0 == value->paramNo) continue;
 570         params[value->paramNo -1 ] = value;
 571     }
 572
 573     cIter.reset();
 574     while(cIter.hasElement())
 575     {
 576         cValue = (ConditionValue*) cIter.nextElement();
 577         if (cValue == NULL)
 578         {
 579             free(params); params = NULL;
 580             free(paramValues); paramValues = NULL;
 581             printError(ErrSysFatal, "Should never happen. value NULL after iteration");
 582             return ErrSysFatal;
 583         }
 584         if (0 == cValue->paramNo) continue;
 585         params[cValue->paramNo -1 ] = cValue;
 586     }
 587     return OK;
 588 }
 589 int  UpdStatement::getFldPos(char *name)
 590 {
 591     return table->getFldPos(name);
 592 }
 593