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 DbRetVal InsStatement::resolve()
 259 {
 260     if (dbMgr == NULL) return ErrNoConnection;
 261     //check whether the table exists
 262     table = dbMgr->openTable(parsedData->getTableName());
 263     if (table == NULL)
 264     {
 265         printError(ErrNotExists, "Unable to open the table:Table not exists");
 266         return ErrNotExists;
 267     }
 268
 269     List fieldNameList;
 270     //check whether filed list is specified
 271     if( 0 == parsedData->getFieldNameList().size() )
 272         fieldNameList = table->getFieldNameList();
 273     else
 274         fieldNameList = parsedData->getFieldNameList();
 275
 276     //check whether the total number of field name in the list is same as the total
 277     //number of values provided in the values list.
 278     if ( fieldNameList.size() !=
 279                                parsedData->getFieldValueList().size())
 280     {
 281         dbMgr->closeTable(table);
 282         table = NULL;
 283         printError(ErrSyntaxError, "Field Name list and field values do not match");
 284         return ErrSyntaxError;
 285     }
 286
 287     //get the fieldname list and validate field names
 288     ListIterator iter = fieldNameList.getIterator();
 289     ListIterator valIter = parsedData->getFieldValueList().getIterator();
 290     FieldName *name; FieldValue *value;
 291     FieldInfo *fInfo = new FieldInfo();
 292     int paramPos =1;
 293     DbRetVal rv = OK;
 294     while (iter.hasElement())
 295     {
 296         name = (FieldName*)iter.nextElement();
 297         value = (FieldValue*) valIter.nextElement();
 298         if (NULL == name || NULL == value)
 299         {
 300             dbMgr->closeTable(table);
 301             table = NULL;
 302             delete fInfo;
 303             printError(ErrSyntaxError, "Field Name list and field values do not match");
 304             return ErrSyntaxError;
 305         }
 306         rv = table->getFieldInfo(name->fldName, fInfo);
 307         if (ErrNotFound == rv)
 308         {
 309             dbMgr->closeTable(table);
 310             table = NULL;
 311             delete fInfo;
 312             printError(ErrSyntaxError, "Field %s does not exist in table",
 313                                         name->fldName);
 314             return ErrSyntaxError;
 315         }
 316         strcpy(value->fldName,name->fldName);
 317         value->type = fInfo->type;
 318         value->length = fInfo->length;
 319         value->isNullable = fInfo->isNull;
 320                 // for binary datatype input buffer size should be 2 times the length
 321         if (fInfo->type == typeBinary)
 322             value->value = AllDataType::alloc(fInfo->type, 2 * fInfo->length);
 323         else value->value = AllDataType::alloc(fInfo->type, fInfo->length);
 324         value->isAllocVal = true;
 325         if (value->parsedString == NULL) continue;
 326         table->bindFld(name->fldName, value->value);
 327         if (value->parsedString[0] == '?')
 328         {
 329             value->paramNo = paramPos++;
 330         }
 331         if (!value->paramNo) {
 332              // Checking Integer value
 333              if((value->type == typeInt) || (value->type==typeShort) || (value->type==typeByteInt) || (value->type==typeLongLong) || (value->type==typeLong)){
 334                  int len=strlen(value->parsedString);
 335                  for(int n=0;n<len;n++){
 336                     int p=value->parsedString[n];
 337                     if(!(p>=48 && p<=57 || p==45) )
 338                         return ErrBadArg;
 339                  }
 340              }
 341             // for binary datatype buffer is just strcpy'd. It will be converted into binary datatype in copyValuesToBindBuffer in DBAPI
 342                 if (value->type == typeBinary)
 343                    strncpy((char *)value->value, value->parsedString, 2 * fInfo->length);
 344                 else AllDataType::strToValue(value->value, value->parsedString, fInfo->type, fInfo->length);
 345        }
 346     }
 347     delete fInfo;
 348     totalParams = paramPos -1;
 349     if (0 == totalParams) {
 350         if( 0 == parsedData->getFieldNameList().size() ) {
 351             iter.reset();
 352             while(iter.hasElement())
 353                 delete (Identifier *) iter.nextElement();
 354             fieldNameList.reset();
 355         }
 356                 return OK;
 357         }
 358     params = (void**) malloc ( totalParams * sizeof(FieldValue*));
 359     paramValues = (char**) malloc( totalParams * sizeof(char*));
 360     memset(params, 0, totalParams * sizeof(FieldValue*));
 361     memset(paramValues, 0, totalParams * sizeof(char*));
 362     valIter.reset();
 363     while(valIter.hasElement())
 364     {
 365         value = (FieldValue*) valIter.nextElement();
 366         if (value == NULL)
 367         {
 368             dbMgr->closeTable(table);
 369             table = NULL;
 370             free(params); params = NULL;
 371             free(paramValues); paramValues = NULL;
 372             printError(ErrSysFatal, "Should never happen. value NULL after iteration");
 373             return ErrSysFatal;
 374         }
 375         if (value->paramNo == 0) continue;
 376         params[value->paramNo -1 ] = value;
 377     }
 378    // memory to be deallocated created by table->getFieldNameList
 379     if( 0 == parsedData->getFieldNameList().size() ) {
 380         iter.reset();
 381         while(iter.hasElement())
 382             delete (Identifier *) iter.nextElement();
 383         fieldNameList.reset();
 384     }
 385     return OK;
 386 }
 387 int InsStatement::getFldPos(char *name)
 388 {
 389     return table->getFldPos(name);
 390 }
 391