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<os.h>
  17 #include <Parser.h>
  18 #include <CSql.h>
  19 #include<PredicateImpl.h>
  20
  21
  22 void ParsedData::insertValue(char *val)
  23 {
  24     FieldValue *newVal = new FieldValue();
  25     if (val == NULL)
  26         newVal->parsedString = NULL;
  27     else
  28         newVal->parsedString = strdup(val);
  29     strcpy(newVal->fldName," ");
  30     newVal->value = NULL;
  31     newVal->paramNo = 0;
  32     newVal->type = typeUnknown;
  33     newVal->length = 0;
  34     newVal->isAllocVal=false;
  35     fieldValueList.append(newVal);
  36 }
  37
  38 void ParsedData::insertInValue(char *val)
  39 {
  40     FieldValue *newVal = new FieldValue();
  41     if (val == NULL)
  42         newVal->parsedString = NULL;
  43     else
  44         newVal->parsedString = strdup(val);
  45     strcpy(newVal->fldName," ");
  46     newVal->value = NULL;
  47     newVal->paramNo = 0;
  48     newVal->type = typeUnknown;
  49     newVal->length = 0;
  50     newVal->isAllocVal=false;
  51     inValueList.append(newVal);
  52 }
  53
  54 void** ParsedData::insertCondValueAndGetPtr(char *fldName, char *val, bool opLike, AggType aType, bool isInHaving)
  55 {
  56     ConditionValue *newVal = new ConditionValue();
  57     if (val == NULL)
  58         newVal->parsedString = NULL;
  59     else
  60         newVal->parsedString = strdup(val);
  61     newVal->value = NULL;
  62     newVal->paramNo = 0;
  63     newVal->type = typeUnknown;
  64     newVal->aType = aType;
  65     newVal->length = 0;
  66     strcpy(newVal->fName, fldName);
  67         newVal->opLike = opLike;
  68     conditionValueList.append(newVal);
  69     if (isInHaving) {
  70         FieldName *fName = new FieldName();
  71         strcpy(fName->fldName, fldName);
  72         fName->aType = aType;
  73         havingFieldNameList.append(fName);
  74     }
  75     return &(newVal->value);
  76
  77 }
  78
  79 void ParsedData::insertCondValue(char *fldName)
  80 {
  81     ConditionValue *newVal = new ConditionValue();
  82     newVal->parsedString = NULL;
  83     newVal->value = NULL;
  84     newVal->paramNo = 1;//To solve parsedString Null problem
  85     newVal->type = typeUnknown;
  86     newVal->aType = AGG_UNKNOWN;
  87     newVal->length = 0;
  88     strcpy(newVal->fName, fldName);
  89     newVal->opLike = false;
  90     conditionValueList.append(newVal);
  91 }
  92 void ParsedData::insertField(char *fName, AggType type)
  93 {
  94     FieldName *newVal = new FieldName();
  95     strcpy(newVal->fldName , fName);
  96     newVal->aType = type;
  97     fieldNameList.append(newVal);
  98 }
  99 void ParsedData::insertFieldAlias(char *name)
 100 {
 101     FieldName *newVal=NULL;
 102     newVal = (FieldName *)fieldNameList.get(fieldNameList.size());
 103     strcpy(newVal->aliasFldName, name);
 104 }
 105
 106 void ParsedData::insertFKField(char *fkName)
 107 {
 108     FieldName *newVal = new FieldName();
 109     strcpy(newVal->fldName , fkName);
 110     fkFieldNameList.append(newVal);
 111 }
 112 void ParsedData::insertPKField(char *pkName)
 113 {
 114     FieldName *newVal = new FieldName();
 115     strcpy(newVal->fldName , pkName);
 116     pkFieldNameList.append(newVal);
 117 }
 118 void ParsedData::insertForeignKeyList()
 119 {
 120     FieldName *name=NULL;
 121     ForeignKeyInfo *fkInfo = new ForeignKeyInfo();
 122    // strcpy(fkInfo->fkTableName,tblName);
 123     strcpy(fkInfo->pkTableName,pkTblName);
 124     ListIterator fNameIter = getFkFieldNameList().getIterator();
 125     fNameIter.reset();
 126     while (fNameIter.hasElement())
 127     {
 128         name = (FieldName *)fNameIter.nextElement();
 129         fkInfo->fkFldList.append(name->fldName);
 130         delete name;
 131     }
 132     fkFieldNameList.reset();
 133     fNameIter = getPkFieldNameList().getIterator();
 134     fNameIter.reset();
 135     while (fNameIter.hasElement())
 136     {
 137         name = (FieldName *)fNameIter.nextElement();
 138         fkInfo->pkFldList.append(name->fldName);
 139         delete name;
 140     }
 141     pkFieldNameList.reset();
 142     foreignKeyList.append(fkInfo);
 143 }
 144 void ParsedData::insertTableName(char *tName)
 145 {
 146     TableName *newVal = new TableName();
 147     strcpy(newVal->tblName , tName);
 148     tableNameList.append(newVal);
 149 }
 150 void ParsedData::insertJoinType(JoinType joinType)
 151 {
 152     JoinTypeNode *newVal = new JoinTypeNode();
 153     newVal->jType = joinType;
 154     joinTypeList.append(newVal);
 155 }
 156
 157
 158 void ParsedData::insertTableName(char *tName, char *aName)
 159 {
 160     TableName *newVal = new TableName();
 161     strcpy(newVal->tblName , tName);
 162     strcpy(newVal->aliasName , aName);
 163     tableNameList.append(newVal);
 164 }
 165 void ParsedData::insertGroupField(char *fName)
 166 {
 167     FieldName *newVal = new FieldName();
 168     strcpy(newVal->fldName , fName);
 169     groupFieldNameList.append(newVal);
 170 }
 171 void ParsedData::insertOrderByField(char *fName, bool isDesc)
 172 {
 173     FieldName *newVal = new FieldName();
 174     strcpy(newVal->fldName , fName);
 175     if (isDesc) newVal->aType = AGG_MIN; //using MIN to denote descending order
 176     orderFieldNameList.append(newVal);
 177 }
 178
 179 void ParsedData::insertUpdateValue(char *fName, char *val)
 180 {
 181     UpdateFieldValue *newVal = new UpdateFieldValue();
 182     strcpy(newVal->fldName, fName);
 183     if (val == NULL)
 184         newVal->parsedString = NULL;
 185     else
 186         newVal->parsedString = strdup(val);
 187     newVal->value = NULL;
 188     newVal->expre = NULL;
 189     newVal->paramNo = 0;
 190     updFldValList.append(newVal);
 191 }
 192
 193 Predicate* ParsedData::insertPredicate(char *fName, ComparisionOp op, void **val, AggType aggType)
 194 {
 195     PredicateImpl *pImpl = new PredicateImpl();
 196     pImpl->setTerm(fName, op, val, aggType);
 197     predList.append(pImpl);
 198     return (Predicate*) pImpl;
 199 }
 200 Predicate* ParsedData::insertBetPredicate(char *fName, ComparisionOp op1,
 201                             void **val1, ComparisionOp op2, void **val2)
 202 {
 203     PredicateImpl *pImpl = new PredicateImpl();
 204     pImpl->setTerm(fName, op1, val1, op2, val2);
 205     predList.append(pImpl);
 206     return (Predicate*) pImpl;
 207 }
 208 Predicate* ParsedData::insertNullPredicate(char *fName, ComparisionOp op,bool nullFlag)
 209 {
 210     PredicateImpl *pImpl = new PredicateImpl();
 211     pImpl->setTerm(fName, op, nullFlag);
 212     predList.append(pImpl);
 213     return (Predicate*) pImpl;
 214 }
 215
 216 Predicate* ParsedData::insertPredicate(char *fName1, ComparisionOp op, char *fName2)
 217 {
 218     PredicateImpl *pImpl = new PredicateImpl();
 219     pImpl->setTerm(fName1, op, fName2);
 220     predList.append(pImpl);
 221     return (Predicate*) pImpl;
 222 }
 223
 224 Predicate* ParsedData::insertPredicate(Predicate *p1, LogicalOp op, Predicate *p2)
 225 {
 226     PredicateImpl *pImpl = new PredicateImpl();
 227     pImpl->setTerm(p1, op, p2);
 228     predList.append(pImpl);
 229     return (Predicate*) pImpl;
 230 }
 231 void ParsedData::init()
 232 {
 233     tableNameList.init();
 234     fieldNameList.init();
 235     fieldValueList.init();
 236     inValueList.init();
 237     setCondition(NULL);
 238     setHavingCondition(NULL);
 239     predList.init();
 240     conditionValueList.init();
 241     updFldValList.init();
 242     groupFieldNameList.init();
 243     havingFieldNameList.init();
 244     orderFieldNameList.init();
 245     isDistinct = false;
 246     joinTypeList.init();
 247     isUnique = false;
 248     isPrimary = false;
 249     isAutoIncrement =false;
 250     isForeign=false;
 251     indexType = hashIndex;
 252     hCondFld=false; vCondFld=false;
 253     shouldCreateTbl=false;
 254     limit =0;
 255     offset =0;
 256     paramCounter = 0; stmtType = UnknownStatement;
 257     isExplain=false;
 258     plan = Normal;
 259 }
 260
 261 //NOTE::when you add members to reset() check whether it needs to be added in init() as it is used for statement caching when it contains parameters
 262 void ParsedData::reset()
 263 {
 264     ListIterator fNameIter = fieldNameList.getIterator();
 265     fNameIter.reset();
 266     while (fNameIter.hasElement())
 267         delete ((FieldName *) fNameIter.nextElement());
 268     fieldNameList.reset();
 269     fNameIter = secondaryIndexFieldList.getIterator();
 270     fNameIter.reset();
 271     while (fNameIter.hasElement())
 272         delete ((FieldName *) fNameIter.nextElement());
 273     secondaryIndexFieldList.reset();
 274
 275     fNameIter =pkFieldNameList.getIterator();
 276     fNameIter.reset();
 277     while (fNameIter.hasElement())
 278         delete ((FieldName *) fNameIter.nextElement());
 279     pkFieldNameList.reset();
 280     fNameIter = fkFieldNameList.getIterator();
 281     fNameIter.reset();
 282     while (fNameIter.hasElement())
 283         delete ((FieldName *) fNameIter.nextElement());
 284     fkFieldNameList.reset();
 285     ForeignKeyInfo *info=NULL;
 286     fNameIter = foreignKeyList.getIterator();
 287     while (fNameIter.hasElement())
 288     {
 289         info=(ForeignKeyInfo *) fNameIter.nextElement();
 290         info->fkFldList.removeAll();
 291         info->pkFldList.removeAll();
 292         delete info;
 293     }
 294     foreignKeyList.reset();
 295     ListIterator iter = fieldValueList.getIterator();
 296     FieldValue *value;
 297     while (iter.hasElement())
 298     {
 299         value = (FieldValue*)iter.nextElement();
 300         if (value->parsedString) free(value->parsedString);
 301         if (value->isAllocVal) free(value->value);
 302         delete value;
 303     }
 304     fieldValueList.reset();
 305     ListIterator inIter = inValueList.getIterator();
 306     while (inIter.hasElement()) {
 307         value = (FieldValue *) inIter.nextElement();
 308         if (value->parsedString) free(value->parsedString);
 309         delete value;
 310     }
 311     inValueList.reset();
 312
 313     predicate.reset();
 314     havingPredicate.reset();
 315     ListIterator pIter = predList.getIterator();
 316     while (pIter.hasElement()) {
 317         PredicateImpl *pImpl= (PredicateImpl *) pIter.nextElement();
 318         delete pImpl;
 319     }
 320     predList.reset();
 321
 322     iter = conditionValueList.getIterator();
 323     ConditionValue *condVal;
 324     while (iter.hasElement())
 325     {
 326         condVal = (ConditionValue*)iter.nextElement();
 327         free(condVal->parsedString);
 328         free(condVal->value);
 329         delete condVal;
 330     }
 331     conditionValueList.reset();
 332
 333     iter = updFldValList.getIterator();
 334     UpdateFieldValue *updFldVal;
 335     while (iter.hasElement())
 336     {
 337         updFldVal = (UpdateFieldValue*)iter.nextElement();
 338         if(updFldVal->parsedString!=NULL)
 339            free(updFldVal->parsedString);
 340         if(updFldVal->expre!=NULL){
 341            updFldVal->expre->freeVal();
 342            delete updFldVal->expre;
 343         }
 344         free(updFldVal->value);
 345         delete updFldVal;
 346     }
 347     updFldValList.reset();
 348     iter = groupFieldNameList.getIterator();
 349     while(iter.hasElement())
 350     {
 351         delete iter.nextElement();
 352     }
 353     groupFieldNameList.reset();
 354     iter = orderFieldNameList.getIterator();
 355     while(iter.hasElement())
 356     {
 357         delete iter.nextElement();
 358     }
 359
 360     iter = havingFieldNameList.getIterator();
 361      while(iter.hasElement())
 362     {
 363         delete iter.nextElement();
 364     }
 365     havingFieldNameList.reset();
 366
 367     orderFieldNameList.reset();
 368     isDistinct = false;
 369
 370     iter = tableNameList.getIterator();
 371     TableName *tname;
 372     while (iter.hasElement())
 373     {
 374         tname = (TableName*)iter.nextElement();
 375         delete tname;
 376     }
 377     tableNameList.reset();
 378
 379     iter = joinTypeList.getIterator();
 380     JoinTypeNode *jNode;
 381     while (iter.hasElement())
 382     {
 383         jNode = (JoinTypeNode*)iter.nextElement();
 384         delete jNode;
 385     }
 386     joinTypeList.reset();
 387
 388     if(userNode) { delete userNode; userNode =NULL;}
 389
 390     creFldList.removeAll();
 391     isUnique = false;
 392     isPrimary = false;
 393     isAutoIncrement =false;
 394     isForeign=false;
 395     indexType = hashIndex;
 396     hCondFld=false; vCondFld=false;pkFld=false;forceOption=false; direct=false; uncache=false; noschema=false; dsn=false;
 397     bucketSize = 0;
 398     shouldCreateTbl=false;
 399     limit =0;
 400     offset =0;
 401 }
 402 void ParsedData::clearFieldNameList()
 403 {
 404     ListIterator it = fieldNameList.getIterator();
 405     while (it.hasElement()) delete ((FieldName *) it.nextElement());
 406     fieldNameList.reset();
 407 }
 408
 409 void ParsedData::setFldName(char *name)
 410 {
 411     strcpy(fldDef.fldName_, name);
 412     fldDef.fldName_[IDENTIFIER_LENGTH] = '\0';
 413 }
 414 char *ParsedData::getFldName()
 415 {
 416     return fldDef.fldName_;
 417 }
 418 void ParsedData::setAutoFldName(char *fldName)
 419 {
 420     FieldInfo *newVal = new FieldInfo();
 421     strcpy(newVal->fldName , fldName);
 422     newVal->isAutoIncrement = true;
 423     secondaryIndexFieldList.append(newVal);
 424 }
 425 void ParsedData::setFldType(DataType type)
 426 {
 427     fldDef.type_ = type;
 428 }
 429 DataType ParsedData::getFldType()
 430 {
 431    return fldDef.type_;
 432 }
 433 DbRetVal ParsedData::setAutoIncreament(bool flag)
 434 {
 435     if(isAutoIncrement){return ErrAlready;}
 436     fldDef.isAutoIncrement_=flag;
 437     isAutoIncrement=true;
 438     return OK;
 439 }
 440 bool ParsedData::getAutoIncreament()
 441 {
 442     return fldDef.isAutoIncrement_;
 443 }
 444
 445 DbRetVal ParsedData::setFldLength(size_t length)
 446 {
 447     if(fldDef.type_ == typeBinary && (length-1) && (length-1) <= 256) {
 448         fldDef.length_ = length - 1; return OK;
 449     }
 450     else if (fldDef.type_ == typeBinary && (length-1) > 256) {
 451         return ErrBadRange;
 452     }
 453     else { fldDef.length_ = length; return OK; }
 454 }
 455
 456 void ParsedData::setFldNotNull(bool notNull)
 457 {
 458     fldDef.isNull_ = notNull;
 459 }
 460 void ParsedData::setDefaultValue(char *value)
 461 {
 462     fldDef.isDefault_ = true;
 463     if (value == NULL) {
 464         fldDef.defaultValueBuf_[0]='\0';
 465         return;
 466     }
 467     if (strlen(value) > DEFAULT_VALUE_BUF_LENGTH -1)
 468     {
 469         strncpy(fldDef.defaultValueBuf_, value, DEFAULT_VALUE_BUF_LENGTH -1);
 470         fldDef.defaultValueBuf_[DEFAULT_VALUE_BUF_LENGTH] ='\0';
 471     } else strcpy(fldDef.defaultValueBuf_, value);
 472     return;
 473 }
 474
 475
 476 void ParsedData::insertFldDef()
 477 {
 478     DbRetVal rv = creFldList.append(fldDef);
 479     fldDef.init();
 480 }
 481
 482 Expression* ParsedData::insertExpression(char *fldName)
 483 {
 484     Expression *exp =new Expression();
 485     exp->setExpr(fldName);
 486     return exp;
 487 }
 488 Expression* ParsedData::insertExpression(char *value,bool flag)
 489 {
 490     Expression *exp =new Expression();
 491     exp->setExpr(strdup(value),flag);
 492     return exp;
 493 }
 494 Expression* ParsedData::insertExpression(Expression* exp1, ArithOperator op ,Expression* exp2)
 495 {
 496     Expression *exp =new Expression();
 497     exp->setExpr(exp1, op, exp2);
 498     return exp;
 499 }
 500 void ParsedData::insertUpdateExpression(char *fName, Expression *exp)
 501 {
 502     UpdateFieldValue *newVal = new UpdateFieldValue();
 503     strcpy(newVal->fldName, fName);
 504     newVal->parsedString = NULL;
 505     newVal->value = NULL;
 506     newVal->expre=exp;
 507     newVal->paramNo = 0;
 508     updFldValList.append(newVal);
 509 }
 510 void ParsedData::createUserNode(char *name, char *password)
 511 {
 512     userNode = new UserNode();
 513     strcpy(userNode->userName, name);
 514     strcpy(userNode->passName, password);
 515     userNode->type = CREATEUSER;
 516 }
 517 void ParsedData::dropUserNode(char *name)
 518 {
 519     userNode = new UserNode();
 520     strcpy(userNode->userName, name);
 521     userNode->type = DROPUSER;
 522 }
 523 void ParsedData::alterUserNode(char *name, char *password)
 524 {
 525     userNode = new UserNode();
 526     strcpy(userNode->userName, name);
 527     strcpy(userNode->passName, password);
 528     userNode->type = ALTERUSER;
 529 }