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