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->paramNo = 0;
 101     updFldValList.append(newVal);
 102 }
 103
 104 Predicate* ParsedData::insertPredicate(char *fName, ComparisionOp op, void **val)
 105 {
 106     PredicateImpl *pImpl = new PredicateImpl();
 107     pImpl->setTerm(fName, op, val);
 108     return (Predicate*) pImpl;
 109 }
 110 Predicate* ParsedData::insertPredicate(char *fName1, ComparisionOp op, char *fName2)
 111 {
 112     PredicateImpl *pImpl = new PredicateImpl();
 113     pImpl->setTerm(fName1, op, fName2);
 114     return (Predicate*) pImpl;
 115 }
 116
 117 Predicate* ParsedData::insertPredicate(Predicate *p1, LogicalOp op, Predicate *p2)
 118 {
 119     PredicateImpl *pImpl = new PredicateImpl();
 120     pImpl->setTerm(p1, op, p2);
 121     return (Predicate*) pImpl;
 122 }
 123
 124 void ParsedData::reset()
 125 {
 126     ListIterator fNameIter = fieldNameList.getIterator();
 127     fNameIter.reset();
 128     while (fNameIter.hasElement())
 129         delete (Identifier *) fNameIter.nextElement();
 130     fieldNameList.reset();
 131     ListIterator iter = fieldValueList.getIterator();
 132     FieldValue *value;
 133     while (iter.hasElement())
 134     {
 135         value = (FieldValue*)iter.nextElement();
 136         free(value->parsedString);
 137         if (value->isAllocVal) free(value->value);
 138         delete value;
 139     }
 140     fieldValueList.reset();
 141     inValueList.reset();
 142     predicate.reset();
 143
 144     iter = conditionValueList.getIterator();
 145     ConditionValue *condVal;
 146     while (iter.hasElement())
 147     {
 148         condVal = (ConditionValue*)iter.nextElement();
 149         free(condVal->parsedString);
 150         free(condVal->value);
 151         delete condVal;
 152     }
 153     conditionValueList.reset();
 154
 155     iter = updFldValList.getIterator();
 156     UpdateFieldValue *updFldVal;
 157     while (iter.hasElement())
 158     {
 159         updFldVal = (UpdateFieldValue*)iter.nextElement();
 160         free(updFldVal->parsedString);
 161         free(updFldVal->value);
 162         delete updFldVal;
 163     }
 164     updFldValList.reset();
 165     groupFieldNameList.reset();
 166     iter = tableNameList.getIterator();
 167     TableName *tname;
 168     while (iter.hasElement())
 169     {
 170         tname = (TableName*)iter.nextElement();
 171         delete tname;
 172     }
 173     tableNameList.reset();
 174
 175     creFldList.removeAll();
 176     isUnique = false;
 177     isPrimary = false;
 178     indexType = hashIndex;
 179 }
 180 void ParsedData::clearFieldNameList()
 181 {
 182     fieldNameList.reset();
 183 }
 184
 185 void ParsedData::setFldName(char *name)
 186 {
 187     strcpy(fldDef.fldName_, name);
 188     fldDef.fldName_[IDENTIFIER_LENGTH] = '\0';
 189 }
 190
 191 void ParsedData::setFldType(DataType type)
 192 {
 193     fldDef.type_ = type;
 194 }
 195
 196 void ParsedData::setFldLength(size_t length)
 197 {
 198     if(fldDef.type_ == typeBinary) fldDef.length_ = length - 1;
 199     else fldDef.length_ = length;
 200 }
 201
 202 void ParsedData::setFldNotNull(bool notNull)
 203 {
 204     fldDef.isNull_ = notNull;
 205 }
 206 void ParsedData::setDefaultValue(char *value)
 207 {
 208     fldDef.isDefault_ = true;
 209     if (strlen(value) > DEFAULT_VALUE_BUF_LENGTH -1)
 210     {
 211         strncpy(fldDef.defaultValueBuf_, value, DEFAULT_VALUE_BUF_LENGTH -1);
 212         fldDef.defaultValueBuf_[DEFAULT_VALUE_BUF_LENGTH] ='\0';
 213     } else
 214         strcpy(fldDef.defaultValueBuf_, value);
 215     return;
 216 }
 217
 218
 219 void ParsedData::insertFldDef()
 220 {
 221     DbRetVal rv = creFldList.append(fldDef);
 222     fldDef.init();
 223 }