src/storage/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<fnmatch.h>
  25 #include<JoinTableImpl.h>
  26 #include<Util.h>
  27 void PredicateImpl::print()
  28 {
  29     printf("FieldName1 %s, FieldName2 %s", fldName1, fldName2);
  30     printf("CompOp %d, operand %x operandPtr%x", compOp, operand);
  31     printf("lhs %x, rhs %x", lhs, rhs);
  32
  33 }
  34
  35 void PredicateImpl::setTerm(const char* fName1, ComparisionOp op,
  36                         const char *fName2)
  37 {
  38     strcpy(fldName1, fName1);
  39     strcpy(fldName2, fName2);
  40     compOp = op;
  41     operand = NULL;
  42     operandPtr = NULL;
  43     lhs = rhs = NULL;
  44     logicalOp = OpInvalidLogicalOp;
  45 }
  46
  47 //Operand should be of the same type of the field.This is must
  48 void PredicateImpl::setTerm(const char* fName1, ComparisionOp op, void *opnd)
  49 {
  50     strcpy(fldName1, fName1);
  51     if (op == OpLike) {
  52             char *c = (char *) opnd;
  53                 while (*c != '\0') {
  54                     if (*c == '_') *c = '?';
  55                         else if(*c == '%') *c = '*';
  56                         c++;
  57                 }
  58         }
  59     compOp = op;
  60     operand = opnd;
  61     operandPtr = NULL;
  62     lhs = rhs = NULL;
  63     logicalOp = OpInvalidLogicalOp;
  64 }
  65
  66 void PredicateImpl::setTerm(const char* fName1, ComparisionOp op, void **opnd)
  67 {
  68     strcpy(fldName1, fName1);
  69     compOp = op;
  70     operand = NULL;
  71     operandPtr = opnd;
  72     lhs = rhs = NULL;
  73     logicalOp = OpInvalidLogicalOp;
  74 }
  75
  76
  77 void PredicateImpl::setTerm(Predicate *p1, LogicalOp op, Predicate *p2 )
  78 {
  79     if (p2 == NULL && op != OpNot || op == OpNot && p2 != NULL)
  80     {
  81         //TODO::printError
  82         return;
  83     }
  84     lhs = (PredicateImpl*)p1;
  85     rhs = (PredicateImpl*)p2;
  86     logicalOp = op;
  87     compOp = OpInvalidComparisionOp;
  88 }
  89
  90 void PredicateImpl::setTable(Table *tbl)
  91 {
  92     if (NULL != lhs)
  93         lhs->setTable((TableImpl*)tbl);
  94     if (NULL != rhs)
  95         rhs->setTable((TableImpl*)tbl);
  96    table = (TableImpl*)tbl;
  97 }
  98
  99 void PredicateImpl::setTuple(void *tpl)
 100 {
 101     if (NULL != lhs)
 102         lhs->setTuple(tpl);
 103     if (NULL != rhs)
 104          rhs->setTuple(tpl);
 105     tuple = tpl;
 106 }
 107 void PredicateImpl::setProjectionList(List *lst)
 108 {
 109     if (NULL != lhs)
 110         lhs->setProjectionList(lst);
 111     if (NULL != rhs)
 112          rhs->setProjectionList(lst);
 113     projList = lst;
 114 }
 115 bool PredicateImpl::isSingleTerm()
 116 {
 117     if (NULL == lhs  && NULL == rhs) return true; else false;
 118 }
 119
 120
 121 bool PredicateImpl::isNotOrInvolved()
 122 {
 123     bool lhsResult = true, rhsResult = true;
 124     if (NULL != lhs)
 125     {
 126         lhsResult = lhs->isNotOrInvolved();
 127     }
 128     if (NULL != rhs)
 129     {
 130         rhsResult = rhs->isNotOrInvolved();
 131     }
 132     if (NULL != lhs)
 133     {
 134         //Means it involves only Logical operator
 135             switch(logicalOp)
 136             {
 137                 case OpAnd:
 138                      if (lhsResult || rhsResult) return true;  else return false;
 139                      break;
 140                 case OpOr:
 141                      return true;
 142                      break;
 143                 case OpNot:
 144                 default:
 145                      return true;
 146                      break;
 147         }
 148     }
 149     return false;
 150 }
 151
 152 DbRetVal PredicateImpl::evaluate(bool &result)
 153 {
 154     bool rhsResult = false, lhsResult=false;
 155     printDebug(DM_Predicate, "Evaluate start logical:%d compOp:%d", logicalOp, compOp);
 156     DbRetVal retCode =OK;
 157     result = false;
 158     if (NULL != lhs)
 159     {
 160         retCode = lhs->evaluate(lhsResult);
 161         printDebug(DM_Predicate, "LHS result %d retcode: %d", lhsResult, retCode);
 162         if (retCode != OK) return ErrInvalidExpr;
 163     }
 164     if (NULL != rhs)
 165     {
 166         retCode = rhs->evaluate(rhsResult);
 167         printDebug(DM_Predicate, "RHS result %d retcode:%d", rhsResult, retCode);
 168         if (retCode != OK) return ErrInvalidExpr;
 169     }
 170     if (NULL != lhs)
 171     {
 172         //Means it involves only Logical operator
 173         printDebug(DM_Predicate,"Evalute operator %d lhsResult %d : rhsResult %d", logicalOp, lhsResult, rhsResult );
 174             switch(logicalOp)
 175             {
 176                 case OpAnd:
 177                     if (lhsResult && rhsResult) result = true;
 178                     break;
 179                 case OpOr:
 180                     if (lhsResult || rhsResult) result = true;
 181                     break;
 182                 case OpNot:
 183                     if (lhsResult)  result = false; else result = true;
 184                     break;
 185                 default:
 186                     return ErrInvalidExpr;
 187
 188             }
 189             printDebug(DM_Predicate, "result is %d", result);
 190             return OK;
 191     }
 192     printDebug(DM_Predicate, "Evaluating comparision predicate op:%d", compOp);
 193     //Means it is relational expression
 194     //first operand is always field identifier
 195     //get the value in the tuple
 196     char fieldName1[IDENTIFIER_LENGTH];
 197     char fieldName2[IDENTIFIER_LENGTH];
 198     memset(fieldName1, 0, IDENTIFIER_LENGTH);
 199     memset(fieldName2, 0, IDENTIFIER_LENGTH);
 200     Table::getFieldNameAlone(fldName1, fieldName1);
 201     Table::getFieldNameAlone(fldName2, fieldName2);
 202     if (projList)
 203     {
 204         DataType type=typeUnknown;
 205         int length=0;
 206         //for join node evaluation
 207         ListIterator fIter = projList->getIterator();
 208         JoinProjFieldInfo  *def;
 209         char *val1, *val2;
 210         while (fIter.hasElement())
 211         {
 212             def = (JoinProjFieldInfo*) fIter.nextElement();
 213             if (NULL != def->appBuf) {
 214                 if (0 == strcmp(fldName1, def->tabFieldName))
 215                 {
 216                     val1 = (char*)def->bindBuf;
 217                     type = def->type;
 218                     length = def->length;
 219                     break;
 220                 }
 221             }else{
 222                 printError(ErrNotExists, "Field not binded %s.%s\n",
 223                                       def->tableName, def->fieldName);
 224                 return ErrNotExists;
 225             }
 226         }
 227         if (operand == NULL && operandPtr == NULL)
 228         {
 229             if (fieldName2) {
 230                 fIter.reset();
 231                 while (fIter.hasElement())
 232                 {
 233                     def = (JoinProjFieldInfo*) fIter.nextElement();
 234                     if (NULL != def->appBuf) {
 235                         if (0 == strcmp(fldName2, def->tabFieldName))
 236                         {
 237                             val2 = (char*)def->bindBuf;
 238                             break;
 239                         }
 240                     }else{
 241                         printError(ErrNotExists, "Field not binded %s.%s\n",
 242                                             def->tableName, def->fieldName);
 243                         return ErrNotExists;
 244                     }
 245                 }
 246             }
 247         }
 248         else if(operand != NULL && operandPtr == NULL)
 249         {
 250             val2 = (char*) operand;
 251         }
 252         else if(operand == NULL && operandPtr != NULL)
 253         {
 254             val2 = *(char**)operandPtr;
 255         }
 256         if (compOp == OpLike) result = ! fnmatch(val2, val1, 0);
 257         else result = AllDataType::compareVal(val1, val2, compOp, type,
 258                               length);
 259         return OK;
 260     }
 261     //the below code works only for single table
 262     int offset1, offset2;
 263     offset1 = table->getFieldOffset(fieldName1);
 264     //TODO::do not call getFieldXXX many times, instead get it using getFieldInfo
 265     char *val1, *val2;
 266     //Assumes that fldName2 data type is also same for expr f1 <f2
 267     DataType srcType = table->getFieldType(fieldName1);
 268     val1 = ((char*) tuple) + offset1;
 269     if (operand == NULL && operandPtr == NULL)
 270     {
 271         if (fieldName2) {
 272             offset2 = table->getFieldOffset(fieldName2);
 273             val2 = ((char*)tuple) + offset2;
 274         }
 275     }
 276     else if(operand != NULL && operandPtr == NULL)
 277     {
 278         val2 = (char*) operand;
 279     }
 280     else if(operand == NULL && operandPtr != NULL)
 281     {
 282         val2 = *(char**)operandPtr;
 283     }
 284     int ret = 0;
 285     printDebug(DM_Predicate, " fldname :%s ", fieldName1);
 286     if (compOp == OpLike) result = ! fnmatch(val2, val1, 0);
 287     else result = AllDataType::compareVal(val1, val2, compOp, srcType,
 288                               table->getFieldLength(fieldName1));
 289     return OK;
 290 }
 291
 292 bool PredicateImpl::pointLookupInvolved(const char *fname)
 293 {
 294     bool rhsResult, lhsResult;
 295     if (NULL != lhs)
 296     {
 297         lhsResult = lhs->pointLookupInvolved(fname);
 298     }
 299     if (NULL != rhs)
 300     {
 301         rhsResult = rhs->pointLookupInvolved(fname);
 302     }
 303     if (NULL != lhs)
 304     {
 305         //Means it involves only Logical operator
 306             switch(logicalOp)
 307             {
 308                 case OpAnd:
 309                      //return lhsResult;
 310                      if (lhsResult || rhsResult) return true;  else return false;
 311                      break;
 312                 case OpOr:
 313                      return false;
 314                      break;
 315                 case OpNot:
 316                 default:
 317                      return false;
 318                      break;
 319         }
 320     }
 321     //Means it is relational expression
 322     //first operand is always field identifier
 323     char fieldName1[IDENTIFIER_LENGTH];
 324     Table::getFieldNameAlone(fldName1, fieldName1);
 325     if (OpEquals == compOp)
 326     {
 327         //for expressions f1 == f2 use full scan, so return false
 328         if(NULL == operand && NULL == operandPtr) return false;
 329         if(0 == strcmp(fieldName1, fname))
 330         {
 331             return true;
 332         }
 333     }
 334     return false;
 335 }
 336 bool PredicateImpl::rangeQueryInvolved(const char *fname)
 337 {
 338     bool rhsResult, lhsResult;
 339     if (NULL != lhs)
 340     {
 341         lhsResult = lhs->rangeQueryInvolved(fname);
 342     }
 343     if (NULL != rhs)
 344     {
 345         rhsResult = rhs->rangeQueryInvolved(fname);
 346     }
 347     if (NULL != lhs)
 348     {
 349             switch(logicalOp)
 350             {
 351                 case OpAnd:
 352                      if (lhsResult || rhsResult) return true;  else return false;
 353                      break;
 354                 case OpOr:
 355                      return false;
 356                      break;
 357                 case OpNot:
 358                 default:
 359                      return false;
 360                      break;
 361         }
 362     }
 363     //Means it is relational expression
 364     //first operand is always field identifier
 365     char fieldName1[IDENTIFIER_LENGTH];
 366     Table::getFieldNameAlone(fldName1, fieldName1);
 367     if (OpLessThan == compOp || OpLessThanEquals == compOp ||
 368         OpGreaterThan == compOp || OpGreaterThanEquals == compOp)
 369     {
 370          //for expressions f1 == f2 use full scan, so return false
 371         if(NULL == operand && NULL == operandPtr) return false;
 372         if(0 == strcmp(fieldName1, fname))
 373         {
 374             return true;
 375         }
 376     }
 377     return false;
 378 }
 379
 380
 381 void* PredicateImpl::valPtrForIndexField(const char *fname)
 382 {
 383     void *lhsRet, *rhsRet;
 384     if (NULL != lhs)
 385     {
 386         lhsRet = lhs->valPtrForIndexField(fname);
 387     }
 388     if (NULL != rhs)
 389     {
 390         rhsRet = rhs->valPtrForIndexField(fname);
 391     }
 392     if (NULL != lhs)
 393     {
 394         //Means it involves only Logical operator
 395         if ( lhsRet !=  NULL) return lhsRet;
 396         if ( rhsRet !=  NULL) return rhsRet;
 397     }
 398     char fieldName1[IDENTIFIER_LENGTH];
 399     Table::getFieldNameAlone(fldName1, fieldName1);
 400     //Means it is relational expression
 401     //first operand is always field identifier
 402     //if (OpEquals == compOp)
 403     {
 404         if(0 == strcmp(fieldName1, fname))
 405         {
 406             if (operand) return operand; else return *(void**)operandPtr;
 407         }
 408     }
 409     return NULL;
 410 }
 411 ComparisionOp PredicateImpl::opForIndexField(const char *fname)
 412 {
 413     ComparisionOp lhsRet, rhsRet;
 414     if (NULL != lhs)
 415     {
 416         lhsRet = lhs->opForIndexField(fname);
 417     }
 418     if (NULL != rhs)
 419     {
 420         rhsRet = rhs->opForIndexField(fname);
 421     }
 422     if (NULL != lhs)
 423     {
 424         if ( lhsRet !=  NULL) return lhsRet;
 425         if ( rhsRet !=  NULL) return rhsRet;
 426     }
 427     char fieldName1[IDENTIFIER_LENGTH];
 428     Table::getFieldNameAlone(fldName1, fieldName1);
 429     if(0 == strcmp(fieldName1, fname))
 430     {
 431         return compOp;
 432     }
 433     return OpInvalidComparisionOp;
 434 }
 435