src/sql/DelStatement.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 DelStatement::DelStatement()
  19 {
  20     parsedData = NULL;
  21     dbMgr = NULL;
  22     table = NULL;
  23     params = NULL;
  24     paramValues = NULL;
  25     totalParams = 0;
  26 }
  27
  28 DelStatement::~DelStatement() {
  29     if (table) {
  30         table->setCondition(NULL);
  31         if (dbMgr) dbMgr->closeTable(table);
  32     }
  33     if (totalParams) {
  34         free(params);
  35         params =  NULL;
  36         free(paramValues);
  37         paramValues = NULL;
  38     }
  39
  40 }
  41
  42 DbRetVal DelStatement::getParamFldInfo(int paramPos, FieldInfo *&info)
  43 {
  44     if (paramPos <=0 || paramPos > totalParams) return ErrBadArg;
  45     ConditionValue *value = (ConditionValue*) params[paramPos-1];
  46     if (value == NULL) { printError(ErrBadArg, "Should never happen\n");
  47                          return ErrBadArg; }
  48     info->type = value->type;
  49     info->length = value->length;
  50     return OK;
  51 }
  52 DbRetVal DelStatement::execute(int &rowsAffected)
  53 {
  54     DbRetVal rv = OK;
  55     //copy param values to binded buffer
  56     ConditionValue *value;
  57     for (int i = 0; i < totalParams; i ++)
  58     {
  59         value = (ConditionValue*) params[i];
  60         if (paramValues[i] == NULL)
  61         {
  62             continue;
  63             //printError(ErrBadCall, "param values not set");
  64             //return ErrBadCall;
  65         }
  66         AllDataType::copyVal(value->value, paramValues[i], value->type, value->length);
  67     }
  68     rv = table->execute();
  69     if (rv != OK) return rv;
  70     rowsAffected = 0;
  71     void *tuple;
  72     while(true)
  73     {
  74         tuple = (char*)table->fetchNoBind(rv);
  75         if (rv != OK) break;
  76         if (tuple == NULL) {break;}
  77         rv = table->deleteTuple();
  78         if (rv != OK) break;
  79         rowsAffected++;
  80     }
  81     table->close();
  82     return rv;
  83 }
  84
  85
  86 DbRetVal DelStatement::setParam(int paramNo, void *value)
  87 {
  88     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
  89     if (NULL == value) return ErrBadArg;
  90     paramValues[paramNo -1] = (char*) value;
  91     return OK;
  92 }
  93
  94 DbRetVal DelStatement::setShortParam(int paramNo, short value)
  95 {
  96     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
  97     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
  98     if (NULL == cValue)
  99     {
 100         printError(ErrSysFatal, "condition value is null. Should never happen");
 101         return ErrSysFatal;
 102     }
 103     *(short*)cValue->value = value;
 104     return OK;
 105 }
 106
 107 DbRetVal DelStatement::setIntParam(int paramNo, int value)
 108 {
 109     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 110     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 111     if (NULL == cValue)
 112     {
 113         printError(ErrSysFatal, "condition value is null. Should never happen");
 114         return ErrSysFatal;
 115     }
 116     *(int*)cValue->value = value;
 117     return OK;
 118 }
 119 DbRetVal DelStatement::setLongParam(int paramNo, long value)
 120 {
 121     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 122     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 123     if (NULL == cValue)
 124     {
 125         printError(ErrSysFatal, "condition value is null. Should never happen");
 126         return ErrSysFatal;
 127     }
 128     *(long*)cValue->value = value;
 129     return OK;
 130 }
 131
 132 DbRetVal DelStatement::setLongLongParam(int paramNo, long long value)
 133 {
 134     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 135     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 136     if (NULL == cValue)
 137     {
 138         printError(ErrSysFatal, "condition value is null. Should never happen");
 139         return ErrSysFatal;
 140     }
 141     *(long long*)cValue->value = value;
 142     return OK;
 143 }
 144 DbRetVal DelStatement::setByteIntParam(int paramNo, ByteInt value)
 145 {
 146     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 147     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 148     if (NULL == cValue)
 149     {
 150         printError(ErrSysFatal, "condition value is null. Should never happen");
 151         return ErrSysFatal;
 152     }
 153     *(ByteInt*)cValue->value = value;
 154     return OK;
 155 }
 156 DbRetVal DelStatement::setFloatParam(int paramNo, float value)
 157 {
 158     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 159     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 160     if (NULL == cValue)
 161     {
 162         printError(ErrSysFatal, "condition value is null. Should never happen");
 163         return ErrSysFatal;
 164     }
 165     *(float*)cValue->value = value;
 166     return OK;
 167 }
 168 DbRetVal DelStatement::setDoubleParam(int paramNo, double value)
 169 {
 170     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 171     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 172     if (NULL == cValue)
 173     {
 174         printError(ErrSysFatal, "condition value is null. Should never happen");
 175         return ErrSysFatal;
 176     }
 177     *(double*)cValue->value = value;
 178     return OK;
 179 }
 180 DbRetVal DelStatement::setStringParam(int paramNo, char *value)
 181 {
 182     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 183     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 184     if (NULL == cValue)
 185     {
 186         printError(ErrSysFatal, "condition value is null. Should never happen");
 187         return ErrSysFatal;
 188     }
 189     strcpy((char*)cValue->value, value);
 190     return OK;
 191 }
 192 DbRetVal DelStatement::setDateParam(int paramNo, Date value)
 193 {
 194     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 195     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 196     if (NULL == cValue)
 197     {
 198         printError(ErrSysFatal, "condition value is null. Should never happen");
 199         return ErrSysFatal;
 200     }
 201     *(Date*)cValue->value = value;
 202     return OK;
 203 }
 204 DbRetVal DelStatement::setTimeParam(int paramNo, Time value)
 205 {
 206     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 207     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 208     if (NULL == cValue)
 209     {
 210         printError(ErrSysFatal, "condition value is null. Should never happen");
 211         return ErrSysFatal;
 212     }
 213     *(Time*)cValue->value = value;
 214     return OK;
 215 }
 216  void* DelStatement::getParamValuePtr( int pos )
 217  {
 218      ConditionValue *cValue = (ConditionValue*) params [pos-1];
 219      return ( (void*) cValue->value );
 220  }
 221
 222 DbRetVal DelStatement::setTimeStampParam(int paramNo, TimeStamp value)
 223 {
 224     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 225     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 226     if (NULL == cValue)
 227     {
 228         printError(ErrSysFatal, "condition value is null. Should never happen");
 229         return ErrSysFatal;
 230     }
 231     *(TimeStamp*)cValue->value = value;
 232     return OK;
 233 }
 234
 235 DbRetVal DelStatement::resolve()
 236 {
 237     if (dbMgr == NULL) return ErrNoConnection;
 238     //check whether the table exists
 239     table = dbMgr->openTable(parsedData->getTableName());
 240     if (table == NULL)
 241     {
 242         printError(ErrNotExists, "Unable to open the table:Table not exists");
 243         return ErrNotExists;
 244     }
 245
 246     table->setCondition(parsedData->getCondition());
 247
 248     DbRetVal rv = resolveForCondition();
 249     if (rv != OK)
 250     {
 251         //TODO::free memory allocated for params
 252         table->setCondition(NULL);
 253         dbMgr->closeTable(table);
 254         table = NULL;
 255     }
 256     return rv;
 257 }
 258
 259
 260 DbRetVal DelStatement::resolveForCondition()
 261 {
 262     //get the fieldname list and validate field names
 263     ListIterator iter = parsedData->getConditionValueList().getIterator();
 264
 265     ConditionValue *value;
 266     FieldInfo *fInfo = new FieldInfo();
 267     int paramPos =1;
 268     DbRetVal rv = OK;
 269     while (iter.hasElement())
 270     {
 271         value = (ConditionValue*) iter.nextElement();
 272         if (NULL == value)
 273         {
 274             delete fInfo;
 275             printError(ErrSysFatal, "Should never happen.");
 276             return ErrSysFatal;
 277         }
 278         rv = table->getFieldInfo(value->fName, fInfo);
 279         if (ErrNotFound == rv)
 280         {
 281             delete fInfo;
 282             printError(ErrSyntaxError, "Field %s does not exist in table",
 283                                         value->fName);
 284             return ErrSyntaxError;
 285         }
 286         value->type = fInfo->type;
 287         value->length = fInfo->length;
 288         value->value = AllDataType::alloc(fInfo->type, fInfo->length);
 289         if (value->parsedString == NULL)
 290         {
 291             delete fInfo;
 292             printError(ErrSyntaxError, "Condition value should not be NULL");
 293             return ErrSyntaxError;
 294         }
 295
 296         if (value->parsedString[0] == '?')
 297         {
 298             value->paramNo = paramPos++;
 299         }
 300         if (!value->paramNo)
 301             AllDataType::strToValue(value->value, value->parsedString, fInfo->type);
 302     }
 303     delete fInfo;
 304     totalParams = paramPos -1;
 305     if (0 == totalParams) return OK;
 306     params = (void**) malloc ( totalParams * sizeof(FieldValue*));
 307     paramValues = (char**) malloc( totalParams * sizeof(char*));
 308     memset(params, 0, totalParams * sizeof(FieldValue*));
 309     memset(paramValues, 0, totalParams * sizeof(char*));
 310     iter.reset();
 311     while(iter.hasElement())
 312     {
 313         value = (ConditionValue*) iter.nextElement();
 314         if (value == NULL)
 315         {
 316             free(params); params = NULL;
 317             free(paramValues); paramValues = NULL;
 318             printError(ErrSysFatal, "Should never happen. value NULL after iteration");
 319             return ErrSysFatal;
 320         }
 321         params[value->paramNo -1 ] = value;
 322     }
 323     return OK;
 324 }