src/sql/InsStatement.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 <os.h>
  17 #include <Statement.h>
  18 #include <Info.h>
  19
  20 InsStatement::InsStatement()
  21 {
  22     parsedData = NULL;
  23     dbMgr = NULL;
  24     table = NULL;
  25     params = NULL;
  26     paramValues = NULL;
  27     totalParams = 0;
  28 }
  29
  30 InsStatement::~InsStatement()
  31 {
  32     if (table) { table->close(); table = NULL; }
  33     if (totalParams) {
  34         free(params);
  35         params =  NULL;
  36         free(paramValues);
  37         paramValues = NULL;
  38     }
  39 }
  40
  41 DbRetVal InsStatement::getParamFldInfo(int paramPos, FieldInfo *&info)
  42 {
  43     if (paramPos >totalParams ) return ErrBadCall;
  44     FieldValue *value = (FieldValue*)params[paramPos-1];
  45     if (value == NULL)
  46     {
  47         printError(ErrSysFatal, "param ptr is null: should never happen\n");
  48         return ErrBadArg;
  49     }
  50     table->getFieldNameAlone(value->fldName,info->fldName);
  51     info->type = value->type;
  52     info->length = value->length;
  53     info->isNull = value->isNullable;
  54     return OK;
  55 }
  56
  57 DbRetVal InsStatement::execute(int &rowsAffected)
  58 {
  59     DbRetVal rv = OK;
  60     //copy param values to binded buffer
  61     FieldValue *value;
  62     for (int i = 0; i < totalParams; i ++)
  63     {
  64         value = (FieldValue*) params[i];
  65         if (paramValues[i] == NULL)
  66         {
  67             //printError(ErrBadCall, "param values not set");
  68             continue;
  69             //return ErrBadCall;
  70         }
  71         AllDataType::copyVal(value->value, paramValues[i], value->type, value->length);
  72     }
  73     rv = table->insertTuple();
  74     if (rv ==OK) rowsAffected = 1;
  75     table-> resetNullinfo();
  76     return rv;
  77 }
  78
  79 DbRetVal InsStatement::setParam(int paramNo, void *value)
  80 {
  81     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
  82     if (NULL == value) return ErrBadArg;
  83     paramValues[paramNo -1] = (char*) value;
  84     return OK;
  85 }
  86
  87 DbRetVal InsStatement::setShortParam(int paramNo, short value)
  88 {
  89     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
  90     FieldValue *fValue = (FieldValue*) params [paramNo-1];
  91     if (NULL == fValue)
  92     {
  93         printError(ErrSysFatal, "field value is null. Should never happen");
  94         return ErrSysFatal;
  95     }
  96     *(short*)fValue->value = value;
  97     return OK;
  98 }
  99
 100 DbRetVal InsStatement::setIntParam(int paramNo, int value)
 101 {
 102     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 103     FieldValue *cValue = (FieldValue*) params [paramNo-1];
 104     if (NULL == cValue)
 105     {
 106         printError(ErrSysFatal, "condition value is null. Should never happen");
 107         return ErrSysFatal;
 108     }
 109
 110     *(int*)cValue->value = value;
 111     return OK;
 112 }
 113 DbRetVal InsStatement::setNull(int paramNo)
 114 {
 115     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 116     FieldValue *cValue = (FieldValue*) params [paramNo-1];
 117     if (NULL == cValue)
 118     {
 119         printError(ErrSysFatal, "FieldValue is null. Should never happen");
 120         return ErrSysFatal;
 121     }
 122     char name[IDENTIFIER_LENGTH];
 123     table->getFieldNameAlone(cValue->fldName,name);
 124     table->markFldNull(name);
 125     return OK;
 126 }
 127 DbRetVal InsStatement::setLongParam(int paramNo, long value)
 128 {
 129     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 130     FieldValue *cValue = (FieldValue*) params [paramNo-1];
 131     if (NULL == cValue)
 132     {
 133         printError(ErrSysFatal, "condition value is null. Should never happen");
 134         return ErrSysFatal;
 135     }
 136     *(long*)cValue->value = value;
 137     return OK;
 138 }
 139
 140 DbRetVal InsStatement::setLongLongParam(int paramNo, long long value)
 141 {
 142     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 143     FieldValue *cValue = (FieldValue*) params [paramNo-1];
 144     if (NULL == cValue)
 145     {
 146         printError(ErrSysFatal, "condition value is null. Should never happen");
 147         return ErrSysFatal;
 148     }
 149     *(long long*)cValue->value = value;
 150     return OK;
 151 }
 152 DbRetVal InsStatement::setByteIntParam(int paramNo, ByteInt value)
 153 {
 154     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 155     FieldValue *cValue = (FieldValue*) params [paramNo-1];
 156     if (NULL == cValue)
 157     {
 158         printError(ErrSysFatal, "condition value is null. Should never happen");
 159         return ErrSysFatal;
 160     }
 161     *(ByteInt*)cValue->value = value;
 162     return OK;
 163 }
 164 DbRetVal InsStatement::setFloatParam(int paramNo, float value)
 165 {
 166     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 167     FieldValue *cValue = (FieldValue*) params [paramNo-1];
 168     if (NULL == cValue)
 169     {
 170         printError(ErrSysFatal, "condition value is null. Should never happen");
 171         return ErrSysFatal;
 172     }
 173     *(float*)cValue->value = value;
 174     return OK;
 175 }
 176 DbRetVal InsStatement::setDoubleParam(int paramNo, double value)
 177 {
 178     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 179     FieldValue *cValue = (FieldValue*) params [paramNo-1];
 180     if (NULL == cValue)
 181     {
 182         printError(ErrSysFatal, "condition value is null. Should never happen");
 183         return ErrSysFatal;
 184     }
 185     *(double*)cValue->value = value;
 186     return OK;
 187 }
 188 DbRetVal InsStatement::setStringParam(int paramNo, char *value)
 189 {
 190     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 191     FieldValue *cValue = (FieldValue*) params [paramNo-1];
 192     if (NULL == cValue)
 193     {
 194         printError(ErrSysFatal, "condition value is null. Should never happen");
 195         return ErrSysFatal;
 196     }
 197     //TODO::check if the strlen(value) is greater than field length
 198     //do in all stmts
 199     strcpy((char*)cValue->value, value);
 200     return OK;
 201 }
 202 DbRetVal InsStatement::setDateParam(int paramNo, Date value)
 203 {
 204     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 205     FieldValue *cValue = (FieldValue*) params [paramNo-1];
 206     if (NULL == cValue)
 207     {
 208         printError(ErrSysFatal, "condition value is null. Should never happen");
 209         return ErrSysFatal;
 210     }
 211     *(Date*)cValue->value = value;
 212     return OK;
 213 }
 214 DbRetVal InsStatement::setTimeParam(int paramNo, Time value)
 215 {
 216     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 217     FieldValue *cValue = (FieldValue*) params [paramNo-1];
 218     if (NULL == cValue)
 219     {
 220         printError(ErrSysFatal, "condition value is null. Should never happen");
 221         return ErrSysFatal;
 222     }
 223     *(Time*)cValue->value = value;
 224     return OK;
 225 }
 226  void* InsStatement::getParamValuePtr( int pos )
 227  {
 228      FieldValue *p = (FieldValue*) params [pos-1];
 229      return ( (void*) p->value );
 230  }
 231
 232 DbRetVal InsStatement::setTimeStampParam(int paramNo, TimeStamp value)
 233 {
 234     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 235     FieldValue *cValue = (FieldValue*) params [paramNo-1];
 236     if (NULL == cValue)
 237     {
 238         printError(ErrSysFatal, "condition value is null. Should never happen");
 239         return ErrSysFatal;
 240     }
 241     *(TimeStamp*)cValue->value = value;
 242     return OK;
 243 }
 244
 245 DbRetVal InsStatement::setBinaryParam(int paramNo, void *value, int length)
 246 {
 247     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 248     FieldValue *fValue = (FieldValue*) params [paramNo-1];
 249     if (NULL == fValue)
 250     {
 251         printError(ErrSysFatal, "field value is null. Should never happen");
 252         return ErrSysFatal;
 253     }
 254     memcpy(fValue->value, value, 2 * fValue->length);
 255     return OK;
 256 }
 257
 258 long long InsStatement::getLastInsertedVal(DbRetVal &rv)
 259 {
 260     if(table)
 261         return ((TableImpl*)table)->getLastInsertedVal(rv);
 262     else{
 263         rv = ErrBadCall;
 264         return 0;
 265     }
 266 }
 267
 268 DbRetVal InsStatement::resolve()
 269 {
 270     if (dbMgr == NULL) return ErrNoConnection;
 271     //check whether the table exists
 272     table = dbMgr->openTable(parsedData->getTableName());
 273     if (table == NULL)
 274     {
 275         printError(ErrNotExists, "Unable to open the table:Table not exists");
 276         return ErrNotExists;
 277     }
 278
 279     List fieldNameList;
 280     //check whether filed list is specified
 281     if( 0 == parsedData->getFieldNameList().size() )
 282         fieldNameList = table->getFieldNameList();
 283     else
 284         fieldNameList = parsedData->getFieldNameList();
 285
 286     //check whether the total number of field name in the list is same as the total
 287     //number of values provided in the values list.
 288     if ( fieldNameList.size() !=
 289                                parsedData->getFieldValueList().size())
 290     {
 291         dbMgr->closeTable(table);
 292         table = NULL;
 293         printError(ErrSyntaxError, "Field Name list and field values do not match");
 294         return ErrSyntaxError;
 295     }
 296
 297     //get the fieldname list and validate field names
 298     ListIterator iter = fieldNameList.getIterator();
 299     ListIterator valIter = parsedData->getFieldValueList().getIterator();
 300     FieldName *name; FieldValue *value;
 301     FieldInfo *fInfo = new FieldInfo();
 302     int paramPos =1;
 303     DbRetVal rv = OK;
 304     while (iter.hasElement())
 305     {
 306         name = (FieldName*)iter.nextElement();
 307         value = (FieldValue*) valIter.nextElement();
 308         if (NULL == name || NULL == value)
 309         {
 310             dbMgr->closeTable(table);
 311             table = NULL;
 312             delete fInfo;
 313             printError(ErrSyntaxError, "Field Name list and field values do not match");
 314             return ErrSyntaxError;
 315         }
 316         rv = table->getFieldInfo(name->fldName, fInfo);
 317         if (ErrNotFound == rv)
 318         {
 319             dbMgr->closeTable(table);
 320             table = NULL;
 321             delete fInfo;
 322             printError(ErrSyntaxError, "Field %s does not exist in table",
 323                                         name->fldName);
 324             return ErrSyntaxError;
 325         }
 326         strcpy(value->fldName,name->fldName);
 327         value->type = fInfo->type;
 328         value->length = fInfo->length;
 329         value->isNullable = fInfo->isNull;
 330                 // for binary datatype input buffer size should be 2 times the length
 331         if (fInfo->type == typeBinary)
 332             value->value = AllDataType::alloc(fInfo->type, 2 * fInfo->length);
 333         else value->value = AllDataType::alloc(fInfo->type, fInfo->length);
 334         value->isAllocVal = true;
 335         if (value->parsedString == NULL) {
 336             table->bindFld(name->fldName, NULL, true);
 337             continue;
 338         }
 339         table->bindFld(name->fldName, value->value);
 340         if (value->parsedString[0] == '?')
 341         {
 342             value->paramNo = paramPos++;
 343         }
 344         if (!value->paramNo) {
 345              // Checking Integer value
 346              if((value->type == typeInt) || (value->type==typeShort) || (value->type==typeByteInt) || (value->type==typeLongLong) || (value->type==typeLong)){
 347                  int len=strlen(value->parsedString);
 348                  for(int n=0;n<len;n++){
 349                     int p=value->parsedString[n];
 350                     if(!(p>=48 && p<=57 || p==45) )
 351                         return ErrBadArg;
 352                  }
 353              }
 354             // for binary datatype buffer is just strcpy'd. It will be converted into binary datatype in copyValuesToBindBuffer in DBAPI
 355                 if (value->type == typeBinary)
 356                    strncpy((char *)value->value, value->parsedString, 2 * fInfo->length);
 357                 else AllDataType::strToValue(value->value, value->parsedString, fInfo->type, fInfo->length);
 358                  /* Checking range for char data type 8kb(8000) */
 359                  if(value->type==typeString){
 360                    int len=strlen(value->parsedString);
 361                    if(len > 8000){
 362                        printError(ErrBadRange,"Char data type length should be less than 8kb(8000).");
 363                        return ErrBadRange;
 364                    }
 365                 }
 366
 367        }
 368     }
 369     delete fInfo;
 370     totalParams = paramPos -1;
 371     if (0 == totalParams) {
 372         if( 0 == parsedData->getFieldNameList().size() ) {
 373             iter.reset();
 374             while(iter.hasElement())
 375                 delete (Identifier *) iter.nextElement();
 376             fieldNameList.reset();
 377         }
 378                 return OK;
 379         }
 380     params = (void**) malloc ( totalParams * sizeof(FieldValue*));
 381     paramValues = (char**) malloc( totalParams * sizeof(char*));
 382     memset(params, 0, totalParams * sizeof(FieldValue*));
 383     memset(paramValues, 0, totalParams * sizeof(char*));
 384     valIter.reset();
 385     while(valIter.hasElement())
 386     {
 387         value = (FieldValue*) valIter.nextElement();
 388         if (value == NULL)
 389         {
 390             dbMgr->closeTable(table);
 391             table = NULL;
 392             free(params); params = NULL;
 393             free(paramValues); paramValues = NULL;
 394             printError(ErrSysFatal, "Should never happen. value NULL after iteration");
 395             return ErrSysFatal;
 396         }
 397         if (value->paramNo == 0) continue;
 398         params[value->paramNo -1 ] = value;
 399     }
 400    // memory to be deallocated created by table->getFieldNameList
 401     if( 0 == parsedData->getFieldNameList().size() ) {
 402         iter.reset();
 403         while(iter.hasElement())
 404             delete (Identifier *) iter.nextElement();
 405         fieldNameList.reset();
 406     }
 407     return OK;
 408 }
 409 int InsStatement::getFldPos(char *name)
 410 {
 411     return table->getFldPos(name);
 412 }
 413