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
  41 void Expression::setExpr(void *cVal,bool flag)
  42 {
  43     arOp=unKnownOperator;
  44     constVal=cVal;
  45     lhs = rhs = NULL;
  46 }
  47
  48 void Expression::setExpr(char const *name,ArithOperator op,void *cVal)
  49 {
  50     strcpy(fldName, name);
  51     arOp = op;
  52     constVal = cVal;
  53     lhs = rhs = NULL;
  54 }
  55
  56 void Expression::setExpr(char const *name)
  57 {
  58     strcpy(fldName, name);
  59     arOp=unKnownOperator;
  60     constVal=NULL;
  61     lhs = rhs = NULL;
  62 }
  63
  64 void Expression::setExpr(Expression *exp1, ArithOperator op, Expression *exp2)
  65 {
  66         lhs = exp1;
  67         rhs = exp2;
  68         arOp = op;
  69 }
  70
  71 void *Expression::evaluate(DataType type)
  72 {
  73     calVal=AllDataType::alloc(type,IDENTIFIER_LENGTH);
  74     char *rhsResult = NULL , *lhsResult = NULL;
  75     if (NULL != lhs)
  76     {
  77         lhsResult =(char *) lhs->evaluate(type);
  78         if (NULL == lhsResult) return lhsResult;
  79     }
  80     if (NULL != rhs)
  81     {
  82         rhsResult  = (char *)rhs->evaluate(type);
  83         if (NULL == rhsResult) return rhsResult;
  84     }
  85     int offset;
  86     char *val=NULL;
  87     if(NULL==lhs && NULL == rhs)
  88     {
  89         if(strcmp(fldName,"\0")!=0)
  90         {
  91             DataType srcType = table->getFieldType(fldName);
  92             if(srcType > 12) return NULL;
  93             else
  94             {
  95                 offset=table->getFieldOffset(fldName);
  96                 val= ((char*) tuple) + offset;
  97             }
  98         }
  99         if(constVal!= NULL && strcmp(fldName,"\0")!=0)
 100         {
 101             os::memcpy(calVal,val,table->getFieldLength(fldName));
 102             solve(calVal, constVal, type, arOp);
 103         }
 104         else if(constVal!= NULL && 0==strcmp(fldName,"\0"))
 105         {
 106             AllDataType::copyVal(calVal, constVal, type, IDENTIFIER_LENGTH);
 107         }
 108         else if( NULL==constVal && strcmp(fldName,"\0")!=0)
 109         {
 110             os::memcpy(calVal,val,table->getFieldLength(fldName));
 111         }
 112         return calVal;
 113     }
 114     if(NULL!=lhsResult && NULL!=rhsResult)
 115     {
 116         solve(lhsResult, rhsResult, type, arOp);
 117         return lhsResult;
 118     }
 119
 120 }
 121
 122 void Expression::solve(void *opand1, void *opand2, DataType type, ArithOperator arOp)
 123 {
 124     switch(arOp)
 125     {
 126         case addition:
 127             AllDataType::addVal(opand1, opand2, type );
 128             break;
 129         case subtraction:
 130             AllDataType::subVal(opand1, opand2, type);
 131             break;
 132         case multiplication:
 133             AllDataType::mulVal(opand1, opand2, type);
 134             break;
 135         case division:
 136             AllDataType::divVal(opand1, opand2, type);
 137             break;
 138         case modulus:
 139             AllDataType::mudVal(opand1, opand2, type);
 140             break;
 141         default:
 142             break;
 143     }
 144     return;
 145 }
 146
 147 bool Expression::isSingleTerm()
 148 {
 149     if (NULL==lhs && NULL==rhs ) return true;
 150     else false;
 151 }
 152 void Expression::memFree()
 153 {
 154     if(lhs!=NULL)
 155         lhs->memFree();
 156     if(rhs!=NULL)
 157         rhs->memFree();
 158     free(calVal);
 159 }
 160
 161 void Expression::convertStrToVal(DataType type)
 162 {
 163     if(lhs!=NULL)
 164         lhs->convertStrToVal(type);
 165     if(rhs!=NULL)
 166         rhs->convertStrToVal(type);
 167     if(constVal !=NULL)
 168     {
 169         void *parseString=constVal;
 170         constVal=AllDataType::alloc(type);
 171         AllDataType::strToValue(constVal,(char*)parseString, type);
 172         free(parseString);
 173     }
 174
 175 }
 176 void Expression::freeVal()
 177 {
 178     if(lhs!=NULL)
 179         lhs->freeVal();
 180     if(rhs!=NULL)
 181         rhs->freeVal();
 182     if(constVal !=NULL)
 183         free(constVal);
 184 }