1 /***************************************************************************
2 * Copyright (C) 2007 by www.databasecache.com *
3 * Contact: praba_tuty@databasecache.com *
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. *
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. *
16 * ***************************************************************************/
17 #include<Expression.h>
21 void Expression::setTable(Table
*tbl
)
28 table
=(TableImpl
*) tbl
;
31 void Expression::setTuple(void *tpl
)
40 void Expression::setFunctionType(FunctionType type
)
43 lhs
->setFunctionType(type
);
45 rhs
->setFunctionType(type
);
48 void Expression::setExpr(Expression
* exp1
, FunctionType type
,Expression
* exp2
)
52 setFunctionType(type
);
55 void Expression::setExpr(void *cVal
,bool flag
)
62 void Expression::setExpr(char const *name
,ArithOperator op
,void *cVal
)
64 strcpy(fldName
, name
);
70 void Expression::setExpr(char const *name
)
72 strcpy(fldName
, name
);
78 void Expression::setExpr(Expression
*exp1
, ArithOperator op
, Expression
*exp2
)
85 void *Expression::evaluate(DataType type
,bool &result
)
87 calVal
=AllDataType::alloc(type
,IDENTIFIER_LENGTH
);
88 AllDataType::memoryset(calVal
,type
);
89 char *rhsResult
= NULL
, *lhsResult
= NULL
;
92 lhsResult
=(char *) lhs
->evaluate(type
,result
);
93 if (NULL
== lhsResult
) return lhsResult
;
97 rhsResult
= (char *)rhs
->evaluate(type
,result
);
98 if (NULL
== rhsResult
) return rhsResult
;
100 if(result
){return tuple
;}
101 if (0==strcmp(fldName
,"NULL")){
102 result
=true;return tuple
;
106 if(NULL
==lhs
&& NULL
== rhs
)
108 if(strcmp(fldName
,"\0")!=0)
110 DataType srcType
= table
->getFieldType(fldName
);
111 if(srcType
> 12) return NULL
;
114 offset
=table
->getFieldOffset(fldName
);
115 val
= ((char*) tuple
) + offset
;
116 if(table
->isFldNull(fldName
))
124 if(constVal
!= NULL
&& strcmp(fldName
,"\0")!=0)
126 os::memcpy(calVal
,val
,table
->getFieldLength(fldName
));
127 solve(calVal
, constVal
, type
, arOp
);
129 else if(constVal
!= NULL
&& 0==strcmp(fldName
,"\0"))
131 AllDataType::copyVal(calVal
, constVal
, type
, IDENTIFIER_LENGTH
);
133 else if( NULL
==constVal
&& strcmp(fldName
,"\0")!=0)
135 os::memcpy(calVal
,val
,table
->getFieldLength(fldName
));
139 if(NULL
!=lhsResult
&& NULL
!=rhsResult
)
141 solve(lhsResult
, rhsResult
, type
, arOp
);
147 void *Expression::evaluateForFunction(DataType type
)
149 void *rhsResult
= NULL
, *lhsResult
= NULL
;
152 lhsResult
=(char *) lhs
->evaluateForFunction(type
);
153 if (NULL
== lhsResult
) return lhsResult
;
157 rhsResult
= (char *)rhs
->evaluateForFunction(type
);
158 if (NULL
== rhsResult
) return rhsResult
;
162 if(NULL
==lhs
&& NULL
== rhs
)
164 if(strcmp(fldName
,"\0")!=0)
166 DataType srcType
= table
->getFieldType(fldName
);
167 offset
=table
->getFieldOffset(fldName
);
168 setDataType(srcType
);
169 val
= ((char*) tuple
) + offset
;
170 if(table
->isFldNull(fldName
))
174 calVal
=AllDataType::alloc(srcType
,IDENTIFIER_LENGTH
);
175 AllDataType::copyVal(calVal
,val
, srcType
,IDENTIFIER_LENGTH
);
180 calVal
=AllDataType::alloc(type
,IDENTIFIER_LENGTH
);
181 AllDataType::memoryset(calVal
,type
);
182 if(constVal
!= NULL
&& strcmp(fldName
,"\0")==0)
184 copyFunctionVal(calVal
, constVal
, fType
, IDENTIFIER_LENGTH
);
188 if(NULL
!=lhsResult
&& NULL
!=rhsResult
)
191 calVal
=AllDataType::alloc(type
,IDENTIFIER_LENGTH
);
192 AllDataType::memoryset(calVal
,type
);
194 return evaluateAndGetValPtr(lhsResult
,rhsResult
);
196 if(NULL
!=lhsResult
&& NULL
==rhsResult
)
199 calVal
=AllDataType::alloc(type
,IDENTIFIER_LENGTH
);
200 AllDataType::memoryset(calVal
,type
);
202 dType
= lhs
->getDataType();
203 if(dType
== typeTimeStamp
)
205 if(fType
== EXTRACTYEARFROMDAY
|| fType
== EXTRACTHOURFROMTIME
206 || fType
== EXTRACTMINFROMTIME
|| fType
==EXTRACTSECFROMTIME
207 || fType
== EXTRACTMONFROMDAY
|| fType
==EXTRACTDAYFROMDAY
)
209 fType
= (FunctionType
)((int)(fType
)+3);
212 return evaluateAndGetValPtr(lhsResult
,rhsResult
);
217 void *Expression::evaluateAndGetValPtr( void *lhsResult
, void *rhsResult
)
223 *(int *)calVal
= (*(Date
*)lhsResult
- *(Date
*)rhsResult
);
226 case DATEADDWITHYEAR
:
228 ((Date
*)lhsResult
)->addYear(*(int*)rhsResult
);
233 ((Date
*)lhsResult
)->addMonth(*(int*)rhsResult
);
238 ((Date
*)lhsResult
)->addDay(*(int*)rhsResult
);
241 case DATESUBWITHYEAR
:
243 ((Date
*)lhsResult
)->subYear(*(int*)rhsResult
);
248 ((Date
*)lhsResult
)->subMonth(*(int*)rhsResult
);
253 ((Date
*)lhsResult
)->subDay(*(int*)rhsResult
);
258 *(int *)calVal
= (*(Time
*)lhsResult
- *(Time
*)rhsResult
);
261 case TIMEADDWITHHOUR
:
263 ((Time
*)lhsResult
)->addHour(*(int*)rhsResult
);
268 ((Time
*)lhsResult
)->addMin(*(int*)rhsResult
);
273 ((Time
*)lhsResult
)->addSec(*(int*)rhsResult
);
276 case TIMESUBWITHHOUR
:
278 ((Time
*)lhsResult
)->subHour(*(int*)rhsResult
);
283 ((Time
*)lhsResult
)->subMin(*(int*)rhsResult
);
288 ((Time
*)lhsResult
)->subSec(*(int*)rhsResult
);
291 case TIMESTAMPADDWITHYEAR
:
293 ((TimeStamp
*)lhsResult
)->addYear(*(int*)rhsResult
);
296 case TIMESTAMPADDWITHMON
:
298 ((TimeStamp
*)lhsResult
)->addMonth(*(int*)rhsResult
);
301 case TIMESTAMPADDWITHDAY
:
303 ((TimeStamp
*)lhsResult
)->addDay(*(int*)rhsResult
);
306 case TIMESTAMPSUBWITHYEAR
:
308 ((TimeStamp
*)lhsResult
)->subYear(*(int*)rhsResult
);
311 case TIMESTAMPSUBWITHMON
:
313 ((TimeStamp
*)lhsResult
)->subMonth(*(int*)rhsResult
);
316 case TIMESTAMPSUBWITHDAY
:
318 ((TimeStamp
*)lhsResult
)->subDay(*(int*)rhsResult
);
321 case TIMESTAMPADDWITHHOUR
:
323 ((TimeStamp
*)lhsResult
)->addHour(*(int*)rhsResult
);
326 case TIMESTAMPADDWITHMIN
:
328 ((TimeStamp
*)lhsResult
)->addMin(*(int*)rhsResult
);
331 case TIMESTAMPADDWITHSEC
:
333 ((TimeStamp
*)lhsResult
)->addSec(*(int*)rhsResult
);
336 case TIMESTAMPSUBWITHHOUR
:
338 ((TimeStamp
*)lhsResult
)->subHour(*(int*)rhsResult
);
341 case TIMESTAMPSUBWITHMIN
:
343 ((TimeStamp
*)lhsResult
)->subMin(*(int*)rhsResult
);
346 case TIMESTAMPSUBWITHSEC
:
348 ((TimeStamp
*)lhsResult
)->subSec(*(int*)rhsResult
);
351 case TIMESTAMPDIFFYEAR
:
353 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->yearDiff((*(TimeStamp
*)rhsResult
));
356 case TIMESTAMPDIFFMON
:
358 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->monthDiff((*(TimeStamp
*)rhsResult
));
361 case TIMESTAMPDIFFDAY
:
363 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->dayDiff((*(TimeStamp
*)rhsResult
));
366 case TIMESTAMPDIFFHOUR
:
368 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->hourDiff((*(TimeStamp
*)rhsResult
));
371 case TIMESTAMPDIFFMIN
:
373 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->minDiff((*(TimeStamp
*)rhsResult
));
376 case TIMESTAMPDIFFSEC
:
378 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->secDiff((*(TimeStamp
*)rhsResult
));
381 case EXTRACTYEARFROMDAY
:
383 *(int *)calVal
= ((Date
*)lhsResult
)->year();
386 case EXTRACTMONFROMDAY
:
388 *(int *)calVal
= ((Date
*)lhsResult
)->month();
391 case EXTRACTDAYFROMDAY
:
393 *(int *)calVal
= ((Date
*)lhsResult
)->dayOfMonth();
396 case EXTRACTHOURFROMTIME
:
398 *(int *)calVal
= ((Time
*)lhsResult
)->hours();
401 case EXTRACTMINFROMTIME
:
403 *(int *)calVal
= ((Time
*)lhsResult
)->minutes();
406 case EXTRACTSECFROMTIME
:
408 *(int *)calVal
= ((Time
*)lhsResult
)->seconds();
411 case EXTRACTYEARFROMTIMESTAMP
:
413 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->year();
416 case EXTRACTMONFROMTIMESTAMP
:
418 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->month();
421 case EXTRACTDAYFROMTIMESTAMP
:
423 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->dayOfMonth();
426 case EXTRACTHOURFROMTIMESTAMP
:
428 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->hours();
431 case EXTRACTMINFROMTIMESTAMP
:
433 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->minutes();
436 case EXTRACTSECFROMTIMESTAMP
:
438 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->seconds();
441 case DATEFROMTIMESTAMP
:
443 ((TimeStamp
*)lhsResult
)->getDate(*(Date
*)calVal
);
446 case TIMEFROMTIMESTAMP
:
448 ((TimeStamp
*)lhsResult
)->getTime(*(Time
*)calVal
);
451 default: return NULL
;
456 void Expression::copyFunctionVal(void *dest
,void *src
, FunctionType type
, int length
)
463 //date.parseFrom((char*)src);
464 AllDataType::copyVal(dest
, src
, typeDate
,length
);
467 case DATEADDWITHYEAR
:
469 AllDataType::copyVal(dest
, src
,typeInt
,length
);
474 AllDataType::copyVal(dest
, src
,typeInt
,length
);
479 AllDataType::copyVal(dest
, src
,typeInt
,length
);
482 case DATESUBWITHYEAR
:
484 AllDataType::copyVal(dest
, src
,typeInt
,length
);
489 AllDataType::copyVal(dest
, src
,typeInt
,length
);
494 AllDataType::copyVal(dest
, src
,typeInt
,length
);
499 AllDataType::copyVal(dest
, src
, typeTime
,length
);
502 case TIMEADDWITHHOUR
:
505 case TIMESUBWITHHOUR
:
509 AllDataType::copyVal(dest
, src
,typeInt
,length
);
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
:
525 AllDataType::copyVal(dest
, src
,typeInt
,length
);
528 case TIMESTAMPDIFFYEAR
:
529 case TIMESTAMPDIFFMON
:
530 case TIMESTAMPDIFFDAY
:
531 case TIMESTAMPDIFFHOUR
:
532 case TIMESTAMPDIFFMIN
:
533 case TIMESTAMPDIFFSEC
:
535 AllDataType::copyVal(dest
, src
,typeTimeStamp
,length
);
538 case EXTRACTYEARFROMDAY
:
539 case EXTRACTMONFROMDAY
:
540 case EXTRACTDAYFROMDAY
:
542 AllDataType::copyVal(dest
, src
,typeDate
,length
);
545 case EXTRACTHOURFROMTIME
:
546 case EXTRACTMINFROMTIME
:
547 case EXTRACTSECFROMTIME
:
549 AllDataType::copyVal(dest
, src
,typeTime
,length
);
552 case EXTRACTYEARFROMTIMESTAMP
:
553 case EXTRACTMONFROMTIMESTAMP
:
554 case EXTRACTDAYFROMTIMESTAMP
:
555 case EXTRACTHOURFROMTIMESTAMP
:
556 case EXTRACTMINFROMTIMESTAMP
:
557 case EXTRACTSECFROMTIMESTAMP
:
559 AllDataType::copyVal(dest
, src
,typeTimeStamp
,length
);
563 case DATEFROMTIMESTAMP
:
564 case TIMEFROMTIMESTAMP
:
566 AllDataType::copyVal(dest
, src
,typeTimeStamp
,length
);
575 void Expression::solve(void *opand1
, void *opand2
, DataType type
, ArithOperator arOp
)
580 AllDataType::addVal(opand1
, opand2
, type
);
583 AllDataType::subVal(opand1
, opand2
, type
);
586 AllDataType::mulVal(opand1
, opand2
, type
);
589 AllDataType::divVal(opand1
, opand2
, type
);
592 AllDataType::mudVal(opand1
, opand2
, type
);
600 bool Expression::isSingleTerm()
602 if (NULL
==lhs
&& NULL
==rhs
) return true;
605 void Expression::memFree()
614 void Expression::convertStrToVal(DataType type
)
617 lhs
->convertStrToVal(type
);
619 rhs
->convertStrToVal(type
);
622 void *parseString
=constVal
;
623 constVal
=AllDataType::alloc(type
);
624 AllDataType::strToValue(constVal
,(char*)parseString
, type
);
629 void Expression::freeVal()