src/relational/table/PredicateImpl.cxx

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by www.databasecache.com                           *
   3  *   Contact: praba_tuty@databasecache.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<Table.h>
  17 #include<Index.h>
  18 #include<CatalogTables.h>
  19 #include<Lock.h>
  20 #include<Debug.h>
  21 #include<PredicateImpl.h>
  22 #include<Table.h>
  23 #include<TableImpl.h>
  24 #include<JoinTableImpl.h>
  25 #include<Util.h>
  26 static char aggNames[][10] =
  27 {
  28     "MIN", "MAX", "SUM", "AVG", "COUNT",  ""
  29 };
  30
  31 PredicateImpl::~PredicateImpl()
  32 {
  33 //    if (lhs)  {delete lhs; lhs = NULL; }
  34 //    if (rhs) { delete rhs; rhs = NULL; }
  35 }
  36
  37 void PredicateImpl::print(int space)
  38 {
  39     char spaceBuf[IDENTIFIER_LENGTH];
  40     memset(spaceBuf, 32, IDENTIFIER_LENGTH);
  41     spaceBuf[space] = '\0';
  42
  43     printf("%s <PREDICATE>\n", spaceBuf);
  44     if (0 != strcmp(fldName1, "")) {
  45       if (aggType ==  AGG_UNKNOWN)
  46         printf("%s <FieldName1> %s </FieldName1>\n", spaceBuf, fldName1);
  47       else
  48         printf("%s <FieldName1> %s(%s) </FieldName1>\n", spaceBuf,
  49                                            aggNames[aggType-1], fldName1);
  50     }
  51     if (0 != strcmp(fldName2, ""))
  52         printf("%s <FieldName2> %s </FieldName2>\n", spaceBuf, fldName2);
  53     if (compOp != OpInvalidComparisionOp)
  54         printf("%s <CompOp> %s </CompOp>\n", spaceBuf, CompOpNames[compOp]);
  55     if (logicalOp != OpInvalidLogicalOp)
  56         printf("%s <LogOp> %s </LogOp>\n", spaceBuf, LogOpNames[logicalOp]);
  57     if (operand) printf("%s <Operand> VALUE </Operand>\n", spaceBuf);
  58     if (operandPtr) printf("%s <OperandPtr> VALUE </OperandPtr>\n", spaceBuf);
  59     if (comp2Op != OpInvalidComparisionOp)
  60         printf("%s <Comp2Op> %s </Comp2Op>\n", spaceBuf, CompOpNames[comp2Op]);
  61     if (operand2) printf("%s <Operand2> VALUE </Operand2>\n", spaceBuf);
  62     if (operand2Ptr) printf("%s <Operand2Ptr> VALUE </Operand2Ptr>\n", spaceBuf);
  63     //TEMP
  64     //printf("<ISPUSHEDDOWN> %d </ISPUSHEDDOWN>\n", isPushedDown);
  65
  66     if (lhs) {
  67        printf("%s <PRED-LEFT>\n", spaceBuf);
  68        lhs->print(space+2);
  69        printf("%s </PRED-LEFT>\n", spaceBuf);
  70     }
  71     if (rhs)
  72     {
  73        printf("%s <PRED-RIGHT>\n", spaceBuf);
  74        rhs->print(space+2);
  75        printf("%s </PRED-RIGHT>\n", spaceBuf);
  76     }
  77     printf("%s </PREDICATE>\n", spaceBuf);
  78
  79 }
  80
  81 void PredicateImpl::setTerm(const char* fName1, ComparisionOp op,
  82                         const char *fName2)
  83 {
  84     strcpy(fldName1, fName1);
  85     strcpy(fldName2, fName2);
  86     compOp = op;
  87     operand = NULL;
  88     operandPtr = NULL;
  89     lhs = rhs = NULL;
  90     parent = NULL;
  91     logicalOp = OpInvalidLogicalOp;
  92     comp2Op = OpInvalidComparisionOp;
  93     operand2 =NULL;
  94     operand2Ptr = NULL;
  95 }
  96
  97 //Operand should be of the same type of the field.This is must
  98 void PredicateImpl::setTerm(const char* fName1, ComparisionOp op, void *opnd)
  99 {
 100     strcpy(fldName1, fName1);
 101     compOp = op;
 102     operand = opnd;
 103     operandPtr = NULL;
 104     lhs = rhs = NULL;
 105     parent = NULL;
 106     logicalOp = OpInvalidLogicalOp;
 107     comp2Op = OpInvalidComparisionOp;
 108     operand2 =NULL;
 109     operand2Ptr = NULL;
 110 }
 111
 112 void  PredicateImpl::setTerm(Expression *exp, ComparisionOp op, void **opnd)
 113 {
 114     compOp = op;
 115     lhs = rhs = NULL;
 116     operandPtr = opnd;
 117     operand = NULL;
 118     logicalOp = OpInvalidLogicalOp;
 119     comp2Op = OpInvalidComparisionOp;
 120     operand2 =NULL;
 121     operand2Ptr = NULL;
 122     lExp = exp;
 123 }
 124
 125 void  PredicateImpl::setTerm(Expression *exp1, ComparisionOp op, Expression *exp2)
 126 {
 127     compOp = op;
 128     lhs = rhs = NULL;
 129     operandPtr = NULL;
 130     operand = NULL;
 131     logicalOp = OpInvalidLogicalOp;
 132     comp2Op = OpInvalidComparisionOp;
 133     operand2 =NULL;
 134     operand2Ptr = NULL;
 135     lExp = exp1;
 136     rExp = exp2;
 137 }
 138
 139 void PredicateImpl::setTerm(Expression *exp, ComparisionOp  op, const char *fName2 )
 140 {
 141     strcpy(fldName2, fName2);
 142     compOp = op;
 143     operand = NULL;
 144     operandPtr = NULL;
 145     lhs = rhs = NULL;
 146     parent = NULL;
 147     logicalOp = OpInvalidLogicalOp;
 148     comp2Op = OpInvalidComparisionOp;
 149     operand2 =NULL;
 150     operand2Ptr = NULL;
 151     lExp = exp;
 152     return;
 153 }
 154
 155 void PredicateImpl::setTerm(const char* fName1, ComparisionOp op,bool nullFlag)
 156 {
 157     strcpy(fldName1, fName1);
 158     compOp = op;
 159     isNull = nullFlag;
 160     lhs = rhs = NULL;
 161     operandPtr = NULL;
 162     operand = NULL;
 163     logicalOp = OpInvalidLogicalOp;
 164     comp2Op = OpInvalidComparisionOp;
 165     operand2 =NULL;
 166     operand2Ptr = NULL;
 167 }
 168
 169 void PredicateImpl::setTerm(const char* fName1, ComparisionOp op, void **opnd)
 170 {
 171     strcpy(fldName1, fName1);
 172     compOp = op;
 173     operand = NULL;
 174     operandPtr = opnd;
 175     lhs = rhs = NULL;
 176     parent = NULL;
 177     logicalOp = OpInvalidLogicalOp;
 178     comp2Op = OpInvalidComparisionOp;
 179     operand2 =NULL;
 180     operand2Ptr = NULL;
 181 }
 182
 183 void PredicateImpl::setTerm(const char* fName1, ComparisionOp op, void **opnd, AggType aType)
 184 {
 185     strcpy(fldName1, fName1);
 186     compOp = op;
 187     operand = NULL;
 188     operandPtr = opnd;
 189     lhs = rhs = NULL;
 190     parent = NULL;
 191     aggType = aType;
 192     logicalOp = OpInvalidLogicalOp;
 193     comp2Op = OpInvalidComparisionOp;
 194     operand2 =NULL;
 195     operand2Ptr = NULL;
 196 }
 197
 198 void PredicateImpl::setTerm(const char* fName1, ComparisionOp op, void **opnd,
 199                                               ComparisionOp op2, void **opnd2)
 200 {
 201     strcpy(fldName1, fName1);
 202     compOp = op;
 203     operand = NULL;
 204     operandPtr = opnd;
 205     lhs = rhs = NULL;
 206     parent = NULL;
 207     logicalOp = OpInvalidLogicalOp;
 208
 209     comp2Op = op2;
 210     operand2=NULL;
 211     operand2Ptr = opnd2;
 212 }
 213
 214 void PredicateImpl::setParent(PredicateImpl *pImpl)
 215 {
 216    //if (parent != NULL) printf("Parent already set\n");
 217    parent = pImpl;
 218    return;
 219 }
 220
 221 void PredicateImpl::setTerm(Predicate *p1, LogicalOp op, Predicate *p2 )
 222 {
 223     if (p2 == NULL && op != OpNot || op == OpNot && p2 != NULL)
 224     {
 225         //TODO::printError
 226         printError(ErrBadArg, "Wrong argument passed\n");
 227         return;
 228     }
 229     lhs = (PredicateImpl*)p1;
 230     rhs = (PredicateImpl*)p2;
 231     logicalOp = op;
 232     compOp = OpInvalidComparisionOp;
 233     if (lhs != NULL) lhs->setParent(this);
 234     if (rhs != NULL) rhs->setParent(this);
 235     return;
 236 }
 237
 238 void PredicateImpl::setTable(Table *tbl)
 239 {
 240     if (NULL != lhs)
 241         lhs->setTable(tbl);
 242     if (NULL != rhs)
 243         rhs->setTable(tbl);
 244    table = tbl;
 245 }
 246
 247 void PredicateImpl::setIfNoLeftRight()
 248 {
 249     if (NULL != lhs)
 250         lhs->setIfNoLeftRight();
 251     if (NULL != rhs)
 252         rhs->setIfNoLeftRight();
 253     if(NULL == lhs && NULL == rhs) isNoLeftRight=true;
 254     return;
 255 }
 256
 257 void PredicateImpl::setTuple(void *tpl)
 258 {
 259     if (isNoLeftRight) {
 260         tuple=tpl;
 261         return;
 262     }
 263     if (NULL != lhs)
 264         lhs->setTuple(tpl);
 265     if (NULL != rhs)
 266          rhs->setTuple(tpl);
 267     tuple = tpl;
 268 }
 269
 270 void PredicateImpl::setProjectionList(List *lst)
 271 {
 272     if (NULL != lhs)
 273         lhs->setProjectionList(lst);
 274     if (NULL != rhs)
 275          rhs->setProjectionList(lst);
 276     projList = lst;
 277     isBindBufSet = false;
 278 }
 279
 280 bool PredicateImpl::isSingleTerm()
 281 {
 282     if (NULL == lhs  && NULL == rhs && comp2Op == OpInvalidComparisionOp)
 283         return true;
 284     return false;
 285 }
 286
 287 bool PredicateImpl::appendIfSameFld(char *fName, ComparisionOp op, void *buf)
 288 {
 289     char fieldName1[IDENTIFIER_LENGTH];
 290     Table::getFieldNameAlone(fldName1, fieldName1);
 291     if (strcmp(fName,fieldName1) == 0)
 292     {
 293         printDebug(DM_Predicate, "Field name matched");
 294         /*
 295         //switching so that in case of joins, first other conditions are
 296         //evaluated first and then matching tuples for join is evaluated
 297         //otherwise it may give wrong result set
 298         if (operand) {operand2 = operand; operand2Ptr = NULL; }
 299         if (operandPtr)  {operand2Ptr = operandPtr; operand2 = NULL; }
 300         comp2Op = compOp;
 301         compOp = op;
 302         operand = buf;
 303         operandPtr = NULL;
 304         */
 305         comp2Op = op;
 306         operand2 = buf;
 307
 308         return true;
 309     }
 310     return false;
 311 }
 312
 313 bool PredicateImpl::isIsNullInvolved()
 314 {
 315     bool lhsResult = true, rhsResult = true;
 316     if (NULL != lhs)
 317     {
 318         lhsResult = lhs->isIsNullInvolved();
 319     }
 320     if (NULL != rhs)
 321     {
 322         rhsResult = rhs->isIsNullInvolved();
 323     }
 324     if (NULL != lhs)
 325     {
 326         if (lhsResult || rhsResult) return true;
 327         if(compOp == isNull) return true;
 328     }
 329     return false;
 330 }
 331
 332 bool PredicateImpl::isNotOrInvolved()
 333 {
 334     bool lhsResult = true, rhsResult = true;
 335     if (NULL != lhs)
 336     {
 337         lhsResult = lhs->isNotOrInvolved();
 338     }
 339     if (NULL != rhs)
 340     {
 341         rhsResult = rhs->isNotOrInvolved();
 342     }
 343     if (NULL != lhs)
 344     {
 345         //Means it involves only Logical operator
 346             switch(logicalOp)
 347             {
 348                 case OpAnd:
 349                      if (lhsResult || rhsResult) return true;  else return false;
 350                      break;
 351                 case OpOr:
 352                      return true;
 353                      break;
 354                 case OpNot:
 355                 default:
 356                      return true;
 357                      break;
 358         }
 359     }
 360     return false;
 361 }
 362
 363 void* PredicateImpl::getValIfPointLookupOnInt(int &offset)
 364 { //perf opt
 365     if (NULL != lhs && NULL != rhs) return NULL;
 366     if(typeInt != type || comp2Op !=OpInvalidComparisionOp) return NULL;
 367     if (compOp != OpEquals) return NULL;
 368     offset = offset1;
 369     void *val =NULL;
 370     if(operand == NULL && operandPtr != NULL)
 371     {
 372         val = *(void**)operandPtr;
 373     } else if(operand != NULL && operandPtr == NULL)
 374     {
 375         val = (void*) operand;
 376     }
 377     return val;
 378 }
 379
 380 void* PredicateImpl::getVal1IfBetweenOnInt(int &offset)
 381 { //perf opt
 382     if (NULL != lhs && NULL != rhs) return NULL;
 383     if(typeInt != type)  return NULL;
 384     if (compOp != OpGreaterThanEquals ||
 385         comp2Op !=OpLessThanEquals) return NULL;
 386     offset = offset1;
 387     void *val =NULL;
 388     if(operand == NULL && operandPtr != NULL)
 389     {
 390         val = *(void**)operandPtr;
 391     } else if(operand != NULL && operandPtr == NULL)
 392     {
 393         val = (void*) operand;
 394     }
 395     return val;
 396 }
 397
 398 void* PredicateImpl::getVal2IfBetweenOnInt(int &offset)
 399 { //perf opt
 400     if (NULL != lhs && NULL != rhs) return NULL;
 401     if(typeInt != type)  return NULL;
 402     if (compOp != OpGreaterThanEquals ||
 403         comp2Op !=OpLessThanEquals) return NULL;
 404     offset = offset1;
 405     void *val =NULL;
 406     if(operand2 == NULL && operand2Ptr != NULL)
 407     {
 408         val = *(void**)operand2Ptr;
 409     } else if(operand2 != NULL && operand2Ptr == NULL)
 410     {
 411         val = (void*) operand2;
 412     }
 413     return val;
 414 }
 415
 416 void PredicateImpl::solveForProjList(Table *tab)
 417 {
 418     if (NULL != lhs)
 419     {
 420         lhs->solveForProjList(tab);
 421     }
 422     if (NULL != rhs)
 423     {
 424         rhs->solveForProjList(tab);
 425     }
 426     table = tab;
 427     if (NULL != lhs) return ;
 428     bool isExist1=false;
 429     bool isExist2=false;
 430     if (projList)
 431     {
 432         ListIterator fIter = projList->getIterator();
 433         JoinProjFieldInfo  *def;
 434         while (fIter.hasElement())
 435         {
 436             def = (JoinProjFieldInfo*) fIter.nextElement();
 437             if (!isExist1 && 0 == strcmp(fldName1, def->tabFieldName))
 438             {
 439                 isExist1=true;
 440             }
 441             if (!isExist2 && 0 == strcmp(fldName2, def->tabFieldName) )
 442             {
 443                 isExist2=true;
 444             }
 445         }
 446         if (!isExist1)
 447         {
 448             tab->bindFld(fldName1, NULL);
 449         }
 450         if (!isExist2 &&  strcmp(fldName2, "")!=0)
 451         {
 452             tab->bindFld(fldName2, NULL);
 453         }
 454      }
 455 }
 456
 457 void PredicateImpl::setOffsetAndType()
 458 {
 459     if (NULL != lhs)
 460     {
 461         lhs->setOffsetAndType();
 462     }
 463     if (NULL != rhs)
 464     {
 465         rhs->setOffsetAndType();
 466     }
 467     char fieldName1[IDENTIFIER_LENGTH];
 468     char fieldName2[IDENTIFIER_LENGTH];
 469     memset(fieldName1, 0, IDENTIFIER_LENGTH);
 470     memset(fieldName2, 0, IDENTIFIER_LENGTH);
 471     Table::getFieldNameAlone(fldName1, fieldName1);
 472     Table::getFieldNameAlone(fldName2, fieldName2);
 473     //this function is called only from TableImpl
 474     TableImpl *tImpl = (TableImpl*) table;
 475     if(fieldName1){
 476         FieldInfo *info = new FieldInfo();
 477         tImpl->getFieldInfo(fieldName1, info);
 478         offset1 = tImpl->getFieldOffset(fieldName1);
 479         fldPos = tImpl->getFldPos(fieldName1);
 480         type = info->type;
 481         length = info->length;
 482         isNullable = true;
 483         if (info->isNull || info->isPrimary || info->isAutoIncrement)
 484              isNullable = false;
 485         //printf("isNullable is set to %d\n", isNullable);
 486         delete info;
 487     }
 488
 489     if(fieldName2){
 490         offset2 = tImpl->getFieldOffset(fieldName2);
 491         if(typeUnknown == type)
 492             type = tImpl->getFieldType(fieldName2);
 493     }
 494
 495 }
 496
 497 bool PredicateImpl::pointLookupInvolved(const char *fname)
 498 {
 499     bool rhsResult, lhsResult;
 500     if (NULL != lhs)
 501     {
 502         lhsResult = lhs->pointLookupInvolved(fname);
 503     }
 504     if (NULL != rhs)
 505     {
 506         rhsResult = rhs->pointLookupInvolved(fname);
 507     }
 508     if (NULL != lhs)
 509     {
 510         //Means it involves only Logical operator
 511             switch(logicalOp)
 512             {
 513                 case OpAnd:
 514                      //return lhsResult;
 515                      if (lhsResult || rhsResult) return true;  else return false;
 516                      break;
 517                 case OpOr:
 518                      return false;
 519                      break;
 520                 case OpNot:
 521                 default:
 522                      return false;
 523                      break;
 524         }
 525     }
 526     //Means it is relational expression
 527     //first operand is always field identifier
 528     char fieldName1[IDENTIFIER_LENGTH];
 529     Table::getFieldNameAlone(fldName1, fieldName1);
 530     if (OpEquals == compOp)
 531     {
 532         //for expressions f1 == f2 use full scan, so return false
 533         if(NULL == operand && NULL == operandPtr) return false;
 534         if(0 == strcmp(fieldName1, fname))
 535         {
 536             return true;
 537         }
 538     }
 539     return false;
 540 }
 541
 542 bool PredicateImpl::isBetweenInvolved(const char *fname)
 543 {
 544     bool rhsResult, lhsResult;
 545     if (NULL != lhs)
 546     {
 547         lhsResult = lhs->isBetweenInvolved(fname);
 548     }
 549     if (NULL != rhs)
 550     {
 551         rhsResult = rhs->isBetweenInvolved(fname);
 552     }
 553     if (NULL != lhs)
 554     {
 555             switch(logicalOp)
 556             {
 557                 case OpAnd:
 558                      if (lhsResult && rhsResult) return true;  else return false;
 559                      break;
 560                 default:
 561                      return false;
 562                      break;
 563             }
 564      }
 565      char fieldName1[IDENTIFIER_LENGTH];
 566      Table::getFieldNameAlone(fldName1, fieldName1);
 567      if ( OpGreaterThan == compOp || OpGreaterThanEquals == compOp)
 568      {
 569         if(0 == strcmp(fieldName1, fname))
 570         {
 571            return true;
 572         }
 573     }
 574     return false;
 575 }
 576
 577 bool PredicateImpl::rangeQueryInvolved(const char *fname)
 578 {
 579     bool rhsResult, lhsResult;
 580     if (NULL != lhs)
 581     {
 582         lhsResult = lhs->rangeQueryInvolved(fname);
 583     }
 584     if (NULL != rhs)
 585     {
 586         rhsResult = rhs->rangeQueryInvolved(fname);
 587     }
 588     if (NULL != lhs)
 589     {
 590             switch(logicalOp)
 591             {
 592                 case OpAnd:
 593                      if (lhsResult || rhsResult) return true;  else return false;
 594                      break;
 595                 case OpOr:
 596                      return false;
 597                      break;
 598                 case OpNot:
 599                 default:
 600                      return false;
 601                      break;
 602         }
 603     }
 604     //Means it is relational expression
 605     //first operand is always field identifier
 606     char fieldName1[IDENTIFIER_LENGTH];
 607     Table::getFieldNameAlone(fldName1, fieldName1);
 608     if (OpLessThan == compOp || OpLessThanEquals == compOp ||
 609         OpGreaterThan == compOp || OpGreaterThanEquals == compOp)
 610     {
 611          //for expressions f1 == f2 use full scan, so return false
 612         if(NULL == operand && NULL == operandPtr) return false;
 613         if(0 == strcmp(fieldName1, fname))
 614         {
 615             return true;
 616         }
 617     }
 618     return false;
 619 }
 620
 621 void* PredicateImpl::opAndValPtrForIndexField(const char *fname, bool isUnique,ComparisionOp &op)
 622 {
 623     ComparisionOp lhsOp= OpInvalidComparisionOp, rhsOp= OpInvalidComparisionOp;
 624     void *lhsRet=NULL, *rhsRet=NULL;
 625     if (NULL != lhs)
 626     {
 627         lhsRet = lhs->opAndValPtrForIndexField(fname, isUnique, lhsOp);
 628     }
 629     if (NULL != rhs)
 630     {
 631         rhsRet = rhs->opAndValPtrForIndexField(fname, isUnique,rhsOp);
 632     }
 633     if (lhsRet && lhsOp == OpEquals) { op = lhsOp;  return lhsRet;}
 634     if (rhsRet && rhsOp == OpEquals) { op = rhsOp; return rhsRet;}
 635     if (NULL != lhs)
 636     {
 637          if( lhsRet) { op = lhsOp;  return lhsRet; }
 638          if( rhsRet) { op = rhsOp;  return rhsRet; }
 639     }
 640     char fieldName1[IDENTIFIER_LENGTH];
 641     Table::getFieldNameAlone(fldName1, fieldName1);
 642     //Means it is relational expression
 643     //first operand is always field identifier
 644     if(0 == strcmp(fieldName1, fname))
 645     {
 646         op = compOp;
 647         if (isUnique && compOp != OpLessThan &&
 648               compOp != OpLessThanEquals &&
 649               compOp != OpNotEquals ) isPushedDown = true;
 650         if (operand) return operand; else return *(void**)operandPtr;
 651     }
 652     op = OpInvalidComparisionOp;
 653     return NULL;
 654
 655 }
 656
 657 //called only in case of hash index scan
 658 void* PredicateImpl::valPtrForIndexField(const char *fname, bool isUnique)
 659 {
 660     void *lhsRet=NULL, *rhsRet=NULL;
 661     if (NULL != lhs)
 662     {
 663         lhsRet = lhs->valPtrForIndexField(fname, isUnique);
 664         if ( lhsRet !=  NULL) return lhsRet;
 665     }
 666     if (NULL != rhs)
 667     {
 668         rhsRet = rhs->valPtrForIndexField(fname, isUnique);
 669         if ( rhsRet !=  NULL) return rhsRet;
 670     }
 671     char fieldName1[IDENTIFIER_LENGTH];
 672     Table::getFieldNameAlone(fldName1, fieldName1);
 673     //Means it is relational expression
 674     //first operand is always field identifier
 675     if (OpEquals == compOp)
 676     {
 677         if(0 == strcmp(fieldName1, fname))
 678         {
 679             if (isUnique) isPushedDown = true;
 680             if (operand) return operand; else return *(void**)operandPtr;
 681         }
 682     }
 683     return NULL;
 684 }
 685
 686 ComparisionOp PredicateImpl::opForIndexField(const char *fname)
 687 {
 688     ComparisionOp lhsRet= OpInvalidComparisionOp, rhsRet= OpInvalidComparisionOp;
 689     if (NULL != lhs)
 690     {
 691         lhsRet = lhs->opForIndexField(fname);
 692         if ( lhsRet !=  OpInvalidComparisionOp) return lhsRet;
 693
 694     }
 695     if (NULL != rhs)
 696     {
 697         rhsRet = rhs->opForIndexField(fname);
 698         if ( rhsRet !=  OpInvalidComparisionOp) return rhsRet;
 699     }
 700     char fieldName1[IDENTIFIER_LENGTH];
 701     Table::getFieldNameAlone(fldName1, fieldName1);
 702     if(0 == strcmp(fieldName1, fname))
 703     {
 704         return compOp;
 705     }
 706     return OpInvalidComparisionOp;
 707 }
 708
 709 PredicateImpl* PredicateImpl::getTablePredicate()
 710 {
 711     PredicateImpl *lhsRet = NULL, *rhsRet = NULL;
 712     if (NULL != lhs)
 713     {
 714         lhsRet = lhs->getTablePredicate();
 715         if ( lhsRet !=  NULL) return lhsRet;
 716     }
 717     if (NULL != rhs)
 718     {
 719         rhsRet = rhs->getTablePredicate();
 720         if ( rhsRet !=  NULL) return rhsRet;
 721     }
 722     if (operand || operandPtr )
 723     {
 724         //printf("PRABA::getTablePredicate returning %s %d\n", fldName1, compOp);
 725         if (parent)
 726         {
 727            if (this == parent->lhs) {
 728                parent->lhs = NULL;
 729            }
 730            else {
 731               parent->rhs = NULL;
 732            }
 733            parent = NULL;
 734         }
 735         return this;
 736     }
 737     return NULL;
 738 }
 739
 740 PredicateImpl* PredicateImpl::getJoinPredicate()
 741 {
 742     PredicateImpl *lhsRet = NULL, *rhsRet = NULL;
 743     if (NULL != lhs)
 744     {
 745         lhsRet = lhs->getJoinPredicate();
 746         if ( lhsRet !=  NULL) return lhsRet;
 747     }
 748     if (NULL != rhs)
 749     {
 750         rhsRet = rhs->getJoinPredicate();
 751         if ( rhsRet !=  NULL) return rhsRet;
 752     }
 753     if (0 != strcmp(fldName2, ""))
 754     {
 755         //printf("PRABA::getJoinPredicate returning %s %s\n", fldName1, fldName2);
 756         if (parent)
 757         {
 758            if (this == parent->lhs)
 759                parent->lhs = NULL;
 760            else
 761                parent->rhs = NULL;
 762            parent = NULL;
 763         }
 764         return this;
 765     }
 766     return NULL;
 767 }
 768
 769 void PredicateImpl::removeIfNotNecessary()
 770 {
 771     if (NULL != lhs)
 772     {
 773         lhs->removeIfNotNecessary();
 774     }
 775     if (NULL != rhs)
 776     {
 777         rhs->removeIfNotNecessary();
 778     }
 779     if (logicalOp != OpAnd) return;
 780     if (NULL ==  lhs && NULL == rhs)
 781     {
 782         if (NULL == parent)
 783         {
 784             return;
 785         }
 786         if (this == parent->rhs) parent->rhs = NULL;
 787         else if (this == parent->lhs) parent->lhs = NULL;
 788         //TODO::PRABA::fix the leak below. if uncommented dumps core
 789         //delete this;
 790         //WARNINGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
 791         //current object is deleted. do not any code here
 792         return;
 793     }
 794     else if (NULL ==  lhs )
 795     {
 796         //left side of the node is empty means we can remove this AND node
 797         //and place it as left or right of my parent where i am currently placed
 798         if (NULL == parent)
 799         {
 800             return;
 801         }
 802         if (this == parent->rhs) parent->rhs=this->rhs;
 803         else if (this == parent->lhs) parent->lhs = this->rhs;
 804         //TODO::PRABA::fix the leak below. if uncommented dumps core
 805         //delete this;
 806         //WARNINGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
 807         //current object is deleted. do not any code here
 808         return;
 809     }
 810     else if (NULL ==  rhs )
 811     {
 812         //right side of the node is empty means we can remove this AND node
 813         //and place it as left or right of my parent where i am currently placed
 814         if (NULL == parent)
 815         {
 816             return;
 817         }
 818         if (this == parent->rhs) parent->rhs=this->lhs;
 819         else if (this == parent->lhs) parent->lhs = this->lhs;
 820         //TODO::PRABA::fix the leak below. if uncommented dumps core
 821         //delete this;
 822         //WARNINGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
 823         //current object is deleted. do not any code here
 824         return;
 825     }
 826     return;
 827 }
 828
 829 bool PredicateImpl::isDummyPredicate()
 830 {
 831     if (NULL == lhs && NULL == rhs && NULL == parent
 832                     && NULL == operand && NULL == operandPtr &&
 833                     (0 == strcmp(fldName1, "")) && (0==strcmp(fldName2, "")))
 834         return true;
 835     else
 836         return false;
 837 }
 838
 839 PredicateImpl* PredicateImpl::getIfOneSidedPredicate()
 840 {
 841     if (logicalOp != OpAnd) return NULL;
 842     if (NULL ==  lhs && NULL !=rhs)
 843     {
 844         return rhs;
 845     }
 846     if (NULL !=  lhs && NULL ==rhs)
 847     {
 848         return lhs;
 849     }
 850     return NULL;
 851 }