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         if (table) {
  38             table->setCondition(NULL);
  39             if (dbMgr) dbMgr->closeTable(table);
  40         }
  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         info->type = uValue->type;
  70         info->length = uValue->length;
  71     } else {
  72         cValue = (ConditionValue*) params[paramPos-1];
  73         info->type = cValue->type;
  74         info->length = cValue->length;
  75     }
  76     return OK;
  77
  78 }
  79 DbRetVal UpdStatement::execute(int &rowsAffected)
  80 {
  81     DbRetVal rv = OK;
  82     //copy param values to binded buffer
  83     ConditionValue *cValue;
  84     UpdateFieldValue *uValue;
  85
  86     for (int i = 0; i < totalParams; i ++)
  87     {
  88         if (i < totalAssignParams) {
  89             uValue = (UpdateFieldValue*) params[i];
  90             if (paramValues[i] == NULL)
  91             {
  92                 continue;
  93                 //printError(ErrBadCall, "param values not set");
  94                 //return ErrBadCall;
  95             }
  96             AllDataType::copyVal(uValue->value, paramValues[i], uValue->type, uValue->length);
  97         } else {
  98             cValue = (ConditionValue*) params[i];
  99             if (paramValues[i] == NULL)
 100             {
 101                 continue;
 102                 //printError(ErrBadCall, "param values not set");
 103                 //return ErrBadCall;
 104             }
 105             AllDataType::copyVal(cValue->value, paramValues[i], cValue->type, cValue->length);
 106         }
 107     }
 108     rv = table->execute();
 109     if (rv != OK) return rv;
 110     rowsAffected = 0;
 111     void *tuple;
 112     while(true)
 113     {
 114         tuple = (char*)table->fetchNoBind(rv);
 115         if (rv != OK) break;
 116         if (tuple == NULL) {break;}
 117         rv = table->updateTuple();
 118         if (rv != OK) break;
 119         rowsAffected++;
 120     }
 121     table->close();
 122     return rv;
 123 }
 124
 125
 126 DbRetVal UpdStatement::setParam(int paramNo, void *value)
 127 {
 128     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 129     if (NULL == value) return ErrBadArg;
 130     paramValues[paramNo -1] = (char*) value;
 131     return OK;
 132 }
 133
 134 DbRetVal UpdStatement::setShortParam(int paramNo, short value)
 135 {
 136     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 137     if (NULL == params[paramNo-1])
 138     {
 139         printError(ErrSysFatal, "param not set. Should never happen");
 140         return ErrSysFatal;
 141     }
 142
 143     ConditionValue *cValue;
 144     UpdateFieldValue *uValue;
 145     if (paramNo <= totalAssignParams) {
 146         uValue = (UpdateFieldValue*) params[paramNo-1];
 147         *(short*)uValue->value = value;
 148     } else {
 149         cValue = (ConditionValue*) params[paramNo-1];
 150         *(short*)cValue->value = value;
 151     }
 152     return OK;
 153 }
 154
 155
 156 DbRetVal UpdStatement::setIntParam(int paramNo, int value)
 157 {
 158     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 159     if (NULL == params[paramNo-1])
 160     {
 161         printError(ErrSysFatal, "param not set. Should never happen");
 162         return ErrSysFatal;
 163     }
 164     ConditionValue *cValue;
 165     UpdateFieldValue *uValue;
 166     if (paramNo <= totalAssignParams) {
 167         uValue = (UpdateFieldValue*) params[paramNo-1];
 168         *(int*)uValue->value = value;
 169     } else {
 170         cValue = (ConditionValue*) params[paramNo-1];
 171         *(int*)cValue->value = value;
 172     }
 173     return OK;
 174 }
 175
 176 DbRetVal UpdStatement::setLongParam(int paramNo, long value)
 177 {
 178     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 179     if (NULL == params[paramNo-1])
 180     {
 181         printError(ErrSysFatal, "param not set. Should never happen");
 182         return ErrSysFatal;
 183     }
 184
 185     ConditionValue *cValue;
 186     UpdateFieldValue *uValue;
 187     if (paramNo <= totalAssignParams) {
 188         uValue = (UpdateFieldValue*) params[paramNo-1];
 189         *(long*)uValue->value = value;
 190     } else {
 191         cValue = (ConditionValue*) params[paramNo-1];
 192         *(long*)cValue->value = value;
 193     }
 194     return OK;
 195 }
 196
 197 DbRetVal UpdStatement::setLongLongParam(int paramNo, long 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 long*)uValue->value = value;
 211     } else {
 212         cValue = (ConditionValue*) params[paramNo-1];
 213         *(long long*)cValue->value = value;
 214     }
 215     return OK;
 216 }
 217
 218 DbRetVal UpdStatement::setByteIntParam(int paramNo, ByteInt 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         *(ByteInt*)uValue->value = value;
 232     } else {
 233         cValue = (ConditionValue*) params[paramNo-1];
 234         *(ByteInt*)cValue->value = value;
 235     }
 236     return OK;
 237 }
 238
 239 DbRetVal UpdStatement::setFloatParam(int paramNo, float 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         *(float*)uValue->value = value;
 253     } else {
 254         cValue = (ConditionValue*) params[paramNo-1];
 255         *(float*)cValue->value = value;
 256     }
 257     return OK;
 258 }
 259
 260
 261 DbRetVal UpdStatement::setDoubleParam(int paramNo, double value)
 262 {
 263     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 264     if (NULL == params[paramNo-1])
 265     {
 266         printError(ErrSysFatal, "param not set. Should never happen");
 267         return ErrSysFatal;
 268     }
 269
 270     ConditionValue *cValue;
 271     UpdateFieldValue *uValue;
 272     if (paramNo <= totalAssignParams) {
 273         uValue = (UpdateFieldValue*) params[paramNo-1];
 274         *(double*)uValue->value = value;
 275     } else {
 276         cValue = (ConditionValue*) params[paramNo-1];
 277         *(double*)cValue->value = value;
 278     }
 279     return OK;
 280 }
 281
 282 DbRetVal UpdStatement::setStringParam(int paramNo, char *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         strcpy((char*)uValue->value, value);
 296     } else {
 297         cValue = (ConditionValue*) params[paramNo-1];
 298         strcpy((char*)cValue->value, value);
 299     }
 300     return OK;
 301 }
 302
 303
 304 DbRetVal UpdStatement::setDateParam(int paramNo, Date value)
 305 {
 306     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 307     if (NULL == params[paramNo-1])
 308     {
 309         printError(ErrSysFatal, "param not set. Should never happen");
 310         return ErrSysFatal;
 311     }
 312
 313     ConditionValue *cValue;
 314     UpdateFieldValue *uValue;
 315     if (paramNo <= totalAssignParams) {
 316         uValue = (UpdateFieldValue*) params[paramNo-1];
 317         *(Date*)uValue->value = value;
 318     } else {
 319         cValue = (ConditionValue*) params[paramNo-1];
 320         *(Date*)cValue->value = value;
 321     }
 322     return OK;
 323 }
 324
 325 DbRetVal UpdStatement::setTimeParam(int paramNo, Time 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         *(Time*)uValue->value = value;
 339     } else {
 340         cValue = (ConditionValue*) params[paramNo-1];
 341         *(Time*)cValue->value = value;
 342     }
 343     return OK;
 344 }
 345
 346
 347 DbRetVal UpdStatement::setTimeStampParam(int paramNo, TimeStamp value)
 348 {
 349     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 350     if (NULL == params[paramNo-1])
 351     {
 352         printError(ErrSysFatal, "param not set. Should never happen");
 353         return ErrSysFatal;
 354     }
 355
 356     ConditionValue *cValue;
 357     UpdateFieldValue *uValue;
 358     if (paramNo <= totalAssignParams) {
 359         uValue = (UpdateFieldValue*) params[paramNo-1];
 360         *(TimeStamp*)uValue->value = value;
 361     } else {
 362         cValue = (ConditionValue*) params[paramNo-1];
 363         *(TimeStamp*)cValue->value = value;
 364     }
 365     return OK;
 366 }
 367
 368 DbRetVal UpdStatement::resolve()
 369 {
 370     if (dbMgr == NULL) return ErrNoConnection;
 371     //check whether the table exists
 372     table = dbMgr->openTable(parsedData->getTableName());
 373     if (table == NULL)
 374     {
 375         printError(ErrNotExists, "Unable to open the table:Table not exists");
 376         return ErrNotExists;
 377     }
 378
 379     table->setCondition(parsedData->getCondition());
 380
 381     DbRetVal rv = resolveForAssignment();
 382     if (rv != OK)
 383     {
 384         //TODO::free memory allocated for params
 385         table->setCondition(NULL);
 386         dbMgr->closeTable(table);
 387         table = NULL;
 388     }
 389     return rv;
 390 }
 391
 392 DbRetVal UpdStatement::resolveForAssignment()
 393 {
 394     //get the fieldname list and validate field names
 395     ListIterator iter = parsedData->getUpdateFieldValueList().getIterator();
 396
 397     UpdateFieldValue *value;
 398     FieldInfo *fInfo = new FieldInfo();
 399     int paramPos =1;
 400     DbRetVal rv = OK;
 401     while (iter.hasElement())
 402     {
 403         value = (UpdateFieldValue*) iter.nextElement();
 404         if (NULL == value)
 405         {
 406             delete fInfo;
 407             printError(ErrSysFatal, "Should never happen.");
 408             return ErrSysFatal;
 409         }
 410         rv = table->getFieldInfo(value->fldName, fInfo);
 411         if (ErrNotFound == rv)
 412         {
 413             delete fInfo;
 414             printError(ErrSyntaxError, "Field %s does not exist in table",
 415                                         value->fldName);
 416             return ErrSyntaxError;
 417         }
 418         value->type = fInfo->type;
 419         value->length = fInfo->length;
 420         value->value = AllDataType::alloc(fInfo->type, fInfo->length);
 421         table->bindFld(value->fldName, value->value);
 422         if (value->parsedString == NULL)
 423         {
 424             if (fInfo->isNull) { delete fInfo; return ErrNullViolation; }
 425             table->markFldNull(value->fldName);
 426             continue;
 427         }
 428         if (value->parsedString[0] == '?')
 429         {
 430             value->paramNo = paramPos++;
 431         }
 432         if (!value->paramNo)
 433             AllDataType::strToValue(value->value, value->parsedString, fInfo->type, value->length);
 434     }
 435     totalAssignParams = paramPos -1;
 436
 437
 438     //get the fieldname list and validate field names
 439     ListIterator cIter = parsedData->getConditionValueList().getIterator();
 440     ConditionValue *cValue = NULL;
 441     while (cIter.hasElement())
 442     {
 443         cValue = (ConditionValue*) cIter.nextElement();
 444         if (NULL == cValue)
 445         {
 446             delete fInfo;
 447             printError(ErrSysFatal, "Should never happen.");
 448             return ErrSysFatal;
 449         }
 450         rv = table->getFieldInfo(cValue->fName, fInfo);
 451         if (ErrNotFound == rv)
 452         {
 453             delete fInfo;
 454             printError(ErrSyntaxError, "Field %s does not exist in table",
 455                                         cValue->fName);
 456             return ErrSyntaxError;
 457         }
 458         cValue->type = fInfo->type;
 459         cValue->length = fInfo->length;
 460         cValue->value = AllDataType::alloc(fInfo->type, fInfo->length);
 461         if (cValue->parsedString == NULL)
 462         {
 463             delete fInfo;
 464             printError(ErrSyntaxError, "Condition value should not be NULL");
 465             return ErrSyntaxError;
 466         }
 467
 468         if (cValue->parsedString[0] == '?')
 469         {
 470             cValue->paramNo = paramPos++;
 471         }
 472         if (!cValue->paramNo)
 473             AllDataType::strToValue(cValue->value, cValue->parsedString, fInfo->type);
 474     }
 475
 476
 477     delete fInfo;
 478     totalParams = paramPos -1;
 479     if (0 == totalParams) return OK;
 480     params = (void**) malloc ( totalParams * sizeof(FieldValue*));
 481     paramValues = (char**) malloc( totalParams * sizeof(char*));
 482
 483     memset(params, 0, totalParams * sizeof(FieldValue*));
 484     memset(paramValues, 0, totalParams * sizeof(char*));
 485
 486     iter.reset();
 487     while(iter.hasElement())
 488     {
 489         value = (UpdateFieldValue*) iter.nextElement();
 490         if (value == NULL)
 491         {
 492             free(params); params = NULL;
 493             free(paramValues); paramValues = NULL;
 494             printError(ErrSysFatal, "Should never happen. value NULL after iteration");
 495             return ErrSysFatal;
 496         }
 497         if (0 == value->paramNo) continue;
 498         params[value->paramNo -1 ] = value;
 499     }
 500
 501     cIter.reset();
 502     while(cIter.hasElement())
 503     {
 504         cValue = (ConditionValue*) cIter.nextElement();
 505         if (cValue == NULL)
 506         {
 507             free(params); params = NULL;
 508             free(paramValues); paramValues = NULL;
 509             printError(ErrSysFatal, "Should never happen. value NULL after iteration");
 510             return ErrSysFatal;
 511         }
 512         if (0 == cValue->paramNo) continue;
 513         params[cValue->paramNo -1 ] = cValue;
 514     }
 515     return OK;
 516 }