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