src/storage/Expression.cxx

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by www.databasecache.com                           *
   3  *   Contact: praba_tuty@databasecache.com                                 *
   4  *                                                                         *
   5  *                                                                         *
   6  *   This program is free software; you can redistribute it and/or modify  *
   7  *   it under the terms of the GNU General Public License as published by  *
   8  *   the Free Software Foundation; either version 2 of the License, or     *
   9  *   (at your option) any later version.                                   *
  10  *                                                                         *
  11  *   This program is distributed in the hope that it will be useful,       *
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  14  *   GNU General Public License for more details.                          *
  15  *                                                                         *
  16  * ***************************************************************************/
  17 #include<Expression.h>
  18 #include<Table.h>
  19 #include<TableImpl.h>
  20
  21 void Expression::setTable(Table *tbl )
  22 {
  23     if(NULL!=lhs)
  24         lhs->setTable(tbl);
  25     if(NULL!=rhs)
  26         rhs->setTable(tbl);
  27
  28     table=(TableImpl*) tbl;
  29 }
  30
  31 void Expression::setTuple(void *tpl)
  32 {
  33     if(NULL!=lhs)
  34         lhs->setTuple(tpl);
  35     if(NULL!=rhs)
  36         rhs->setTuple(tpl);
  37
  38     tuple = tpl;
  39 }
  40 void Expression::setFunctionType(FunctionType type)
  41 {
  42     if(NULL!=lhs)
  43         lhs->setFunctionType(type);
  44     if(NULL!=rhs)
  45         rhs->setFunctionType(type);
  46     fType = type;
  47 }
  48 void Expression::setExpr(Expression* exp1, FunctionType type,Expression* exp2)
  49 {
  50     lhs = exp1;
  51     rhs = exp2;
  52     setFunctionType(type);
  53     arOp=unKnownOperator;
  54 }
  55 void Expression::setExpr(void *cVal,bool flag)
  56 {
  57     arOp=unKnownOperator;
  58     constVal=cVal;
  59     lhs = rhs = NULL;
  60 }
  61
  62 void Expression::setExpr(char const *name,ArithOperator op,void *cVal)
  63 {
  64     strcpy(fldName, name);
  65     arOp = op;
  66     constVal = cVal;
  67     lhs = rhs = NULL;
  68 }
  69
  70 void Expression::setExpr(char const *name)
  71 {
  72     strcpy(fldName, name);
  73     arOp=unKnownOperator;
  74     constVal=NULL;
  75     lhs = rhs = NULL;
  76 }
  77
  78 void Expression::setExpr(Expression *exp1, ArithOperator op, Expression *exp2)
  79 {
  80         lhs = exp1;
  81         rhs = exp2;
  82         arOp = op;
  83 }
  84
  85 void *Expression::evaluate(DataType type,bool &result)
  86 {
  87     calVal=AllDataType::alloc(type,IDENTIFIER_LENGTH);
  88     AllDataType::memoryset(calVal,type);
  89     char *rhsResult = NULL , *lhsResult = NULL;
  90     if (NULL != lhs)
  91     {
  92         lhsResult =(char *) lhs->evaluate(type,result);
  93         if (NULL == lhsResult) return lhsResult;
  94     }
  95     if (NULL != rhs)
  96     {
  97         rhsResult  = (char *)rhs->evaluate(type,result);
  98         if (NULL == rhsResult) return rhsResult;
  99     }
 100     if(result){return tuple;}
 101     if (0==strcmp(fldName,"NULL")){
 102         result=true;return tuple;
 103     }
 104     int offset;
 105     char *val=NULL;
 106     if(NULL==lhs && NULL == rhs)
 107     {
 108         if(strcmp(fldName,"\0")!=0)
 109         {
 110             DataType srcType = table->getFieldType(fldName);
 111             if(srcType > 12) return NULL;
 112             else
 113             {
 114                 offset=table->getFieldOffset(fldName);
 115                 val= ((char*) tuple) + offset;
 116                 if(table->isFldNull(fldName))
 117                 {
 118                     result=true;
 119                     return tuple;
 120                 }
 121
 122             }
 123         }
 124         if(constVal!= NULL && strcmp(fldName,"\0")!=0)
 125         {
 126             os::memcpy(calVal,val,table->getFieldLength(fldName));
 127             solve(calVal, constVal, type, arOp);
 128         }
 129         else if(constVal!= NULL && 0==strcmp(fldName,"\0"))
 130         {
 131             AllDataType::copyVal(calVal, constVal, type, IDENTIFIER_LENGTH);
 132         }
 133         else if( NULL==constVal && strcmp(fldName,"\0")!=0)
 134         {
 135             os::memcpy(calVal,val,table->getFieldLength(fldName));
 136         }
 137         return calVal;
 138     }
 139     if(NULL!=lhsResult && NULL!=rhsResult)
 140     {
 141         solve(lhsResult, rhsResult, type, arOp);
 142         return lhsResult;
 143     }
 144
 145 }
 146
 147 void *Expression::evaluateForFunction(DataType type)
 148 {
 149     void *rhsResult = NULL , *lhsResult = NULL;
 150     if (NULL != lhs)
 151     {
 152         lhsResult =(char *) lhs->evaluateForFunction(type);
 153         if (NULL == lhsResult) return lhsResult;
 154     }
 155     if (NULL != rhs)
 156     {
 157         rhsResult  = (char *)rhs->evaluateForFunction(type);
 158         if (NULL == rhsResult) return rhsResult;
 159     }
 160     int offset;
 161     char *val=NULL;
 162     if(NULL==lhs && NULL == rhs)
 163     {
 164         if(strcmp(fldName,"\0")!=0)
 165         {
 166             DataType srcType = table->getFieldType(fldName);
 167             offset=table->getFieldOffset(fldName);
 168             setDataType(srcType);
 169             val= ((char*) tuple) + offset;
 170             if(table->isFldNull(fldName))
 171             {
 172                 return NULL;
 173             }else {
 174                calVal=AllDataType::alloc(srcType,IDENTIFIER_LENGTH);
 175                AllDataType::copyVal(calVal,val, srcType,IDENTIFIER_LENGTH);
 176                return calVal;
 177             }
 178
 179         }
 180         calVal=AllDataType::alloc(type,IDENTIFIER_LENGTH);
 181         AllDataType::memoryset(calVal,type);
 182         if(constVal!= NULL && strcmp(fldName,"\0")==0)
 183         {
 184             copyFunctionVal(calVal, constVal, fType, IDENTIFIER_LENGTH);
 185             return calVal;
 186         }
 187     }
 188     if(NULL!=lhsResult && NULL!=rhsResult)
 189     {
 190         if(calVal==NULL){
 191             calVal=AllDataType::alloc(type,IDENTIFIER_LENGTH);
 192             AllDataType::memoryset(calVal,type);
 193         }
 194         return evaluateAndGetValPtr(lhsResult,rhsResult);
 195     }
 196     if(NULL!=lhsResult && NULL==rhsResult)
 197     {
 198         if(calVal==NULL){
 199             calVal=AllDataType::alloc(type,IDENTIFIER_LENGTH);
 200             AllDataType::memoryset(calVal,type);
 201         }
 202         dType = lhs->getDataType();
 203         if(dType == typeTimeStamp)
 204         {
 205             if(fType == EXTRACTYEARFROMDAY || fType == EXTRACTHOURFROMTIME
 206                     || fType == EXTRACTMINFROMTIME || fType ==EXTRACTSECFROMTIME
 207                            || fType == EXTRACTMONFROMDAY || fType ==EXTRACTDAYFROMDAY)
 208              {
 209                  fType = (FunctionType)((int)(fType)+3);
 210              }
 211         }
 212         return evaluateAndGetValPtr(lhsResult,rhsResult);
 213     }
 214     return NULL;
 215 }
 216
 217 void *Expression::evaluateAndGetValPtr( void *lhsResult, void *rhsResult)
 218 {
 219     switch(fType)
 220     {
 221         case DATEDIFF:
 222         {
 223             *(int *)calVal = (*(Date*)lhsResult - *(Date*)rhsResult);
 224             return calVal;
 225         }
 226         case DATEADDWITHYEAR:
 227         {
 228            ((Date*)lhsResult)->addYear(*(int*)rhsResult);
 229            return lhsResult;
 230         }
 231         case DATEADDWITHMON:
 232         {
 233            ((Date*)lhsResult)->addMonth(*(int*)rhsResult);
 234            return lhsResult;
 235         }
 236         case DATEADDWITHDAY:
 237         {
 238            ((Date*)lhsResult)->addDay(*(int*)rhsResult);
 239            return lhsResult;
 240         }
 241         case DATESUBWITHYEAR:
 242         {
 243            ((Date*)lhsResult)->subYear(*(int*)rhsResult);
 244            return lhsResult;
 245         }
 246         case DATESUBWITHMON:
 247         {
 248            ((Date*)lhsResult)->subMonth(*(int*)rhsResult);
 249            return lhsResult;
 250         }
 251         case DATESUBWITHDAY:
 252         {
 253            ((Date*)lhsResult)->subDay(*(int*)rhsResult);
 254            return lhsResult;
 255         }
 256         case TIMEDIFF:
 257         {
 258            *(int *)calVal = (*(Time*)lhsResult - *(Time*)rhsResult);
 259             return calVal;
 260         }
 261         case TIMEADDWITHHOUR:
 262         {
 263            ((Time*)lhsResult)->addHour(*(int*)rhsResult);
 264            return lhsResult;
 265         }
 266         case TIMEADDWITHMIN:
 267         {
 268            ((Time*)lhsResult)->addMin(*(int*)rhsResult);
 269            return lhsResult;
 270         }
 271         case TIMEADDWITHSEC:
 272         {
 273            ((Time*)lhsResult)->addSec(*(int*)rhsResult);
 274            return lhsResult;
 275         }
 276         case TIMESUBWITHHOUR:
 277         {
 278            ((Time*)lhsResult)->subHour(*(int*)rhsResult);
 279            return lhsResult;
 280         }
 281         case TIMESUBWITHMIN:
 282         {
 283            ((Time*)lhsResult)->subMin(*(int*)rhsResult);
 284            return lhsResult;
 285         }
 286         case TIMESUBWITHSEC:
 287         {
 288            ((Time*)lhsResult)->subSec(*(int*)rhsResult);
 289            return lhsResult;
 290         }
 291         case TIMESTAMPADDWITHYEAR:
 292         {
 293            ((TimeStamp*)lhsResult)->addYear(*(int*)rhsResult);
 294            return lhsResult;
 295         }
 296         case TIMESTAMPADDWITHMON:
 297         {
 298            ((TimeStamp*)lhsResult)->addMonth(*(int*)rhsResult);
 299            return lhsResult;
 300         }
 301         case TIMESTAMPADDWITHDAY:
 302         {
 303            ((TimeStamp*)lhsResult)->addDay(*(int*)rhsResult);
 304            return lhsResult;
 305         }
 306         case TIMESTAMPSUBWITHYEAR:
 307         {
 308            ((TimeStamp*)lhsResult)->subYear(*(int*)rhsResult);
 309            return lhsResult;
 310         }
 311         case TIMESTAMPSUBWITHMON:
 312         {
 313            ((TimeStamp*)lhsResult)->subMonth(*(int*)rhsResult);
 314            return lhsResult;
 315         }
 316         case TIMESTAMPSUBWITHDAY:
 317         {
 318            ((TimeStamp*)lhsResult)->subDay(*(int*)rhsResult);
 319            return lhsResult;
 320         }
 321         case TIMESTAMPADDWITHHOUR:
 322         {
 323            ((TimeStamp*)lhsResult)->addHour(*(int*)rhsResult);
 324            return lhsResult;
 325         }
 326         case TIMESTAMPADDWITHMIN:
 327         {
 328            ((TimeStamp*)lhsResult)->addMin(*(int*)rhsResult);
 329            return lhsResult;
 330         }
 331         case TIMESTAMPADDWITHSEC:
 332         {
 333            ((TimeStamp*)lhsResult)->addSec(*(int*)rhsResult);
 334            return lhsResult;
 335         }
 336         case TIMESTAMPSUBWITHHOUR:
 337         {
 338            ((TimeStamp*)lhsResult)->subHour(*(int*)rhsResult);
 339            return lhsResult;
 340         }
 341         case TIMESTAMPSUBWITHMIN:
 342         {
 343            ((TimeStamp*)lhsResult)->subMin(*(int*)rhsResult);
 344            return lhsResult;
 345         }
 346         case TIMESTAMPSUBWITHSEC:
 347         {
 348            ((TimeStamp*)lhsResult)->subSec(*(int*)rhsResult);
 349            return lhsResult;
 350         }
 351         case TIMESTAMPDIFFYEAR:
 352         {
 353            *(int *)calVal = ((TimeStamp*)lhsResult)->yearDiff((*(TimeStamp*)rhsResult));
 354             return calVal;
 355         }
 356         case TIMESTAMPDIFFMON:
 357         {
 358            *(int *)calVal = ((TimeStamp*)lhsResult)->monthDiff((*(TimeStamp*)rhsResult));
 359             return calVal;
 360         }
 361         case TIMESTAMPDIFFDAY:
 362         {
 363            *(int *)calVal = ((TimeStamp*)lhsResult)->dayDiff((*(TimeStamp*)rhsResult));
 364             return calVal;
 365         }
 366         case TIMESTAMPDIFFHOUR:
 367         {
 368            *(int *)calVal = ((TimeStamp*)lhsResult)->hourDiff((*(TimeStamp*)rhsResult));
 369             return calVal;
 370         }
 371         case TIMESTAMPDIFFMIN:
 372         {
 373            *(int *)calVal = ((TimeStamp*)lhsResult)->minDiff((*(TimeStamp*)rhsResult));
 374             return calVal;
 375         }
 376         case TIMESTAMPDIFFSEC:
 377         {
 378            *(int *)calVal = ((TimeStamp*)lhsResult)->secDiff((*(TimeStamp*)rhsResult));
 379             return calVal;
 380         }
 381         case EXTRACTYEARFROMDAY:
 382         {
 383            *(int *)calVal = ((Date*)lhsResult)->year();
 384             return calVal;
 385         }
 386         case EXTRACTMONFROMDAY:
 387         {
 388            *(int *)calVal = ((Date*)lhsResult)->month();
 389             return calVal;
 390         }
 391         case EXTRACTDAYFROMDAY:
 392         {
 393             *(int *)calVal = ((Date*)lhsResult)->dayOfMonth();
 394             return calVal;
 395         }
 396         case EXTRACTHOURFROMTIME:
 397         {
 398             *(int *)calVal = ((Time*)lhsResult)->hours();
 399             return calVal;
 400         }
 401         case EXTRACTMINFROMTIME:
 402         {
 403             *(int *)calVal = ((Time*)lhsResult)->minutes();
 404             return calVal;
 405         }
 406         case EXTRACTSECFROMTIME:
 407         {
 408             *(int *)calVal = ((Time*)lhsResult)->seconds();
 409             return calVal;
 410         }
 411         case EXTRACTYEARFROMTIMESTAMP:
 412         {
 413             *(int *)calVal = ((TimeStamp*)lhsResult)->year();
 414             return calVal;
 415         }
 416         case EXTRACTMONFROMTIMESTAMP:
 417         {
 418             *(int *)calVal = ((TimeStamp*)lhsResult)->month();
 419             return calVal;
 420         }
 421         case EXTRACTDAYFROMTIMESTAMP:
 422         {
 423             *(int *)calVal = ((TimeStamp*)lhsResult)->dayOfMonth();
 424             return calVal;
 425         }
 426         case EXTRACTHOURFROMTIMESTAMP:
 427         {
 428             *(int *)calVal = ((TimeStamp*)lhsResult)->hours();
 429             return calVal;
 430         }
 431         case EXTRACTMINFROMTIMESTAMP:
 432         {
 433             *(int *)calVal = ((TimeStamp*)lhsResult)->minutes();
 434             return calVal;
 435         }
 436         case EXTRACTSECFROMTIMESTAMP:
 437         {
 438             *(int *)calVal = ((TimeStamp*)lhsResult)->seconds();
 439             return calVal;
 440         }
 441         case DATEFROMTIMESTAMP:
 442         {
 443             ((TimeStamp*)lhsResult)->getDate(*(Date *)calVal);
 444             return calVal;
 445         }
 446         case TIMEFROMTIMESTAMP:
 447         {
 448             ((TimeStamp*)lhsResult)->getTime(*(Time *)calVal);
 449             return calVal;
 450         }
 451         default: return NULL;
 452     }
 453
 454 }
 455
 456 void Expression::copyFunctionVal(void *dest,void *src, FunctionType type, int length)
 457 {
 458      switch(type)
 459     {
 460         case DATEDIFF:
 461         {
 462             //Date date;
 463             //date.parseFrom((char*)src);
 464             AllDataType::copyVal(dest, src, typeDate,length);
 465             return;
 466         }
 467         case DATEADDWITHYEAR:
 468         {
 469             AllDataType::copyVal(dest, src,typeInt,length);
 470             return;
 471         }
 472         case DATEADDWITHMON:
 473         {
 474             AllDataType::copyVal(dest, src,typeInt,length);
 475             return;
 476         }
 477         case DATEADDWITHDAY:
 478         {
 479             AllDataType::copyVal(dest, src,typeInt,length);
 480             return;
 481         }
 482         case DATESUBWITHYEAR:
 483         {
 484             AllDataType::copyVal(dest, src,typeInt,length);
 485             return;
 486         }
 487         case DATESUBWITHMON:
 488         {
 489             AllDataType::copyVal(dest, src,typeInt,length);
 490             return;
 491         }
 492         case DATESUBWITHDAY:
 493         {
 494             AllDataType::copyVal(dest, src,typeInt,length);
 495             return;
 496         }
 497         case TIMEDIFF:
 498         {
 499             AllDataType::copyVal(dest, src, typeTime,length);
 500             return;
 501         }
 502         case TIMEADDWITHHOUR:
 503         case TIMEADDWITHMIN:
 504         case TIMEADDWITHSEC:
 505         case TIMESUBWITHHOUR:
 506         case TIMESUBWITHMIN:
 507         case TIMESUBWITHSEC:
 508         {
 509             AllDataType::copyVal(dest, src,typeInt,length);
 510             return;
 511         }
 512         case TIMESTAMPADDWITHYEAR:
 513         case TIMESTAMPADDWITHMON:
 514         case TIMESTAMPADDWITHDAY:
 515         case TIMESTAMPSUBWITHYEAR:
 516         case TIMESTAMPSUBWITHMON:
 517         case TIMESTAMPSUBWITHDAY:
 518         case TIMESTAMPADDWITHHOUR:
 519         case TIMESTAMPADDWITHMIN:
 520         case TIMESTAMPADDWITHSEC:
 521         case TIMESTAMPSUBWITHHOUR:
 522         case TIMESTAMPSUBWITHMIN:
 523         case TIMESTAMPSUBWITHSEC:
 524         {
 525             AllDataType::copyVal(dest, src,typeInt,length);
 526             return;
 527         }
 528         case TIMESTAMPDIFFYEAR:
 529         case TIMESTAMPDIFFMON:
 530         case TIMESTAMPDIFFDAY:
 531         case TIMESTAMPDIFFHOUR:
 532         case TIMESTAMPDIFFMIN:
 533         case TIMESTAMPDIFFSEC:
 534         {
 535             AllDataType::copyVal(dest, src,typeTimeStamp,length);
 536             return;
 537         }
 538         case EXTRACTYEARFROMDAY:
 539         case EXTRACTMONFROMDAY:
 540         case EXTRACTDAYFROMDAY:
 541         {
 542             AllDataType::copyVal(dest, src,typeDate,length);
 543             return;
 544         }
 545         case EXTRACTHOURFROMTIME:
 546         case EXTRACTMINFROMTIME:
 547         case EXTRACTSECFROMTIME:
 548         {
 549             AllDataType::copyVal(dest, src,typeTime,length);
 550             return;
 551         }
 552         case EXTRACTYEARFROMTIMESTAMP:
 553         case EXTRACTMONFROMTIMESTAMP:
 554         case EXTRACTDAYFROMTIMESTAMP:
 555         case EXTRACTHOURFROMTIMESTAMP:
 556         case EXTRACTMINFROMTIMESTAMP:
 557         case EXTRACTSECFROMTIMESTAMP:
 558         {
 559             AllDataType::copyVal(dest, src,typeTimeStamp,length);
 560             return;
 561
 562         }
 563         case DATEFROMTIMESTAMP:
 564         case TIMEFROMTIMESTAMP:
 565         {
 566             AllDataType::copyVal(dest, src,typeTimeStamp,length);
 567             return;
 568
 569         }
 570         default: return;
 571     }
 572
 573 }
 574
 575 void Expression::solve(void *opand1, void *opand2, DataType type, ArithOperator arOp)
 576 {
 577     switch(arOp)
 578     {
 579         case addition:
 580             AllDataType::addVal(opand1, opand2, type );
 581             break;
 582         case subtraction:
 583             AllDataType::subVal(opand1, opand2, type);
 584             break;
 585         case multiplication:
 586             AllDataType::mulVal(opand1, opand2, type);
 587             break;
 588         case division:
 589             AllDataType::divVal(opand1, opand2, type);
 590             break;
 591         case modulus:
 592             AllDataType::mudVal(opand1, opand2, type);
 593             break;
 594         default:
 595             break;
 596     }
 597     return;
 598 }
 599
 600 bool Expression::isSingleTerm()
 601 {
 602     if (NULL==lhs && NULL==rhs ) return true;
 603     else false;
 604 }
 605 void Expression::memFree()
 606 {
 607     if(lhs!=NULL)
 608         lhs->memFree();
 609     if(rhs!=NULL)
 610         rhs->memFree();
 611     free(calVal);
 612 }
 613
 614 void Expression::convertStrToVal(DataType type)
 615 {
 616     if(lhs!=NULL)
 617         lhs->convertStrToVal(type);
 618     if(rhs!=NULL)
 619         rhs->convertStrToVal(type);
 620     if(constVal !=NULL)
 621     {
 622         void *parseString=constVal;
 623         constVal=AllDataType::alloc(type);
 624         AllDataType::strToValue(constVal,(char*)parseString, type);
 625         free(parseString);
 626     }
 627
 628 }
 629 void Expression::freeVal()
 630 {
 631     if(lhs!=NULL)
 632         lhs->freeVal();
 633     if(rhs!=NULL)
 634         rhs->freeVal();
 635     if(constVal !=NULL)
 636         free(constVal);
 637 }