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::insertPredicate(char *fName1, ComparisionOp op, char *fName2)
 112 {
 113     PredicateImpl *pImpl = new PredicateImpl();
 114     pImpl->setTerm(fName1, op, fName2);
 115     return (Predicate*) pImpl;
 116 }
 117
 118 Predicate* ParsedData::insertPredicate(Predicate *p1, LogicalOp op, Predicate *p2)
 119 {
 120     PredicateImpl *pImpl = new PredicateImpl();
 121     pImpl->setTerm(p1, op, p2);
 122     return (Predicate*) pImpl;
 123 }
 124
 125 void ParsedData::reset()
 126 {
 127     ListIterator fNameIter = fieldNameList.getIterator();
 128     fNameIter.reset();
 129     while (fNameIter.hasElement())
 130         delete (Identifier *) fNameIter.nextElement();
 131     fieldNameList.reset();
 132     ListIterator iter = fieldValueList.getIterator();
 133     FieldValue *value;
 134     while (iter.hasElement())
 135     {
 136         value = (FieldValue*)iter.nextElement();
 137         free(value->parsedString);
 138         if (value->isAllocVal) free(value->value);
 139         delete value;
 140     }
 141     fieldValueList.reset();
 142     inValueList.reset();
 143     predicate.reset();
 144
 145     iter = conditionValueList.getIterator();
 146     ConditionValue *condVal;
 147     while (iter.hasElement())
 148     {
 149         condVal = (ConditionValue*)iter.nextElement();
 150         free(condVal->parsedString);
 151         free(condVal->value);
 152         delete condVal;
 153     }
 154     conditionValueList.reset();
 155
 156     iter = updFldValList.getIterator();
 157     UpdateFieldValue *updFldVal;
 158     while (iter.hasElement())
 159     {
 160         updFldVal = (UpdateFieldValue*)iter.nextElement();
 161         if(updFldVal->parsedString!=NULL)
 162            free(updFldVal->parsedString);
 163         if(updFldVal->expre!=NULL)
 164            updFldVal->expre->freeVal();
 165         free(updFldVal->value);
 166         delete updFldVal;
 167     }
 168     updFldValList.reset();
 169     groupFieldNameList.reset();
 170     iter = tableNameList.getIterator();
 171     TableName *tname;
 172     while (iter.hasElement())
 173     {
 174         tname = (TableName*)iter.nextElement();
 175         delete tname;
 176     }
 177     tableNameList.reset();
 178
 179     creFldList.removeAll();
 180     isUnique = false;
 181     isPrimary = false;
 182     indexType = hashIndex;
 183 }
 184 void ParsedData::clearFieldNameList()
 185 {
 186     fieldNameList.reset();
 187 }
 188
 189 void ParsedData::setFldName(char *name)
 190 {
 191     strcpy(fldDef.fldName_, name);
 192     fldDef.fldName_[IDENTIFIER_LENGTH] = '\0';
 193 }
 194
 195 void ParsedData::setFldType(DataType type)
 196 {
 197     fldDef.type_ = type;
 198 }
 199
 200 DbRetVal ParsedData::setFldLength(size_t length)
 201 {
 202     if(fldDef.type_ == typeBinary && (length-1) && (length-1) <= 256) {
 203         fldDef.length_ = length - 1; return OK;
 204     }
 205     else if (fldDef.type_ == typeBinary && (length-1) > 256) {
 206         return ErrBadRange;
 207     }
 208     else { fldDef.length_ = length; return OK; }
 209 }
 210
 211 void ParsedData::setFldNotNull(bool notNull)
 212 {
 213     fldDef.isNull_ = notNull;
 214 }
 215 void ParsedData::setDefaultValue(char *value)
 216 {
 217     fldDef.isDefault_ = true;
 218     if (strlen(value) > DEFAULT_VALUE_BUF_LENGTH -1)
 219     {
 220         strncpy(fldDef.defaultValueBuf_, value, DEFAULT_VALUE_BUF_LENGTH -1);
 221         fldDef.defaultValueBuf_[DEFAULT_VALUE_BUF_LENGTH] ='\0';
 222     } else
 223         strcpy(fldDef.defaultValueBuf_, value);
 224     return;
 225 }
 226
 227
 228 void ParsedData::insertFldDef()
 229 {
 230     DbRetVal rv = creFldList.append(fldDef);
 231     fldDef.init();
 232 }
 233
 234 Expression* ParsedData::insertExpression(char *fldName)
 235 {
 236     Expression *exp =new Expression();
 237     exp->setExpr(fldName);
 238     return exp;
 239 }
 240 Expression* ParsedData::insertExpression(char *value,bool flag)
 241 {
 242     Expression *exp =new Expression();
 243     exp->setExpr(strdup(value),flag);
 244     return exp;
 245 }
 246 Expression* ParsedData::insertExpression(Expression* exp1, ArithOperator op ,Expression* exp2)
 247 {
 248     Expression *exp =new Expression();
 249     exp->setExpr(exp1, op, exp2);
 250     return exp;
 251 }
 252 void ParsedData::insertUpdateExpression(char *fName, Expression *exp)
 253 {
 254     UpdateFieldValue *newVal = new UpdateFieldValue();
 255     strcpy(newVal->fldName, fName);
 256     newVal->parsedString = NULL;
 257     newVal->value = NULL;
 258     newVal->expre=exp;
 259     newVal->paramNo = 0;
 260     updFldValList.append(newVal);
 261 }