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
 397     iter = tableNameList.getIterator();
 398     TableName *tname;
 399     while (iter.hasElement())
 400     {
 401         tname = (TableName*)iter.nextElement();
 402         delete tname;
 403     }
 404     tableNameList.reset();
 405
 406     iter = joinTypeList.getIterator();
 407     JoinTypeNode *jNode;
 408     while (iter.hasElement())
 409     {
 410         jNode = (JoinTypeNode*)iter.nextElement();
 411         delete jNode;
 412     }
 413     joinTypeList.reset();
 414
 415     if(userNode) { delete userNode; userNode =NULL;}
 416
 417     creFldList.removeAll();
 418     isUnique = false;
 419     isPrimary = false;
 420     isAutoIncrement =false;
 421     isForeign=false;
 422     indexType = hashIndex;
 423     hCondFld=false; vCondFld=false;pkFld=false;forceOption=false; direct=false; uncache=false; noschema=false; dsn=false;
 424     bucketSize = 0;
 425     shouldCreateTbl=false;
 426     limit =0;
 427     offset =0;
 428     ftype = UNKNOWN_FUNCTION;
 429 }
 430 void ParsedData::clearFieldNameList()
 431 {
 432     ListIterator it = fieldNameList.getIterator();
 433     while (it.hasElement()) delete ((FieldName *) it.nextElement());
 434     fieldNameList.reset();
 435 }
 436
 437 void ParsedData::setFldName(char *name)
 438 {
 439     strcpy(fldDef.fldName_, name);
 440     fldDef.fldName_[IDENTIFIER_LENGTH] = '\0';
 441 }
 442 char *ParsedData::getFldName()
 443 {
 444     return fldDef.fldName_;
 445 }
 446 void ParsedData::setAutoFldName(char *fldName)
 447 {
 448     FieldInfo *newVal = new FieldInfo();
 449     strcpy(newVal->fldName , fldName);
 450     newVal->isAutoIncrement = true;
 451     secondaryIndexFieldList.append(newVal);
 452 }
 453 void ParsedData::setFldType(DataType type)
 454 {
 455     fldDef.type_ = type;
 456 }
 457 DataType ParsedData::getFldType()
 458 {
 459    return fldDef.type_;
 460 }
 461 DbRetVal ParsedData::setAutoIncreament(bool flag)
 462 {
 463     if(isAutoIncrement){return ErrAlready;}
 464     fldDef.isAutoIncrement_=flag;
 465     isAutoIncrement=true;
 466     return OK;
 467 }
 468 bool ParsedData::getAutoIncreament()
 469 {
 470     return fldDef.isAutoIncrement_;
 471 }
 472
 473 DbRetVal ParsedData::setFldLength(size_t length)
 474 {
 475     if(fldDef.type_ == typeBinary && (length-1) && (length-1) <= 256) {
 476         fldDef.length_ = length - 1; return OK;
 477     }
 478     else if (fldDef.type_ == typeBinary && (length-1) > 256) {
 479         return ErrBadRange;
 480     }
 481     else { fldDef.length_ = length; return OK; }
 482 }
 483
 484 void ParsedData::setFldNotNull(bool notNull)
 485 {
 486     fldDef.isNull_ = notNull;
 487 }
 488 DbRetVal ParsedData::setDefaultValue(char *value)
 489 {
 490     DbRetVal rv=OK;
 491     fldDef.isDefault_ = true;
 492     if (value == NULL) {
 493         fldDef.defaultValueBuf_[0]='\0';
 494         return OK;;
 495     }
 496     /* Function to check Default Value */
 497     rv=validateDefaultValue(value);
 498     if(rv !=OK) return ErrDefaultValue;
 499
 500     if (strlen(value) > DEFAULT_VALUE_BUF_LENGTH -1)
 501     {
 502         strncpy(fldDef.defaultValueBuf_, value, DEFAULT_VALUE_BUF_LENGTH -1);
 503         fldDef.defaultValueBuf_[DEFAULT_VALUE_BUF_LENGTH] ='\0';
 504     } else strcpy(fldDef.defaultValueBuf_, value);
 505     return rv;
 506 }
 507 /* Validate Default value  */
 508 DbRetVal ParsedData::validateDefaultValue(char *value)
 509 {
 510     DbRetVal rv=OK;
 511     Date date;
 512     Time time;
 513     TimeStamp timeStamp;
 514     int ret=0;
 515     /* Default value checking for INT, SHORT, LONG, LONGLONG data type */
 516     if(fldDef.type_ == typeInt || fldDef.type_ == typeShort || fldDef.type_ == typeByteInt || fldDef.type_ == typeLongLong || fldDef.type_ == typeLong){
 517         for(int i=0; i<strlen(value); i++){
 518             if(!(value[i] >= '0' && value[i] <= '9'  || value[0]=='-')){
 519                 return ErrDefaultValue;
 520             }
 521         }
 522     }
 523     /* Default value check for FLOAT and DOUBLE data type*/
 524     else if (fldDef.type_ == typeFloat || fldDef.type_ == typeDouble){
 525         for(int i=0;i<strlen(value);i++){
 526             if(!(value[i] >= '0' && value[i] <='9' || value[0]=='-'  || value[i] == '.')){
 527                 return ErrDefaultValue;
 528             }
 529         }
 530     }
 531     /* Default value checking for DATE */
 532     else if(fldDef.type_ == typeDate ){
 533         ret=date.parseFrom(value);
 534         if(ret==-1){ return ErrDefaultValue;}
 535     }
 536      /*Default value checking for TIME  */
 537     else if(fldDef.type_ == typeTime ){
 538         ret=time.parseFrom(value);
 539         if(ret==-1){ return ErrDefaultValue;}
 540     }
 541     /* Default value checking for TIMESTAMP */
 542     else if(fldDef.type_ == typeTimeStamp ){
 543         ret=timeStamp.parseFrom(value);
 544         if(ret==-1){ return ErrDefaultValue;}
 545     }
 546     return rv;
 547 }
 548
 549
 550
 551
 552 void ParsedData::insertFldDef()
 553 {
 554     DbRetVal rv = creFldList.append(fldDef);
 555     fldDef.init();
 556 }
 557 Expression* ParsedData::insertExpression(Expression* exp1, FunctionType type,Expression* exp2)
 558 {
 559     Expression *exp =new Expression();
 560     exp->setExpr(exp1, type, exp2);
 561     return exp;
 562 }
 563 Expression* ParsedData::insertExpression(char *fldName)
 564 {
 565     Expression *exp =new Expression();
 566     exp->setExpr(fldName);
 567     return exp;
 568 }
 569
 570 Expression* ParsedData::insertExpression(char *value,bool flag)
 571 {
 572     Expression *exp =new Expression();
 573     exp->setExpr(strdup(value),flag);
 574     return exp;
 575 }
 576
 577 Expression* ParsedData::insertExpression(Expression* exp1, ArithOperator op ,Expression* exp2)
 578 {
 579     Expression *exp =new Expression();
 580     exp->setExpr(exp1, op, exp2);
 581     return exp;
 582 }
 583 void ParsedData::insertUpdateExpression(char *fName, Expression *exp)
 584 {
 585     UpdateFieldValue *newVal = new UpdateFieldValue();
 586     strcpy(newVal->fldName, fName);
 587     newVal->parsedString = NULL;
 588     newVal->value = NULL;
 589     newVal->expre=exp;
 590     newVal->paramNo = 0;
 591     updFldValList.append(newVal);
 592 }
 593 void ParsedData::createUserNode(char *name, char *password)
 594 {
 595     userNode = new UserNode();
 596     strcpy(userNode->userName, name);
 597     strcpy(userNode->passName, password);
 598     userNode->type = CREATEUSER;
 599 }
 600 void ParsedData::dropUserNode(char *name)
 601 {
 602     userNode = new UserNode();
 603     strcpy(userNode->userName, name);
 604     userNode->type = DROPUSER;
 605 }
 606 void ParsedData::alterUserNode(char *name, char *password)
 607 {
 608     userNode = new UserNode();
 609     strcpy(userNode->userName, name);
 610     strcpy(userNode->passName, password);
 611     userNode->type = ALTERUSER;
 612 }