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 AllDataType::convert(table
->getFieldType(fldName
), val
,
127 type
, calVal
, table
->getFieldLength(fldName
));
128 solve(calVal
, constVal
, type
, arOp
);
130 else if(constVal
!= NULL
&& 0==strcmp(fldName
,"\0"))
132 AllDataType::copyVal(calVal
, constVal
, type
, IDENTIFIER_LENGTH
);
134 else if( NULL
==constVal
&& strcmp(fldName
,"\0")!=0)
136 AllDataType::convert(table
->getFieldType(fldName
), val
,
137 type
, calVal
, table
->getFieldLength(fldName
));
141 if(NULL
!=lhsResult
&& NULL
!=rhsResult
)
143 solve(lhsResult
, rhsResult
, type
, arOp
);
149 void *Expression::evaluateForFunction(DataType type
)
151 void *rhsResult
= NULL
, *lhsResult
= NULL
;
154 lhsResult
=(char *) lhs
->evaluateForFunction(type
);
155 if (NULL
== lhsResult
) return lhsResult
;
159 rhsResult
= (char *)rhs
->evaluateForFunction(type
);
160 if (NULL
== rhsResult
) return rhsResult
;
164 if(NULL
==lhs
&& NULL
== rhs
)
166 if(strcmp(fldName
,"\0")!=0)
168 DataType srcType
= table
->getFieldType(fldName
);
169 offset
=table
->getFieldOffset(fldName
);
170 setDataType(srcType
);
171 val
= ((char*) tuple
) + offset
;
172 if(table
->isFldNull(fldName
))
176 calVal
=AllDataType::alloc(srcType
,IDENTIFIER_LENGTH
);
177 AllDataType::copyVal(calVal
,val
, srcType
,IDENTIFIER_LENGTH
);
182 calVal
=AllDataType::alloc(type
,IDENTIFIER_LENGTH
);
183 AllDataType::memoryset(calVal
,type
);
184 if(constVal
!= NULL
&& strcmp(fldName
,"\0")==0)
186 copyFunctionVal(calVal
, constVal
, fType
, IDENTIFIER_LENGTH
);
190 if(NULL
!=lhsResult
&& NULL
!=rhsResult
)
193 calVal
=AllDataType::alloc(type
,IDENTIFIER_LENGTH
);
194 AllDataType::memoryset(calVal
,type
);
196 return evaluateAndGetValPtr(lhsResult
,rhsResult
);
198 if(NULL
!=lhsResult
&& NULL
==rhsResult
)
201 calVal
=AllDataType::alloc(type
,IDENTIFIER_LENGTH
);
202 AllDataType::memoryset(calVal
,type
);
204 dType
= lhs
->getDataType();
205 if(dType
== typeTimeStamp
)
207 if(fType
== EXTRACTYEARFROMDAY
|| fType
== EXTRACTHOURFROMTIME
208 || fType
== EXTRACTMINFROMTIME
|| fType
==EXTRACTSECFROMTIME
209 || fType
== EXTRACTMONFROMDAY
|| fType
==EXTRACTDAYFROMDAY
)
211 fType
= (FunctionType
)((int)(fType
)+3);
214 return evaluateAndGetValPtr(lhsResult
,rhsResult
);
219 void *Expression::evaluateAndGetValPtr( void *lhsResult
, void *rhsResult
)
225 *(int *)calVal
= (*(Date
*)lhsResult
- *(Date
*)rhsResult
);
228 case DATEADDWITHYEAR
:
230 ((Date
*)lhsResult
)->addYear(*(int*)rhsResult
);
235 ((Date
*)lhsResult
)->addMonth(*(int*)rhsResult
);
240 ((Date
*)lhsResult
)->addDay(*(int*)rhsResult
);
243 case DATESUBWITHYEAR
:
245 ((Date
*)lhsResult
)->subYear(*(int*)rhsResult
);
250 ((Date
*)lhsResult
)->subMonth(*(int*)rhsResult
);
255 ((Date
*)lhsResult
)->subDay(*(int*)rhsResult
);
260 *(int *)calVal
= (*(Time
*)lhsResult
- *(Time
*)rhsResult
);
263 case TIMEADDWITHHOUR
:
265 ((Time
*)lhsResult
)->addHour(*(int*)rhsResult
);
270 ((Time
*)lhsResult
)->addMin(*(int*)rhsResult
);
275 ((Time
*)lhsResult
)->addSec(*(int*)rhsResult
);
278 case TIMESUBWITHHOUR
:
280 ((Time
*)lhsResult
)->subHour(*(int*)rhsResult
);
285 ((Time
*)lhsResult
)->subMin(*(int*)rhsResult
);
290 ((Time
*)lhsResult
)->subSec(*(int*)rhsResult
);
293 case TIMESTAMPADDWITHYEAR
:
295 ((TimeStamp
*)lhsResult
)->addYear(*(int*)rhsResult
);
298 case TIMESTAMPADDWITHMON
:
300 ((TimeStamp
*)lhsResult
)->addMonth(*(int*)rhsResult
);
303 case TIMESTAMPADDWITHDAY
:
305 ((TimeStamp
*)lhsResult
)->addDay(*(int*)rhsResult
);
308 case TIMESTAMPSUBWITHYEAR
:
310 ((TimeStamp
*)lhsResult
)->subYear(*(int*)rhsResult
);
313 case TIMESTAMPSUBWITHMON
:
315 ((TimeStamp
*)lhsResult
)->subMonth(*(int*)rhsResult
);
318 case TIMESTAMPSUBWITHDAY
:
320 ((TimeStamp
*)lhsResult
)->subDay(*(int*)rhsResult
);
323 case TIMESTAMPADDWITHHOUR
:
325 ((TimeStamp
*)lhsResult
)->addHour(*(int*)rhsResult
);
328 case TIMESTAMPADDWITHMIN
:
330 ((TimeStamp
*)lhsResult
)->addMin(*(int*)rhsResult
);
333 case TIMESTAMPADDWITHSEC
:
335 ((TimeStamp
*)lhsResult
)->addSec(*(int*)rhsResult
);
338 case TIMESTAMPSUBWITHHOUR
:
340 ((TimeStamp
*)lhsResult
)->subHour(*(int*)rhsResult
);
343 case TIMESTAMPSUBWITHMIN
:
345 ((TimeStamp
*)lhsResult
)->subMin(*(int*)rhsResult
);
348 case TIMESTAMPSUBWITHSEC
:
350 ((TimeStamp
*)lhsResult
)->subSec(*(int*)rhsResult
);
353 case TIMESTAMPDIFFYEAR
:
355 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->yearDiff((*(TimeStamp
*)rhsResult
));
358 case TIMESTAMPDIFFMON
:
360 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->monthDiff((*(TimeStamp
*)rhsResult
));
363 case TIMESTAMPDIFFDAY
:
365 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->dayDiff((*(TimeStamp
*)rhsResult
));
368 case TIMESTAMPDIFFHOUR
:
370 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->hourDiff((*(TimeStamp
*)rhsResult
));
373 case TIMESTAMPDIFFMIN
:
375 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->minDiff((*(TimeStamp
*)rhsResult
));
378 case TIMESTAMPDIFFSEC
:
380 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->secDiff((*(TimeStamp
*)rhsResult
));
383 case EXTRACTYEARFROMDAY
:
385 *(int *)calVal
= ((Date
*)lhsResult
)->year();
388 case EXTRACTMONFROMDAY
:
390 *(int *)calVal
= ((Date
*)lhsResult
)->month();
393 case EXTRACTDAYFROMDAY
:
395 *(int *)calVal
= ((Date
*)lhsResult
)->dayOfMonth();
398 case EXTRACTHOURFROMTIME
:
400 *(int *)calVal
= ((Time
*)lhsResult
)->hours();
403 case EXTRACTMINFROMTIME
:
405 *(int *)calVal
= ((Time
*)lhsResult
)->minutes();
408 case EXTRACTSECFROMTIME
:
410 *(int *)calVal
= ((Time
*)lhsResult
)->seconds();
413 case EXTRACTYEARFROMTIMESTAMP
:
415 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->year();
418 case EXTRACTMONFROMTIMESTAMP
:
420 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->month();
423 case EXTRACTDAYFROMTIMESTAMP
:
425 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->dayOfMonth();
428 case EXTRACTHOURFROMTIMESTAMP
:
430 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->hours();
433 case EXTRACTMINFROMTIMESTAMP
:
435 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->minutes();
438 case EXTRACTSECFROMTIMESTAMP
:
440 *(int *)calVal
= ((TimeStamp
*)lhsResult
)->seconds();
443 case DATEFROMTIMESTAMP
:
445 ((TimeStamp
*)lhsResult
)->getDate(*(Date
*)calVal
);
448 case TIMEFROMTIMESTAMP
:
450 ((TimeStamp
*)lhsResult
)->getTime(*(Time
*)calVal
);
453 default: return NULL
;
458 void Expression::copyFunctionVal(void *dest
,void *src
, FunctionType type
, int length
)
465 //date.parseFrom((char*)src);
466 AllDataType::copyVal(dest
, src
, typeDate
,length
);
469 case DATEADDWITHYEAR
:
471 AllDataType::copyVal(dest
, src
,typeInt
,length
);
476 AllDataType::copyVal(dest
, src
,typeInt
,length
);
481 AllDataType::copyVal(dest
, src
,typeInt
,length
);
484 case DATESUBWITHYEAR
:
486 AllDataType::copyVal(dest
, src
,typeInt
,length
);
491 AllDataType::copyVal(dest
, src
,typeInt
,length
);
496 AllDataType::copyVal(dest
, src
,typeInt
,length
);
501 AllDataType::copyVal(dest
, src
, typeTime
,length
);
504 case TIMEADDWITHHOUR
:
507 case TIMESUBWITHHOUR
:
511 AllDataType::copyVal(dest
, src
,typeInt
,length
);
514 case TIMESTAMPADDWITHYEAR
:
515 case TIMESTAMPADDWITHMON
:
516 case TIMESTAMPADDWITHDAY
:
517 case TIMESTAMPSUBWITHYEAR
:
518 case TIMESTAMPSUBWITHMON
:
519 case TIMESTAMPSUBWITHDAY
:
520 case TIMESTAMPADDWITHHOUR
:
521 case TIMESTAMPADDWITHMIN
:
522 case TIMESTAMPADDWITHSEC
:
523 case TIMESTAMPSUBWITHHOUR
:
524 case TIMESTAMPSUBWITHMIN
:
525 case TIMESTAMPSUBWITHSEC
:
527 AllDataType::copyVal(dest
, src
,typeInt
,length
);
530 case TIMESTAMPDIFFYEAR
:
531 case TIMESTAMPDIFFMON
:
532 case TIMESTAMPDIFFDAY
:
533 case TIMESTAMPDIFFHOUR
:
534 case TIMESTAMPDIFFMIN
:
535 case TIMESTAMPDIFFSEC
:
537 AllDataType::copyVal(dest
, src
,typeTimeStamp
,length
);
540 case EXTRACTYEARFROMDAY
:
541 case EXTRACTMONFROMDAY
:
542 case EXTRACTDAYFROMDAY
:
544 AllDataType::copyVal(dest
, src
,typeDate
,length
);
547 case EXTRACTHOURFROMTIME
:
548 case EXTRACTMINFROMTIME
:
549 case EXTRACTSECFROMTIME
:
551 AllDataType::copyVal(dest
, src
,typeTime
,length
);
554 case EXTRACTYEARFROMTIMESTAMP
:
555 case EXTRACTMONFROMTIMESTAMP
:
556 case EXTRACTDAYFROMTIMESTAMP
:
557 case EXTRACTHOURFROMTIMESTAMP
:
558 case EXTRACTMINFROMTIMESTAMP
:
559 case EXTRACTSECFROMTIMESTAMP
:
561 AllDataType::copyVal(dest
, src
,typeTimeStamp
,length
);
565 case DATEFROMTIMESTAMP
:
566 case TIMEFROMTIMESTAMP
:
568 AllDataType::copyVal(dest
, src
,typeTimeStamp
,length
);
577 void Expression::solve(void *opand1
, void *opand2
, DataType type
, ArithOperator arOp
)
582 AllDataType::addVal(opand1
, opand2
, type
);
585 AllDataType::subVal(opand1
, opand2
, type
);
588 AllDataType::mulVal(opand1
, opand2
, type
);
591 AllDataType::divVal(opand1
, opand2
, type
);
594 AllDataType::mudVal(opand1
, opand2
, type
);
602 bool Expression::isSingleTerm()
604 if (NULL
==lhs
&& NULL
==rhs
) return true;
607 void Expression::memFree()
616 void Expression::convertStrToVal(DataType type
)
619 lhs
->convertStrToVal(type
);
621 rhs
->convertStrToVal(type
);
624 void *parseString
=constVal
;
625 constVal
=AllDataType::alloc(type
);
626 AllDataType::strToValue(constVal
,(char*)parseString
, type
);
631 void Expression::freeVal()