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,bool &result)
  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,result);
  78         if (NULL == lhsResult) return lhsResult;
  79     }
  80     if (NULL != rhs)
  81     {
  82         rhsResult  = (char *)rhs->evaluate(type,result);
  83         if (NULL == rhsResult) return rhsResult;
  84     }
  85     if(result){return tuple;}
  86     int offset;
  87     char *val=NULL;
  88     if(NULL==lhs && NULL == rhs)
  89     {
  90         if(strcmp(fldName,"\0")!=0)
  91         {
  92             DataType srcType = table->getFieldType(fldName);
  93             if(srcType > 12) return NULL;
  94             else
  95             {
  96                 offset=table->getFieldOffset(fldName);
  97                 val= ((char*) tuple) + offset;
  98                 if(table->isFldNull(fldName))
  99                 {
 100                     result=true;
 101                     return tuple;
 102                 }
 103
 104             }
 105         }
 106         if(constVal!= NULL && strcmp(fldName,"\0")!=0)
 107         {
 108             os::memcpy(calVal,val,table->getFieldLength(fldName));
 109             solve(calVal, constVal, type, arOp);
 110         }
 111         else if(constVal!= NULL && 0==strcmp(fldName,"\0"))
 112         {
 113             AllDataType::copyVal(calVal, constVal, type, IDENTIFIER_LENGTH);
 114         }
 115         else if( NULL==constVal && strcmp(fldName,"\0")!=0)
 116         {
 117             os::memcpy(calVal,val,table->getFieldLength(fldName));
 118         }
 119         return calVal;
 120     }
 121     if(NULL!=lhsResult && NULL!=rhsResult)
 122     {
 123         solve(lhsResult, rhsResult, type, arOp);
 124         return lhsResult;
 125     }
 126
 127 }
 128
 129 void Expression::solve(void *opand1, void *opand2, DataType type, ArithOperator arOp)
 130 {
 131     switch(arOp)
 132     {
 133         case addition:
 134             AllDataType::addVal(opand1, opand2, type );
 135             break;
 136         case subtraction:
 137             AllDataType::subVal(opand1, opand2, type);
 138             break;
 139         case multiplication:
 140             AllDataType::mulVal(opand1, opand2, type);
 141             break;
 142         case division:
 143             AllDataType::divVal(opand1, opand2, type);
 144             break;
 145         case modulus:
 146             AllDataType::mudVal(opand1, opand2, type);
 147             break;
 148         default:
 149             break;
 150     }
 151     return;
 152 }
 153
 154 bool Expression::isSingleTerm()
 155 {
 156     if (NULL==lhs && NULL==rhs ) return true;
 157     else false;
 158 }
 159 void Expression::memFree()
 160 {
 161     if(lhs!=NULL)
 162         lhs->memFree();
 163     if(rhs!=NULL)
 164         rhs->memFree();
 165     free(calVal);
 166 }
 167
 168 void Expression::convertStrToVal(DataType type)
 169 {
 170     if(lhs!=NULL)
 171         lhs->convertStrToVal(type);
 172     if(rhs!=NULL)
 173         rhs->convertStrToVal(type);
 174     if(constVal !=NULL)
 175     {
 176         void *parseString=constVal;
 177         constVal=AllDataType::alloc(type);
 178         AllDataType::strToValue(constVal,(char*)parseString, type);
 179         free(parseString);
 180     }
 181
 182 }
 183 void Expression::freeVal()
 184 {
 185     if(lhs!=NULL)
 186         lhs->freeVal();
 187     if(rhs!=NULL)
 188         rhs->freeVal();
 189     if(constVal !=NULL)
 190         free(constVal);
 191 }