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