src/sql/ParsedData.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 "Parser.h"
  17 #include <CSql.h>
  18 #include<PredicateImpl.h>
  19
  20
  21 void ParsedData::insertValue(char *val)
  22 {
  23     FieldValue *newVal = new FieldValue();
  24     if (val == NULL)
  25         newVal->parsedString = NULL;
  26     else
  27         newVal->parsedString = strdup(val);
  28     strcpy(newVal->fldName," ");
  29     newVal->value = NULL;
  30     newVal->paramNo = 0;
  31     newVal->type = typeUnknown;
  32     newVal->length = 0;
  33     newVal->isAllocVal=false;
  34     fieldValueList.append(newVal);
  35 }
  36
  37 void ParsedData::insertInValue(char *val)
  38 {
  39     FieldValue *newVal = new FieldValue();
  40     if (val == NULL)
  41         newVal->parsedString = NULL;
  42     else
  43         newVal->parsedString = strdup(val);
  44     strcpy(newVal->fldName," ");
  45     newVal->value = NULL;
  46     newVal->paramNo = 0;
  47     newVal->type = typeUnknown;
  48     newVal->length = 0;
  49     newVal->isAllocVal=false;
  50     inValueList.append(newVal);
  51 }
  52
  53 void** ParsedData::insertCondValueAndGetPtr(char *fldName, char *val, bool opLike)
  54 {
  55     ConditionValue *newVal = new ConditionValue();
  56     if (val == NULL)
  57         newVal->parsedString = NULL;
  58     else
  59         newVal->parsedString = strdup(val);
  60     newVal->value = NULL;
  61     newVal->paramNo = 0;
  62     newVal->type = typeUnknown;
  63     newVal->length = 0;
  64     strcpy(newVal->fName, fldName);
  65         newVal->opLike = opLike;
  66     conditionValueList.append(newVal);
  67     return &(newVal->value);
  68
  69 }
  70
  71 void ParsedData::insertField(char *fName, AggType type)
  72 {
  73     FieldName *newVal = new FieldName();
  74     strcpy(newVal->fldName , fName);
  75     newVal->aType = type;
  76     fieldNameList.append(newVal);
  77 }
  78 void ParsedData::insertTableName(char *tName)
  79 {
  80     TableName *newVal = new TableName();
  81     strcpy(newVal->tblName , tName);
  82     tableNameList.append(newVal);
  83 }
  84 void ParsedData::insertGroupField(char *fName)
  85 {
  86     FieldName *newVal = new FieldName();
  87     strcpy(newVal->fldName , fName);
  88     groupFieldNameList.append(newVal);
  89 }
  90
  91 void ParsedData::insertUpdateValue(char *fName, char *val)
  92 {
  93     UpdateFieldValue *newVal = new UpdateFieldValue();
  94     strcpy(newVal->fldName, fName);
  95     if (val == NULL)
  96         newVal->parsedString = NULL;
  97     else
  98         newVal->parsedString = strdup(val);
  99     newVal->value = NULL;
 100     newVal->expre = NULL;
 101     newVal->paramNo = 0;
 102     updFldValList.append(newVal);
 103 }
 104
 105 Predicate* ParsedData::insertPredicate(char *fName, ComparisionOp op, void **val)
 106 {
 107     PredicateImpl *pImpl = new PredicateImpl();
 108     pImpl->setTerm(fName, op, val);
 109     return (Predicate*) pImpl;
 110 }
 111 Predicate* ParsedData::insertBetPredicate(char *fName, ComparisionOp op1,
 112                             void **val1, ComparisionOp op2, void **val2)
 113 {
 114     PredicateImpl *pImpl = new PredicateImpl();
 115     pImpl->setTerm(fName, op1, val1, op2, val2);
 116     return (Predicate*) pImpl;
 117 }
 118 Predicate* ParsedData::insertPredicate(char *fName1, ComparisionOp op, char *fName2)
 119 {
 120     PredicateImpl *pImpl = new PredicateImpl();
 121     pImpl->setTerm(fName1, op, fName2);
 122     return (Predicate*) pImpl;
 123 }
 124
 125 Predicate* ParsedData::insertPredicate(Predicate *p1, LogicalOp op, Predicate *p2)
 126 {
 127     PredicateImpl *pImpl = new PredicateImpl();
 128     pImpl->setTerm(p1, op, p2);
 129     return (Predicate*) pImpl;
 130 }
 131
 132 void ParsedData::reset()
 133 {
 134     ListIterator fNameIter = fieldNameList.getIterator();
 135     fNameIter.reset();
 136     while (fNameIter.hasElement())
 137         delete ((FieldName *) fNameIter.nextElement());
 138     fieldNameList.reset();
 139     ListIterator iter = fieldValueList.getIterator();
 140     FieldValue *value;
 141     while (iter.hasElement())
 142     {
 143         value = (FieldValue*)iter.nextElement();
 144         free(value->parsedString);
 145         if (value->isAllocVal) free(value->value);
 146         delete value;
 147     }
 148     fieldValueList.reset();
 149     ListIterator inIter = inValueList.getIterator();
 150     while (inIter.hasElement()) {
 151         value = (FieldValue *) inIter.nextElement();
 152         if (value->parsedString) free(value->parsedString);
 153         delete value;
 154     }
 155     inValueList.reset();
 156
 157     predicate.reset();
 158
 159     iter = conditionValueList.getIterator();
 160     ConditionValue *condVal;
 161     while (iter.hasElement())
 162     {
 163         condVal = (ConditionValue*)iter.nextElement();
 164         free(condVal->parsedString);
 165         free(condVal->value);
 166         delete condVal;
 167     }
 168     conditionValueList.reset();
 169
 170     iter = updFldValList.getIterator();
 171     UpdateFieldValue *updFldVal;
 172     while (iter.hasElement())
 173     {
 174         updFldVal = (UpdateFieldValue*)iter.nextElement();
 175         if(updFldVal->parsedString!=NULL)
 176            free(updFldVal->parsedString);
 177         if(updFldVal->expre!=NULL)
 178            updFldVal->expre->freeVal();
 179         free(updFldVal->value);
 180         delete updFldVal;
 181     }
 182     updFldValList.reset();
 183     iter = groupFieldNameList.getIterator();
 184     while(iter.hasElement())
 185     {
 186         delete iter.nextElement();
 187     }
 188     groupFieldNameList.reset();
 189
 190     iter = tableNameList.getIterator();
 191     TableName *tname;
 192     while (iter.hasElement())
 193     {
 194         tname = (TableName*)iter.nextElement();
 195         delete tname;
 196     }
 197     tableNameList.reset();
 198
 199     creFldList.removeAll();
 200     isUnique = false;
 201     isPrimary = false;
 202     indexType = hashIndex;
 203 }
 204 void ParsedData::clearFieldNameList()
 205 {
 206     ListIterator it = fieldNameList.getIterator();
 207     while (it.hasElement()) delete ((FieldName *) it.nextElement());
 208     fieldNameList.reset();
 209 }
 210
 211 void ParsedData::setFldName(char *name)
 212 {
 213     strcpy(fldDef.fldName_, name);
 214     fldDef.fldName_[IDENTIFIER_LENGTH] = '\0';
 215 }
 216
 217 void ParsedData::setFldType(DataType type)
 218 {
 219     fldDef.type_ = type;
 220 }
 221
 222 DbRetVal ParsedData::setFldLength(size_t length)
 223 {
 224     if(fldDef.type_ == typeBinary && (length-1) && (length-1) <= 256) {
 225         fldDef.length_ = length - 1; return OK;
 226     }
 227     else if (fldDef.type_ == typeBinary && (length-1) > 256) {
 228         return ErrBadRange;
 229     }
 230     else { fldDef.length_ = length; return OK; }
 231 }
 232
 233 void ParsedData::setFldNotNull(bool notNull)
 234 {
 235     fldDef.isNull_ = notNull;
 236 }
 237 void ParsedData::setDefaultValue(char *value)
 238 {
 239     fldDef.isDefault_ = true;
 240     if (strlen(value) > DEFAULT_VALUE_BUF_LENGTH -1)
 241     {
 242         strncpy(fldDef.defaultValueBuf_, value, DEFAULT_VALUE_BUF_LENGTH -1);
 243         fldDef.defaultValueBuf_[DEFAULT_VALUE_BUF_LENGTH] ='\0';
 244     } else
 245         strcpy(fldDef.defaultValueBuf_, value);
 246     return;
 247 }
 248
 249
 250 void ParsedData::insertFldDef()
 251 {
 252     DbRetVal rv = creFldList.append(fldDef);
 253     fldDef.init();
 254 }
 255
 256 Expression* ParsedData::insertExpression(char *fldName)
 257 {
 258     Expression *exp =new Expression();
 259     exp->setExpr(fldName);
 260     return exp;
 261 }
 262 Expression* ParsedData::insertExpression(char *value,bool flag)
 263 {
 264     Expression *exp =new Expression();
 265     exp->setExpr(strdup(value),flag);
 266     return exp;
 267 }
 268 Expression* ParsedData::insertExpression(Expression* exp1, ArithOperator op ,Expression* exp2)
 269 {
 270     Expression *exp =new Expression();
 271     exp->setExpr(exp1, op, exp2);
 272     return exp;
 273 }
 274 void ParsedData::insertUpdateExpression(char *fName, Expression *exp)
 275 {
 276     UpdateFieldValue *newVal = new UpdateFieldValue();
 277     strcpy(newVal->fldName, fName);
 278     newVal->parsedString = NULL;
 279     newVal->value = NULL;
 280     newVal->expre=exp;
 281     newVal->paramNo = 0;
 282     updFldValList.append(newVal);
 283 }