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 void** ParsedData::insertCondValueAndGetPtr(char *fldName, char *val, bool opLike, AggType aType, bool isInHaving,bool function)
  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->aType = aType;
  64     newVal->length = 0;
  65     strcpy(newVal->fName, fldName);
  66     newVal->opLike = opLike;
  67     newVal->isFunctionInvolve = function;
  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(Expression *exp, ComparisionOp op,void **val)
 194 {
 195     PredicateImpl *pImpl = new PredicateImpl();
 196     exp->convertStrToVal(AllDataType::getCsqlTypeFromFunctionType(exp->getFunctionType()));
 197     pImpl->setTerm(exp, op, val);
 198     predList.append(pImpl);
 199     return (Predicate*) pImpl;
 200 }
 201 Predicate* ParsedData::insertPredicate(Expression *exp, ComparisionOp op,char *fName2)
 202 {
 203    PredicateImpl *pImpl = new PredicateImpl();
 204    exp->convertStrToVal(AllDataType::getCsqlTypeFromFunctionType(exp->getFunctionType()));
 205     pImpl->setTerm(exp, op, fName2);
 206     predList.append(pImpl);
 207     return (Predicate*) pImpl;
 208
 209 }
 210 Predicate* ParsedData::insertPredicate(Expression *exp1, ComparisionOp op,Expression *exp2)
 211 {
 212    PredicateImpl *pImpl = new PredicateImpl();
 213    exp1->convertStrToVal(AllDataType::getCsqlTypeFromFunctionType(exp1->getFunctionType()));
 214    exp2->convertStrToVal(AllDataType::getCsqlTypeFromFunctionType(exp2->getFunctionType()));
 215     pImpl->setTerm(exp1, op, exp2);
 216     predList.append(pImpl);
 217     return (Predicate*) pImpl;
 218 }
 219
 220 Predicate* ParsedData::insertPredicate(char *fName, ComparisionOp op, void **val, AggType aggType)
 221 {
 222     PredicateImpl *pImpl = new PredicateImpl();
 223     pImpl->setTerm(fName, op, val, aggType);
 224     predList.append(pImpl);
 225     return (Predicate*) pImpl;
 226 }
 227 Predicate* ParsedData::insertBetPredicate(char *fName, ComparisionOp op1,
 228                             void **val1, ComparisionOp op2, void **val2)
 229 {
 230     PredicateImpl *pImpl = new PredicateImpl();
 231     pImpl->setTerm(fName, op1, val1, op2, val2);
 232     predList.append(pImpl);
 233     return (Predicate*) pImpl;
 234 }
 235 Predicate* ParsedData::insertNullPredicate(char *fName, ComparisionOp op,bool nullFlag)
 236 {
 237     PredicateImpl *pImpl = new PredicateImpl();
 238     pImpl->setTerm(fName, op, nullFlag);
 239     predList.append(pImpl);
 240     return (Predicate*) pImpl;
 241 }
 242
 243 Predicate* ParsedData::insertPredicate(char *fName1, ComparisionOp op, char *fName2)
 244 {
 245     PredicateImpl *pImpl = new PredicateImpl();
 246     pImpl->setTerm(fName1, op, fName2);
 247     predList.append(pImpl);
 248     return (Predicate*) pImpl;
 249 }
 250
 251 Predicate* ParsedData::insertPredicate(Predicate *p1, LogicalOp op, Predicate *p2)
 252 {
 253     PredicateImpl *pImpl = new PredicateImpl();
 254     pImpl->setTerm(p1, op, p2);
 255     predList.append(pImpl);
 256     return (Predicate*) pImpl;
 257 }
 258 void ParsedData::init()
 259 {
 260     tableNameList.init();
 261     fieldNameList.init();
 262     fieldValueList.init();
 263     inValueList.init();
 264     setCondition(NULL);
 265     setHavingCondition(NULL);
 266     predList.init();
 267     conditionValueList.init();
 268     updFldValList.init();
 269     groupFieldNameList.init();
 270     havingFieldNameList.init();
 271     orderFieldNameList.init();
 272     isDistinct = false;
 273     joinTypeList.init();
 274     isUnique = false;
 275     isPrimary = false;
 276     isAutoIncrement =false;
 277     isForeign=false;
 278     indexType = hashIndex;
 279     hCondFld=false; vCondFld=false;
 280     shouldCreateTbl=false;
 281     limit =0;
 282     offset =0;
 283     paramCounter = 0; stmtType = UnknownStatement;
 284     isExplain=false;
 285     plan = Normal;
 286 }
 287
 288 //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
 289 void ParsedData::reset()
 290 {
 291     ListIterator fNameIter = fieldNameList.getIterator();
 292     fNameIter.reset();
 293     while (fNameIter.hasElement())
 294         delete ((FieldName *) fNameIter.nextElement());
 295     fieldNameList.reset();
 296     fNameIter = secondaryIndexFieldList.getIterator();
 297     fNameIter.reset();
 298     while (fNameIter.hasElement())
 299         delete ((FieldName *) fNameIter.nextElement());
 300     secondaryIndexFieldList.reset();
 301
 302     fNameIter =pkFieldNameList.getIterator();
 303     fNameIter.reset();
 304     while (fNameIter.hasElement())
 305         delete ((FieldName *) fNameIter.nextElement());
 306     pkFieldNameList.reset();
 307     fNameIter = fkFieldNameList.getIterator();
 308     fNameIter.reset();
 309     while (fNameIter.hasElement())
 310         delete ((FieldName *) fNameIter.nextElement());
 311     fkFieldNameList.reset();
 312     ForeignKeyInfo *info=NULL;
 313     fNameIter = foreignKeyList.getIterator();
 314     while (fNameIter.hasElement())
 315     {
 316         info=(ForeignKeyInfo *) fNameIter.nextElement();
 317         info->fkFldList.removeAll();
 318         info->pkFldList.removeAll();
 319         delete info;
 320     }
 321     foreignKeyList.reset();
 322     ListIterator iter = fieldValueList.getIterator();
 323     FieldValue *value;
 324     while (iter.hasElement())
 325     {
 326         value = (FieldValue*)iter.nextElement();
 327         if (value->parsedString) free(value->parsedString);
 328         if (value->isAllocVal) free(value->value);
 329         delete value;
 330     }
 331     fieldValueList.reset();
 332     ListIterator inIter = inValueList.getIterator();
 333     while (inIter.hasElement()) {
 334         value = (FieldValue *) inIter.nextElement();
 335         if (value->parsedString) free(value->parsedString);
 336         delete value;
 337     }
 338     inValueList.reset();
 339
 340     predicate.reset();
 341     havingPredicate.reset();
 342     ListIterator pIter = predList.getIterator();
 343     while (pIter.hasElement()) {
 344         PredicateImpl *pImpl= (PredicateImpl *) pIter.nextElement();
 345         delete pImpl;
 346     }
 347     predList.reset();
 348
 349     iter = conditionValueList.getIterator();
 350     ConditionValue *condVal;
 351     while (iter.hasElement())
 352     {
 353         condVal = (ConditionValue*)iter.nextElement();
 354         free(condVal->parsedString);
 355         free(condVal->value);
 356         delete condVal;
 357     }
 358     conditionValueList.reset();
 359
 360     iter = updFldValList.getIterator();
 361     UpdateFieldValue *updFldVal;
 362     while (iter.hasElement())
 363     {
 364         updFldVal = (UpdateFieldValue*)iter.nextElement();
 365         if(updFldVal->parsedString!=NULL)
 366            free(updFldVal->parsedString);
 367         if(updFldVal->expre!=NULL){
 368            updFldVal->expre->freeVal();
 369            delete updFldVal->expre;
 370         }
 371         free(updFldVal->value);
 372         delete updFldVal;
 373     }
 374     updFldValList.reset();
 375     iter = groupFieldNameList.getIterator();
 376     while(iter.hasElement())
 377     {
 378         delete iter.nextElement();
 379     }
 380     groupFieldNameList.reset();
 381     iter = orderFieldNameList.getIterator();
 382     while(iter.hasElement())
 383     {
 384         delete iter.nextElement();
 385     }
 386
 387     iter = havingFieldNameList.getIterator();
 388      while(iter.hasElement())
 389     {
 390         delete iter.nextElement();
 391     }
 392     havingFieldNameList.reset();
 393
 394     orderFieldNameList.reset();
 395     isDistinct = false;
 396     isExplain = false;
 397
 398     iter = tableNameList.getIterator();
 399     TableName *tname;
 400     while (iter.hasElement())
 401     {
 402         tname = (TableName*)iter.nextElement();
 403         delete tname;
 404     }
 405     tableNameList.reset();
 406
 407     iter = joinTypeList.getIterator();
 408     JoinTypeNode *jNode;
 409     while (iter.hasElement())
 410     {
 411         jNode = (JoinTypeNode*)iter.nextElement();
 412         delete jNode;
 413     }
 414     joinTypeList.reset();
 415
 416     if(userNode) { delete userNode; userNode =NULL;}
 417
 418     creFldList.removeAll();
 419     isUnique = false;
 420     isPrimary = false;
 421     isAutoIncrement =false;
 422     isForeign=false;
 423     indexType = hashIndex;
 424     hCondFld=false; vCondFld=false;pkFld=false;forceOption=false; direct=false; uncache=false; noschema=false; dsn=false;
 425     bucketSize = 0;
 426     shouldCreateTbl=false;
 427     limit =0;
 428     offset =0;
 429     ftype = UNKNOWN_FUNCTION;
 430 }
 431 void ParsedData::clearFieldNameList()
 432 {
 433     ListIterator it = fieldNameList.getIterator();
 434     while (it.hasElement()) delete ((FieldName *) it.nextElement());
 435     fieldNameList.reset();
 436 }
 437
 438 void ParsedData::setFldName(char *name)
 439 {
 440     strcpy(fldDef.fldName_, name);
 441     fldDef.fldName_[IDENTIFIER_LENGTH] = '\0';
 442 }
 443 char *ParsedData::getFldName()
 444 {
 445     return fldDef.fldName_;
 446 }
 447 void ParsedData::setAutoFldName(char *fldName)
 448 {
 449     FieldInfo *newVal = new FieldInfo();
 450     strcpy(newVal->fldName , fldName);
 451     newVal->isAutoIncrement = true;
 452     secondaryIndexFieldList.append(newVal);
 453 }
 454 void ParsedData::setFldType(DataType type)
 455 {
 456     fldDef.type_ = type;
 457 }
 458 DataType ParsedData::getFldType()
 459 {
 460    return fldDef.type_;
 461 }
 462 DbRetVal ParsedData::setAutoIncreament(bool flag)
 463 {
 464     if(isAutoIncrement){return ErrAlready;}
 465     fldDef.isAutoIncrement_=flag;
 466     isAutoIncrement=true;
 467     return OK;
 468 }
 469 bool ParsedData::getAutoIncreament()
 470 {
 471     return fldDef.isAutoIncrement_;
 472 }
 473
 474 DbRetVal ParsedData::setFldLength(size_t length)
 475 {
 476     if(fldDef.type_ == typeBinary && (length-1) && (length-1) <= 256) {
 477         fldDef.length_ = length - 1; return OK;
 478     }
 479     else if (fldDef.type_ == typeBinary && (length-1) > 256) {
 480         return ErrBadRange;
 481     }
 482     else { fldDef.length_ = length; return OK; }
 483 }
 484
 485 void ParsedData::setFldNotNull(bool notNull)
 486 {
 487     fldDef.isNull_ = notNull;
 488 }
 489 DbRetVal ParsedData::setDefaultValue(char *value)
 490 {
 491     DbRetVal rv=OK;
 492     fldDef.isDefault_ = true;
 493     if (value == NULL) {
 494         fldDef.defaultValueBuf_[0]='\0';
 495         return OK;;
 496     }
 497     /* Function to check Default Value */
 498     rv=validateDefaultValue(value);
 499     if(rv !=OK) return ErrDefaultValue;
 500
 501     if (strlen(value) > DEFAULT_VALUE_BUF_LENGTH -1)
 502     {
 503         strncpy(fldDef.defaultValueBuf_, value, DEFAULT_VALUE_BUF_LENGTH -1);
 504         fldDef.defaultValueBuf_[DEFAULT_VALUE_BUF_LENGTH] ='\0';
 505     } else strcpy(fldDef.defaultValueBuf_, value);
 506     return rv;
 507 }
 508 /* Validate Default value  */
 509 DbRetVal ParsedData::validateDefaultValue(char *value)
 510 {
 511     DbRetVal rv=OK;
 512     Date date;
 513     Time time;
 514     TimeStamp timeStamp;
 515     int ret=0;
 516     /* Default value checking for INT, SHORT, LONG, LONGLONG data type */
 517     if(fldDef.type_ == typeInt || fldDef.type_ == typeShort || fldDef.type_ == typeByteInt || fldDef.type_ == typeLongLong || fldDef.type_ == typeLong){
 518         for(int i=0; i<strlen(value); i++){
 519             if(!(value[i] >= '0' && value[i] <= '9'  || value[0]=='-')){
 520                 return ErrDefaultValue;
 521             }
 522         }
 523     }
 524     /* Default value check for FLOAT and DOUBLE data type*/
 525     else if (fldDef.type_ == typeFloat || fldDef.type_ == typeDouble){
 526         for(int i=0;i<strlen(value);i++){
 527             if(!(value[i] >= '0' && value[i] <='9' || value[0]=='-'  || value[i] == '.')){
 528                 return ErrDefaultValue;
 529             }
 530         }
 531     }
 532     /* Default value checking for DATE */
 533     else if(fldDef.type_ == typeDate ){
 534         ret=date.parseFrom(value);
 535         if(ret==-1){ return ErrDefaultValue;}
 536     }
 537      /*Default value checking for TIME  */
 538     else if(fldDef.type_ == typeTime ){
 539         ret=time.parseFrom(value);
 540         if(ret==-1){ return ErrDefaultValue;}
 541     }
 542     /* Default value checking for TIMESTAMP */
 543     else if(fldDef.type_ == typeTimeStamp ){
 544         ret=timeStamp.parseFrom(value);
 545         if(ret==-1){ return ErrDefaultValue;}
 546     }
 547     return rv;
 548 }
 549
 550
 551
 552
 553 void ParsedData::insertFldDef()
 554 {
 555     DbRetVal rv = creFldList.append(fldDef);
 556     fldDef.init();
 557 }
 558 Expression* ParsedData::insertExpression(Expression* exp1, FunctionType type,Expression* exp2)
 559 {
 560     Expression *exp =new Expression();
 561     exp->setExpr(exp1, type, exp2);
 562     return exp;
 563 }
 564 Expression* ParsedData::insertExpression(char *fldName)
 565 {
 566     Expression *exp =new Expression();
 567     exp->setExpr(fldName);
 568     return exp;
 569 }
 570
 571 Expression* ParsedData::insertExpression(char *value,bool flag)
 572 {
 573     Expression *exp =new Expression();
 574     exp->setExpr(strdup(value),flag);
 575     return exp;
 576 }
 577
 578 Expression* ParsedData::insertExpression(Expression* exp1, ArithOperator op ,Expression* exp2)
 579 {
 580     Expression *exp =new Expression();
 581     exp->setExpr(exp1, op, exp2);
 582     return exp;
 583 }
 584 void ParsedData::insertUpdateExpression(char *fName, Expression *exp)
 585 {
 586     UpdateFieldValue *newVal = new UpdateFieldValue();
 587     strcpy(newVal->fldName, fName);
 588     newVal->parsedString = NULL;
 589     newVal->value = NULL;
 590     newVal->expre=exp;
 591     newVal->paramNo = 0;
 592     updFldValList.append(newVal);
 593 }
 594 void ParsedData::createUserNode(char *name, char *password)
 595 {
 596     userNode = new UserNode();
 597     strcpy(userNode->userName, name);
 598     strcpy(userNode->passName, password);
 599     userNode->type = CREATEUSER;
 600 }
 601 void ParsedData::dropUserNode(char *name)
 602 {
 603     userNode = new UserNode();
 604     strcpy(userNode->userName, name);
 605     userNode->type = DROPUSER;
 606 }
 607 void ParsedData::alterUserNode(char *name, char *password)
 608 {
 609     userNode = new UserNode();
 610     strcpy(userNode->userName, name);
 611     strcpy(userNode->passName, password);
 612     userNode->type = ALTERUSER;
 613 }