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
)
41 void Expression::setFunctionType(FunctionType type
)
44 lhs
->setFunctionType(type
);
46 rhs
->setFunctionType(type
);
50 void Expression::setExpr(Expression
* exp1
, FunctionType type
,Expression
* exp2
)
54 setFunctionType(type
);
58 void Expression::setExpr(void *cVal
,bool flag
)
65 void Expression::setExpr(char const *name
,ArithOperator op
,void *cVal
)
67 strcpy(fldName
, name
);
73 void Expression::setExpr(char const *name
)
75 strcpy(fldName
, name
);
81 void Expression::setExpr(Expression
*exp1
, ArithOperator op
, Expression
*exp2
)
88 void *Expression::evaluate(DataType type
,bool &result
)
90 calVal
=AllDataType::alloc(type
,IDENTIFIER_LENGTH
);
91 AllDataType::memoryset(calVal
,type
);
92 char *rhsResult
= NULL
, *lhsResult
= NULL
;
95 lhsResult
=(char *) lhs
->evaluate(type
,result
);
96 if (NULL
== lhsResult
) return lhsResult
;
100 rhsResult
= (char *)rhs
->evaluate(type
,result
);
101 if (NULL
== rhsResult
) return rhsResult
;
103 if(result
){return tuple
;}
104 if (0==strcmp(fldName
,"NULL")){
105 result
=true;return tuple
;
109 if(NULL
==lhs
&& NULL
== rhs
)
111 if(strcmp(fldName
,"\0")!=0)
113 DataType srcType
= table
->getFieldType(fldName
);
114 if(srcType
> 12) return NULL
;
117 offset
=table
->getFieldOffset(fldName
);
118 val
= ((char*) tuple
) + offset
;
119 if(table
->isFldNull(fldName
))
127 if(constVal
!= NULL
&& strcmp(fldName
,"\0")!=0)
129 AllDataType::convert(table
->getFieldType(fldName
), val
,
130 type
, calVal
, table
->getFieldLength(fldName
));
131 solve(calVal
, constVal
, type
, arOp
);
133 else if(constVal
!= NULL
&& 0==strcmp(fldName
,"\0"))
135 AllDataType::copyVal(calVal
, constVal
, type
, IDENTIFIER_LENGTH
);
137 else if( NULL
==constVal
&& strcmp(fldName
,"\0")!=0)
139 AllDataType::convert(table
->getFieldType(fldName
), val
,
140 type
, calVal
, table
->getFieldLength(fldName
));
144 if(NULL
!=lhsResult
&& NULL
!=rhsResult
)
146 solve(lhsResult
, rhsResult
, type
, arOp
);
153 void *Expression::evaluateForFunction(DataType type
)
155 void *rhsResult
= NULL
, *lhsResult
= NULL
;
158 lhsResult
=(char *) lhs
->evaluateForFunction(type
);
159 if (NULL
== lhsResult
) return lhsResult
;
163 rhsResult
= (char *)rhs
->evaluateForFunction(type
);
164 if (NULL
== rhsResult
) return rhsResult
;
168 if(NULL
==lhs
&& NULL
== rhs
)
170 if(strcmp(fldName
,"\0")!=0)
172 DataType srcType
= table
->getFieldType(fldName
);
173 offset
=table
->getFieldOffset(fldName
);
174 setDataType(srcType
);
175 val
= ((char*) tuple
) + offset
;
176 if(table
->isFldNull(fldName
))
180 calVal
=AllDataType::alloc(srcType
,IDENTIFIER_LENGTH
);
181 AllDataType::copyVal(calVal
,val
, srcType
,IDENTIFIER_LENGTH
);
186 calVal
=AllDataType::alloc(type
,IDENTIFIER_LENGTH
);
187 AllDataType::memoryset(calVal
,type
);
188 if(constVal
!= NULL
&& strcmp(fldName
,"\0")==0)
190 copyFunctionVal(calVal
, constVal
, fType
, IDENTIFIER_LENGTH
);
194 if(NULL
!=lhsResult
&& NULL
!=rhsResult
)
197 calVal
=AllDataType::alloc(type
,IDENTIFIER_LENGTH
);
198 AllDataType::memoryset(calVal
,type
);
200 return evaluateAndGetValPtr(lhsResult
,rhsResult
);
202 if(NULL
!=lhsResult
&& NULL
==rhsResult
)
205 calVal
=AllDataType::alloc(type
,IDENTIFIER_LENGTH
);
206 AllDataType::memoryset(calVal
,type
);
208 dType
= lhs
->getDataType();
209 if(dType
== typeTimeStamp
)
211 if(fType
== EXTRACTYEARFROMDAY
|| fType
== EXTRACTHOURFROMTIME
212 || fType
== EXTRACTMINFROMTIME
|| fType
==EXTRACTSECFROMTIME
213 || fType
== EXTRACTMONFROMDAY
|| fType
==EXTRACTDAYFROMDAY
)
215 fType
= (FunctionType
)((int)(fType
)+3);
218 return evaluateAndGetValPtr(lhsResult
,rhsResult
);
223 void *Expression::evaluateAndGetValPtr( void *lhsResult
, void *rhsResult
)
229 *(int *)calVal
= (*(Date
*)lhsResult
- *(Date
*)rhsResult
);
232 case DATEADDWITHYEAR
:
234 ((Date
*)lhsResult
)->addYear(*(int*)rhsResult
);
239 ((Date
*)lhsResult
)->addMonth(*(int*)rhsResult
);
244 ((Date
*)lhsResult
)->addDay(*(int*)rhsResult
);
247 case DATESUBWITHYEAR
:
249 ((Date
*)lhsResult
)->subYear(*(int*)rhsResult
);
254 ((Date
*)lhsResult
)->subMonth(*(int*)rhsResult
);
259 ((Date
*)lhsResult
)->subDay(*(int*)rhsResult
);
264 *(int *)calVal
= (*(Time
*)lhsResult
- *(Time
*)rhsResult
);
267 case TIMEADDWITHHOUR
:
269 ((Time
*)lhsResult
)->addHour(*(int*)rhsResult
);
274 ((Time
*)lhsResult
)->addMin(*(int*)rhsResult
);
279 ((Time
*)lhsResult
)->addSec(*(int*)rhsResult
);
282 case TIMESUBWITHHOUR
:
284 ((Time
*)lhsResult
)->subHour(*(int*)rhsResult
);
289 ((Time
*)lhsResult
)->subMin(*(int*)rhsResult
);
294 ((Time
*)lhsResult
)->subSec(*(int*)rhsResult
);
297 case TIMESTAMPADDWITHYEAR
:
299 ((TimeStamp
*)lhsResult
)->addYear(*(int*)rhsResult
);
302 case TIMESTAMPADDWITHMON
:
304 ((TimeStamp
*)lhsResult
)->addMonth(*(int*)rhsResult
);
307 case TIMESTAMPADDWITHDAY
:
309 ((TimeStamp
*)lhsResult
)->addDay(*(int*)rhsResult
);
312 case TIMESTAMPSUBWITHYEAR
:
314 ((TimeStamp
*)lhsResult
)->subYear(*(int*)rhsResult
);
317 case TIMESTAMPSUBWITHMON
:
319 ((TimeStamp
*)lhsResult
)->subMonth(*(int*)rhsResult
);
322 case TIMESTAMPSUBWITHDAY
:
324 ((TimeStamp
*)lhsResult
)->subDay(*(int*)rhsResult
);
327 case TIMESTAMPADDWITHHOUR
:
329 ((TimeStamp
*)lhsResult
)->addHour(*(int*)rhsResult
);
332 case TIMESTAMPADDWITHMIN
:
334 ((TimeStamp
*)lhsResult
)->addMin(*(int*)rhsResult
);
337 case TIMESTAMPADDWITHSEC
:
339 ((TimeStamp
*)lhsResult
)->addSec(*(int*)rhsResult
);
342 case TIMESTAMPSUBWITHHOUR
:
344 ((TimeStamp
*)lhsResult
)->subHour(*(int*)rhsResult
);
347 case TIMESTAMPSUBWITHMIN
:
349 ((TimeStamp
*)lhsResult
)->subMin(*(int*)rhsResult
);
352 case TIMESTAMPSUBWITHSEC
:
354 ((TimeStamp
*)lhsResult
)->subSec(*(int*)rhsResult
);
357 case TIMESTAMPDIFFYEAR
:
359 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->yearDiff((*(TimeStamp
*)rhsResult
));
362 case TIMESTAMPDIFFMON
:
364 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->monthDiff((*(TimeStamp
*)rhsResult
));
367 case TIMESTAMPDIFFDAY
:
369 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->dayDiff((*(TimeStamp
*)rhsResult
));
372 case TIMESTAMPDIFFHOUR
:
374 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->hourDiff((*(TimeStamp
*)rhsResult
));
377 case TIMESTAMPDIFFMIN
:
379 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->minDiff((*(TimeStamp
*)rhsResult
));
382 case TIMESTAMPDIFFSEC
:
384 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->secDiff((*(TimeStamp
*)rhsResult
));
387 case EXTRACTYEARFROMDAY
:
389 *(int *)calVal
= ((Date
*)lhsResult
)->year();
392 case EXTRACTMONFROMDAY
:
394 *(int *)calVal
= ((Date
*)lhsResult
)->month();
397 case EXTRACTDAYFROMDAY
:
399 *(int *)calVal
= ((Date
*)lhsResult
)->dayOfMonth();
402 case EXTRACTHOURFROMTIME
:
404 *(int *)calVal
= ((Time
*)lhsResult
)->hours();
407 case EXTRACTMINFROMTIME
:
409 *(int *)calVal
= ((Time
*)lhsResult
)->minutes();
412 case EXTRACTSECFROMTIME
:
414 *(int *)calVal
= ((Time
*)lhsResult
)->seconds();
417 case EXTRACTYEARFROMTIMESTAMP
:
419 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->year();
422 case EXTRACTMONFROMTIMESTAMP
:
424 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->month();
427 case EXTRACTDAYFROMTIMESTAMP
:
429 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->dayOfMonth();
432 case EXTRACTHOURFROMTIMESTAMP
:
434 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->hours();
437 case EXTRACTMINFROMTIMESTAMP
:
439 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->minutes();
442 case EXTRACTSECFROMTIMESTAMP
:
444 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->seconds();
447 case DATEFROMTIMESTAMP
:
449 ((TimeStamp
*)lhsResult
)->getDate(*(Date
*)calVal
);
452 case TIMEFROMTIMESTAMP
:
454 ((TimeStamp
*)lhsResult
)->getTime(*(Time
*)calVal
);
457 default: return NULL
;
462 void Expression::copyFunctionVal(void *dest
,void *src
, FunctionType type
, int length
)
469 //date.parseFrom((char*)src);
470 AllDataType::copyVal(dest
, src
, typeDate
,length
);
473 case DATEADDWITHYEAR
:
475 AllDataType::copyVal(dest
, src
,typeInt
,length
);
480 AllDataType::copyVal(dest
, src
,typeInt
,length
);
485 AllDataType::copyVal(dest
, src
,typeInt
,length
);
488 case DATESUBWITHYEAR
:
490 AllDataType::copyVal(dest
, src
,typeInt
,length
);
495 AllDataType::copyVal(dest
, src
,typeInt
,length
);
500 AllDataType::copyVal(dest
, src
,typeInt
,length
);
505 AllDataType::copyVal(dest
, src
, typeTime
,length
);
508 case TIMEADDWITHHOUR
:
511 case TIMESUBWITHHOUR
:
515 AllDataType::copyVal(dest
, src
,typeInt
,length
);
518 case TIMESTAMPADDWITHYEAR
:
519 case TIMESTAMPADDWITHMON
:
520 case TIMESTAMPADDWITHDAY
:
521 case TIMESTAMPSUBWITHYEAR
:
522 case TIMESTAMPSUBWITHMON
:
523 case TIMESTAMPSUBWITHDAY
:
524 case TIMESTAMPADDWITHHOUR
:
525 case TIMESTAMPADDWITHMIN
:
526 case TIMESTAMPADDWITHSEC
:
527 case TIMESTAMPSUBWITHHOUR
:
528 case TIMESTAMPSUBWITHMIN
:
529 case TIMESTAMPSUBWITHSEC
:
531 AllDataType::copyVal(dest
, src
,typeInt
,length
);
534 case TIMESTAMPDIFFYEAR
:
535 case TIMESTAMPDIFFMON
:
536 case TIMESTAMPDIFFDAY
:
537 case TIMESTAMPDIFFHOUR
:
538 case TIMESTAMPDIFFMIN
:
539 case TIMESTAMPDIFFSEC
:
541 AllDataType::copyVal(dest
, src
,typeTimeStamp
,length
);
544 case EXTRACTYEARFROMDAY
:
545 case EXTRACTMONFROMDAY
:
546 case EXTRACTDAYFROMDAY
:
548 AllDataType::copyVal(dest
, src
,typeDate
,length
);
551 case EXTRACTHOURFROMTIME
:
552 case EXTRACTMINFROMTIME
:
553 case EXTRACTSECFROMTIME
:
555 AllDataType::copyVal(dest
, src
,typeTime
,length
);
558 case EXTRACTYEARFROMTIMESTAMP
:
559 case EXTRACTMONFROMTIMESTAMP
:
560 case EXTRACTDAYFROMTIMESTAMP
:
561 case EXTRACTHOURFROMTIMESTAMP
:
562 case EXTRACTMINFROMTIMESTAMP
:
563 case EXTRACTSECFROMTIMESTAMP
:
565 AllDataType::copyVal(dest
, src
,typeTimeStamp
,length
);
569 case DATEFROMTIMESTAMP
:
570 case TIMEFROMTIMESTAMP
:
572 AllDataType::copyVal(dest
, src
,typeTimeStamp
,length
);
581 void Expression::solve(void *opand1
, void *opand2
, DataType type
, ArithOperator arOp
)
586 AllDataType::addVal(opand1
, opand2
, type
);
589 AllDataType::subVal(opand1
, opand2
, type
);
592 AllDataType::mulVal(opand1
, opand2
, type
);
595 AllDataType::divVal(opand1
, opand2
, type
);
598 AllDataType::mudVal(opand1
, opand2
, type
);
606 bool Expression::isSingleTerm()
608 if (NULL
==lhs
&& NULL
==rhs
) return true;
612 void Expression::memFree()
621 void Expression::convertStrToVal(DataType type
)
624 lhs
->convertStrToVal(type
);
626 rhs
->convertStrToVal(type
);
629 void *parseString
=constVal
;
630 constVal
=AllDataType::alloc(type
);
631 AllDataType::strToValue(constVal
,(char*)parseString
, type
);
637 void Expression::freeVal()