1 /***************************************************************************
2 * Copyright (C) 2007 by www.databasecache.com *
3 * Contact: praba_tuty@databasecache.com *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 ***************************************************************************/
20 #define SmallestValJulDate (1721426)
26 Date::Date(int year
, int month
, int day
)
27 { YMDToJulian(year
, month
, day
, julianDate
); }
28 int Date::set(int year
, int month
, int day
)
29 { return YMDToJulian(year
,month
,day
,julianDate
); }
30 int Date::get(int &year
, int &month
, int &day
) const
31 { return julianToYMD(julianDate
,year
,month
,day
); }
33 int Date::parseFrom(const char *s
) {
36 if(strcmp(s
,"now")==0 || strcmp(s
,"NOW")==0){
37 time_t cnow
= ::time(NULL
);
38 #if defined(SOLARIS) && defined(REMOTE_SOLARIS)
39 struct std::tm
*tmval
= (struct std::tm
*) localtime(&cnow
);
40 return set(year
=tmval
->tm_year
+1900, month
=tmval
->tm_mon
+1, day
=tmval
->tm_mday
);
42 struct tm
*tmval
= localtime(&cnow
);
43 return set(year
=tmval
->tm_year
+1900,month
=tmval
->tm_mon
+1,day
=tmval
->tm_mday
);
50 count
= sscanf(s
,"%d-%d-%d",&year
,&month
,&day
);
54 count
= sscanf(s
,"%d/%d/%d",&year
,&month
,&day
);
59 if (count
< 3) return -1;
60 if (year
< 100) year
+= 1900;
61 if (!isValidDate(year
, month
, day
))
63 return set(year
,month
,day
);
67 void Date::changeToCsqlFormat(char *src
)
74 strncpy(dstPtr
, srcPtr
, 4);
78 if(strncasecmp(srcPtr
,"JAN",3) == 0) strncpy(dstPtr
, "01", 2);
79 else if(strncasecmp(srcPtr
,"FEB",3)== 0) strncpy(dstPtr
, "02", 2);
80 else if(strncasecmp(srcPtr
,"MAR",3)== 0) strncpy(dstPtr
, "03", 2);
81 else if(strncasecmp(srcPtr
,"APR",3)== 0) strncpy(dstPtr
, "04", 2);
82 else if(strncasecmp(srcPtr
,"MAY",3)== 0) strncpy(dstPtr
, "05", 2);
83 else if(strncasecmp(srcPtr
,"JUN",3)== 0) strncpy(dstPtr
, "06", 2);
84 else if(strncasecmp(srcPtr
,"JUL",3)== 0) strncpy(dstPtr
, "07", 2);
85 else if(strncasecmp(srcPtr
,"AUG",3)== 0) strncpy(dstPtr
, "08", 2);
86 else if(strncasecmp(srcPtr
,"SEP",3)== 0) strncpy(dstPtr
, "09", 2);
87 else if(strncasecmp(srcPtr
,"OCT",3)== 0) strncpy(dstPtr
, "10", 2);
88 else if(strncasecmp(srcPtr
,"NOV",3)== 0) strncpy(dstPtr
, "11", 2);
89 else if(strncasecmp(srcPtr
,"DEC",3)== 0) strncpy(dstPtr
, "12", 2);
92 strncpy(dstPtr
, src
, 2);
97 void Date::addDay(int noOfDays
)
99 julianDate
= julianDate
+ noOfDays
;
101 void Date::subDay(int noOfDays
)
103 julianDate
= julianDate
- noOfDays
;
106 void Date::addMonth(int noOfMons
)
108 int year
, month
, day
;
117 void Date::subMonth(int noOfMons
)
119 int year
, month
, day
;
123 year
-= (noOfMons
/12);
125 month
-= (noOfMons
%12);
132 void Date::addYear(int noOfYrs
)
134 int year
, month
, day
;
140 void Date::subYear(int noOfYrs
)
142 int year
, month
, day
;
149 int Date::dayOfMonth() const {
150 int year
, month
, day
;
154 int Date::month() const {
155 int year
, month
, day
;
159 int Date::year() const {
160 int year
, month
, day
;
165 int Date::dayOfWeek() const { return dayOfWeek(julianDate
); }
167 const char *Date::dayOfWeekName() const
168 { return dayOfWeekName(dayOfWeek(julianDate
)); }
170 const char *Date::dayOfWeekAbbr() const
171 { return dayOfWeekAbbr(dayOfWeek(julianDate
)); }
173 static const char *day_names
[] = {
174 "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
176 static const char *day_abbrs
[] = {
177 "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
180 static const char *month_names
[] = {
181 "January", "February", "March", "April", "May", "June",
182 "July", "August", "September", "October", "November", "December"
184 static const char *month_abbrs
[] = {
185 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
186 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
190 static int daysBeforeMonth
[] = {
191 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365
193 static int days_per_month
[] = {
194 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
197 const char * Date::dayOfWeekName(int day
)
198 { return (day
< 1 || day
> 7) ? 0 : day_names
[day
-1]; }
200 const char * Date::dayOfWeekAbbr(int day
)
201 { return (day
< 1 || day
> 7) ? 0 : day_abbrs
[day
-1]; }
203 const char * Date::monthName() const { return monthName(month()); }
204 const char * Date::monthAbbr() const { return monthAbbr(month()); }
205 const char * Date::monthName(int month
)
206 { return (month
< 1 || month
> 12) ? 0 : month_names
[month
-1]; }
207 const char * Date::monthAbbr(int month
)
208 { return (month
< 1 || month
> 12) ? 0 : month_abbrs
[month
-1]; }
209 Date
operator+(const Date
&d1
, int days
)
210 { return Date(d1
.julianDate
+ days
); }
211 Date
operator+(int days
, const Date
&d1
)
212 { return Date(d1
.julianDate
+ days
); }
213 Date
operator-(const Date
&d1
, int days
)
214 { return Date(d1
.julianDate
- days
); }
216 int operator-(const Date
&d1
, const Date
& d2
)
217 { return d1
.julianDate
- d2
.julianDate
; }
219 int operator<(const Date
&d1
,const Date
&d2
)
220 { return d1
.julianDate
< d2
.julianDate
; }
221 int operator>(const Date
&d1
,const Date
&d2
)
222 { return d1
.julianDate
> d2
.julianDate
; }
223 int operator<=(const Date
&d1
,const Date
&d2
)
224 { return d1
.julianDate
<= d2
.julianDate
; }
225 int operator>=(const Date
&d1
,const Date
&d2
)
226 { return d1
.julianDate
>= d2
.julianDate
; }
227 int operator==(const Date
&d1
,const Date
&d2
)
228 { return d1
.julianDate
== d2
.julianDate
; }
229 int operator!=(const Date
&d1
,const Date
&d2
)
230 { return d1
.julianDate
!= d2
.julianDate
; }
232 bool Date::isValid() const
233 { return julianDate
>= SmallestValJulDate
; }
235 bool Date::isLeapYear(int year
)
237 return (year
% 400 == 0) || ((year
% 4 == 0) && !(year
% 100 == 0));
240 int Date::dayOfYear() const {
243 int tmp
= daysBeforeMonth
[month
-1];
244 if (month
>= 3 && isLeapYear(year
))
249 int Date::daysInMonth(int month
, int year
) {
251 int tmp
= days_per_month
[month
];
252 if (month
== 1 && isLeapYear(year
)) tmp
++;
256 bool Date::isValidDate(int year
, int month
, int day
) {
258 if (year
< 1 || year
> 9999) return false;
259 if (month
< 1 || month
> 12) return false;
260 return (day
>= 1) && (day
<= daysInMonth(month
,year
));
263 // Algorithm Author: Robert G. Tantzen
264 int Date::YMDToJulian(int year
, int mon
, int day
, JulianRep
&jul
) {
265 if (!isValidDate(year
, mon
, day
))
266 { jul
= (JulianRep
)0; return -1; }
268 // year, month, day are assumed to be valid
269 int m
= mon
, d
= day
, y
= year
;
273 else { m
+= 9; --y
; }
276 j
= (146097*c
)/4 + (1461*ya
)/4 + (153*m
+2)/5 + d
+ 1721119;
281 // Julian date converter. Takes a julian date (the number of days since some
282 // distant epoch or other), and returns month, day of month, and year in
283 // integer references.
284 // Algorithm Author: Robert G. Tantzen
285 int Date::dayOfWeek(JulianRep jul
) {
286 return (int)((jul
+1)%7+1);
289 int Date::julianToYMD(JulianRep jul
, int &year
, int &month
, int &day
) {
293 if (j
< SmallestValJulDate
)
294 { year
= month
= day
= 0; return -1; }
297 y
= (4 * j
- 1)/146097;
298 j
= 4 * j
- 1 - 146097 * y
;
300 j
= (4 * d
+ 3)/1461;
301 d
= 4 * d
+ 3 - 1461 * j
;
304 d
= 5 * d
- 3 - 153 * m
;
308 else { m
-= 9; ++y
; }
315 #define MAX_VALID_SECONDS (60 * 60 * 24 -1)
316 Time::Time(int hours
, int mins
, int secs
, int usec
)
317 { set(hours
,mins
,secs
, usec
); }
319 int Time::set(int hours
, int mins
, int secs
, int usec
) {
320 if((hours
| mins
| secs
| usec
) < 0) { timeVal
= -1; return -1; }
321 if(hours
>= 24 | mins
>= 60 | secs
>= 62)
322 { timeVal
= -1; return -1; }
323 timeVal
= secs
+ mins
* 60 + hours
* 3600;
325 if(usec
) timeVal
+= usec
/100;
329 int Time::get(int &hours
, int &mins
, int &secs
) const {
330 if (timeVal
< 0) return -1;
331 int s
= timeVal
/10000;
340 int Time::addSec(int secs
)
342 timeVal
+= (secs
*10000);
343 int quit
= timeVal
/864000000;
344 if(0==quit
) return 0;
345 timeVal
%= 864000000;
349 int Time::subSec(int secs
)
351 timeVal
-= (secs
*10000);
352 int quit
= timeVal
/864000000;
353 if(0==quit
) return 0;
354 timeVal
%= 864000000;
357 int Time::addMin(int mins
)
359 timeVal
+= (mins
* 60 * 10000);
360 int quit
= timeVal
/864000000;
361 if(0==quit
) return 0;
362 timeVal
%= 864000000;
365 int Time::subMin(int mins
)
367 timeVal
-= (mins
* 60 * 10000);
368 int quit
= timeVal
/864000000;
369 if(0==quit
) return 0;
370 timeVal
%= 864000000;
373 int Time::addHour(int hours
)
377 timeVal
+= (hours
* 60 * 60 * 10000);
378 int quit
= day
+(timeVal
/864000000);
379 if(0==quit
) return 0;
380 timeVal
%= 864000000;
383 int Time::subHour(int hours
)
385 timeVal
-= (hours
* 60 * 60 * 10000);
386 int quit
= timeVal
/864000000;
389 if(quit
<0) timeVal
+= ( 864000000 * quit
*(-1) );
390 else timeVal
+=864000000;
392 if(0==quit
) return 0;
393 timeVal
%= 864000000;
397 int Time::seconds() const { return (timeVal
/10000) % 60; }
398 int Time::minutes() const { return (timeVal
/(60*10000)) % 60; }
399 int Time::hours() const { return timeVal
/ (3600*10000); }
400 int Time::msec() const { return (timeVal
% 10000) / 10; }
401 int Time::usec() const { return (timeVal
% 10000) * 100; }
403 int Time::setMsec(int ms
) {
404 if(ms
< 0 || ms
>= 1000) return -1;
405 timeVal
= timeVal
+(10*ms
);
408 int Time::setUsec(int us
) {
409 if(us
< 0 || us
>= 1000000) return -1;
410 timeVal
= timeVal
+us
/100;
414 bool Time::isValid() const
415 { return timeVal
>= 0 && timeVal
<= (10000*(MAX_VALID_SECONDS
+1)-1); }
417 bool Time::isValidTime(int hours
, int mins
, int secs
) {
418 return (hours
>= 0 && hours
< 24) &&
419 (mins
>= 0 && mins
< 60) &&
420 (secs
>= 0 && secs
< 60);
423 Time
operator+(const Time
&t1
, int seconds
)
424 { return Time(t1
.timeVal
+ seconds
*10000); }
425 Time
operator+(int seconds
, const Time
&t1
)
426 { return Time(t1
.timeVal
+ seconds
*10000); }
427 Time
operator-(const Time
&t1
, int seconds
)
428 { return Time(t1
.timeVal
- seconds
*10000); }
430 int operator-(const Time
&t1
, const Time
& t2
)
431 { return (t1
.timeVal
- t2
.timeVal
)/10000; }
433 int operator<(const Time
&t1
,const Time
&t2
)
434 { return t1
.timeVal
< t2
.timeVal
; }
435 int operator>(const Time
&t1
,const Time
&t2
)
436 { return t1
.timeVal
> t2
.timeVal
; }
437 int operator<=(const Time
&t1
,const Time
&t2
)
438 { return t1
.timeVal
<= t2
.timeVal
; }
439 int operator>=(const Time
&t1
,const Time
&t2
)
440 { return t1
.timeVal
>= t2
.timeVal
; }
441 int operator==(const Time
&t1
,const Time
&t2
)
442 { return t1
.timeVal
== t2
.timeVal
; }
443 int operator!=(const Time
&t1
,const Time
&t2
)
444 { return t1
.timeVal
!= t2
.timeVal
; }
446 int Time::parseFrom(const char *s
) {
449 if(strcmp(s
,"now")==0 || strcmp(s
,"NOW")==0){
450 time_t cnow
= ::time(NULL
);
451 #if defined(SOLARIS) && defined(REMOTE_SOLARIS)
452 struct std::tm
*tmval
= (struct std::tm
*) localtime(&cnow
);
453 return set(hours
=tmval
->tm_hour
,mins
=tmval
->tm_min
,secs
=tmval
->tm_sec
);
455 struct tm
*tmval
= localtime(&cnow
);
456 return set(hours
=tmval
->tm_hour
,mins
=tmval
->tm_min
,secs
=tmval
->tm_sec
);
460 count
= sscanf(s
,"%d:%d:%d",&hours
,&mins
,&secs
);
461 if (count
< 2) return -1;
462 if (count
== 2) secs
= 0;
464 if (!isValidTime(hours
,mins
,secs
))
466 return set(hours
,mins
,secs
);
469 int TimeStamp::parseFrom(const char *s
) {
473 if(strcmp(s
,"now")==0 || strcmp(s
,"NOW")==0){
474 time_t cnow
= ::time(NULL
);
475 #if defined(SOLARIS) && defined(REMOTE_SOLARIS)
476 struct std::tm
*tmval
= (struct std::tm
*) localtime(&cnow
);
477 setDate(year
=tmval
->tm_year
+1900,month
=tmval
->tm_mon
+1,day
=tmval
->tm_mday
);
478 return setTime(hours
=tmval
->tm_hour
,mins
=tmval
->tm_min
,secs
=tmval
->tm_sec
);
480 struct tm
*tmval
= localtime(&cnow
);
481 setDate(year
=tmval
->tm_year
+1900,month
=tmval
->tm_mon
+1,day
=tmval
->tm_mday
);
482 return setTime(hours
=tmval
->tm_hour
,mins
=tmval
->tm_min
,secs
=tmval
->tm_sec
);
489 count
= sscanf(s
,"%d-%d-%d %d:%d:%d",&year
,&month
,&day
, &hours
, &mins
, &secs
);
493 count
= sscanf(s
,"%d/%d/%d %d:%d:%d",&year
,&month
,&day
, &hours
, &mins
, &secs
);
498 if (count
< 5) return -1;
499 if (count
== 5) secs
= 0;
500 if (year
< 100) year
+= 1900;
502 if (!date
.isValidDate(year
, month
, day
))
505 setDate(year
,month
,day
);
508 if (!time
.isValidTime(hours
,mins
,secs
))
510 return setTime(hours
,mins
,secs
);
513 void TimeStamp::addHour(int hours
)
515 int day
= time
.addHour(hours
);
516 if(day
!=0){ date
.addDay(day
);}
519 void TimeStamp::subHour(int hours
)
521 int day
= time
.subHour(hours
);
522 if(day
!=0){ date
.subDay(day
);}
525 void TimeStamp::addMin(int noOfMins
)
527 int day
= time
.addMin(noOfMins
);
528 if(day
!=0){ date
.addDay(day
);}
531 void TimeStamp::subMin(int noOfMins
)
533 int day
= time
.subMin(noOfMins
);
534 if(day
!=0) {date
.subDay(day
);}
536 void TimeStamp::addSec(int noOfSecs
)
538 int day
= time
.addSec(noOfSecs
);
539 if(day
!=0){ date
.addDay(day
);}
541 void TimeStamp::subSec(int noOfSecs
)
543 int day
= time
.subSec(noOfSecs
);
544 if(day
!=0){ date
.subDay(day
);}
547 int TimeStamp::secDiff(TimeStamp
&ts
)
549 int day1
= date
.getCalDay();
550 int day2
= Date(ts
).getCalDay();
551 int sec1
= time
.getCalSec();
552 int sec2
= Time(ts
).getCalSec();
553 return (((day1
*24*60*60)+sec1
) - ((day2
*24*60*60)+sec2
));
555 int TimeStamp::minDiff(TimeStamp
&ts
)
557 int day1
= date
.getCalDay();
558 int day2
= Date(ts
).getCalDay();
559 int sec1
= time
.getCalSec();
560 int sec2
= Time(ts
).getCalSec();
561 int secdiff
= (((day1
*24*60*60)+sec1
) - ((day2
*24*60*60)+sec2
));
566 int TimeStamp::hourDiff(TimeStamp
&ts
)
568 int day1
= date
.getCalDay();
569 int day2
= Date(ts
).getCalDay();
570 int sec1
= time
.getCalSec();
571 int sec2
= Time(ts
).getCalSec();
572 int secdiff
= (((day1
*24*60*60)+sec1
) - ((day2
*24*60*60)+sec2
));
573 return (secdiff
/3600);
576 int TimeStamp::dayDiff(TimeStamp
&ts
)
578 int day1
= date
.getCalDay();
579 int day2
= Date(ts
).getCalDay();
580 int sec1
= time
.getCalSec();
581 int sec2
= Time(ts
).getCalSec();
582 int secdiff
= (((day1
*24*60*60)+sec1
) - ((day2
*24*60*60)+sec2
));
583 return (secdiff
/(3600*24));
587 int TimeStamp::monthDiff(TimeStamp
&ts
)
589 int day1
= date
.getCalDay();
590 int day2
= Date(ts
).getCalDay();
591 int sec1
= time
.getCalSec();
592 int sec2
= Time(ts
).getCalSec();
593 int secdiff
= (((day1
*24*60*60)+sec1
) - ((day2
*24*60*60)+sec2
));
594 return (secdiff
/(3600*24*30));
597 int TimeStamp::yearDiff(TimeStamp
&ts
)
599 int day1
= date
.getCalDay();
600 int day2
= Date(ts
).getCalDay();
601 int sec1
= time
.getCalSec();
602 int sec2
= Time(ts
).getCalSec();
603 int secdiff
= (((day1
*24*60*60)+sec1
) - ((day2
*24*60*60)+sec2
));
604 return (secdiff
/(3600*24*30*12));
606 void TimeStamp::changeToCsqlFormat(char *src
)
613 strncpy(dstPtr
, srcPtr
, 4);
617 if(strncasecmp(srcPtr
,"JAN",3) == 0) strncpy(dstPtr
, "01", 2);
618 else if(strncasecmp(srcPtr
,"FEB",3)== 0) strncpy(dstPtr
, "02", 2);
619 else if(strncasecmp(srcPtr
,"MAR",3)== 0) strncpy(dstPtr
, "03", 2);
620 else if(strncasecmp(srcPtr
,"APR",3)== 0) strncpy(dstPtr
, "04", 2);
621 else if(strncasecmp(srcPtr
,"MAY",3)== 0) strncpy(dstPtr
, "05", 2);
622 else if(strncasecmp(srcPtr
,"JUN",3)== 0) strncpy(dstPtr
, "06", 2);
623 else if(strncasecmp(srcPtr
,"JUL",3)== 0) strncpy(dstPtr
, "07", 2);
624 else if(strncasecmp(srcPtr
,"AUG",3)== 0) strncpy(dstPtr
, "08", 2);
625 else if(strncasecmp(srcPtr
,"SEP",3)== 0) strncpy(dstPtr
, "09", 2);
626 else if(strncasecmp(srcPtr
,"OCT",3)== 0) strncpy(dstPtr
, "10", 2);
627 else if(strncasecmp(srcPtr
,"NOV",3)== 0) strncpy(dstPtr
, "11", 2);
628 else if(strncasecmp(srcPtr
,"DEC",3)== 0) strncpy(dstPtr
, "12", 2);
631 strncpy(dstPtr
, src
, 2);
634 strncpy(dstPtr
, srcPtr
, 9);
639 int operator< (const TimeStamp
&d1
, const TimeStamp
&d2
)
640 { return (d1
.date
!= d2
.date
) ? d1
.date
< d2
.date
: d1
.time
< d2
.time
; }
641 int operator> (const TimeStamp
&d1
, const TimeStamp
&d2
)
642 { return (d1
.date
!= d2
.date
) ? d1
.date
> d2
.date
: d1
.time
> d2
.time
; }
643 int operator<=(const TimeStamp
&d1
, const TimeStamp
&d2
)
644 { return (d1
.date
!= d2
.date
) ? d1
.date
< d2
.date
: d1
.time
<= d2
.time
; }
645 int operator>=(const TimeStamp
&d1
, const TimeStamp
&d2
)
646 { return (d1
.date
!= d2
.date
) ? d1
.date
> d2
.date
: d1
.time
>= d2
.time
; }
647 int operator==(const TimeStamp
&d1
, const TimeStamp
&d2
)
648 { return d1
.date
== d2
.date
&& d1
.time
== d2
.time
; }
649 int operator!=(const TimeStamp
&d1
, const TimeStamp
&d2
)
650 { return d1
.date
!= d2
.date
|| d1
.time
!= d2
.time
; }
652 DataType
AllDataType::getCsqlTypeFromFunctionType(FunctionType type
)
656 case DATEDIFF
: return typeDate
;
657 case TIMEDIFF
: return typeTime
;
658 case DATEADDWITHYEAR
:
661 case DATESUBWITHYEAR
:
664 case TIMEADDWITHHOUR
:
667 case TIMESUBWITHHOUR
:
669 case TIMESUBWITHSEC
: return typeInt
;
670 case TIMESTAMPADDWITHYEAR
:
671 case TIMESTAMPADDWITHMON
:
672 case TIMESTAMPADDWITHDAY
:
673 case TIMESTAMPSUBWITHYEAR
:
674 case TIMESTAMPSUBWITHMON
:
675 case TIMESTAMPSUBWITHDAY
:
676 case TIMESTAMPADDWITHHOUR
:
677 case TIMESTAMPADDWITHMIN
:
678 case TIMESTAMPADDWITHSEC
:
679 case TIMESTAMPSUBWITHHOUR
:
680 case TIMESTAMPSUBWITHMIN
:
681 case TIMESTAMPSUBWITHSEC
: return typeInt
;
682 case TIMESTAMPDIFFYEAR
:
683 case TIMESTAMPDIFFMON
:
684 case TIMESTAMPDIFFDAY
:
685 case TIMESTAMPDIFFHOUR
:
686 case TIMESTAMPDIFFMIN
:
687 case TIMESTAMPDIFFSEC
: return typeTimeStamp
;
688 case EXTRACTYEARFROMDAY
:
689 case EXTRACTMONFROMDAY
:
690 case EXTRACTDAYFROMDAY
:return typeDate
;
691 case EXTRACTHOURFROMTIME
:
692 case EXTRACTMINFROMTIME
:
693 case EXTRACTSECFROMTIME
: return typeTime
;
694 case EXTRACTYEARFROMTIMESTAMP
:
695 case EXTRACTMONFROMTIMESTAMP
:
696 case EXTRACTDAYFROMTIMESTAMP
:
697 case EXTRACTHOURFROMTIMESTAMP
:
698 case EXTRACTMINFROMTIMESTAMP
:
699 case EXTRACTSECFROMTIMESTAMP
: return typeTimeStamp
;
700 case DATEFROMTIMESTAMP
: return typeTimeStamp
;
701 case TIMEFROMTIMESTAMP
: return typeTimeStamp
;
702 default: return typeInt
;
705 DataType
AllDataType::getCsqlTypeFromFunctionTypeForComparision(FunctionType type
)
709 case DATEDIFF
: return typeInt
;
710 case DATEADDWITHYEAR
: return typeDate
;
711 case DATEADDWITHMON
: return typeDate
;
712 case DATEADDWITHDAY
: return typeDate
;
713 case DATESUBWITHYEAR
: return typeDate
;
714 case DATESUBWITHMON
: return typeDate
;
715 case DATESUBWITHDAY
: return typeDate
;
716 case TIMEDIFF
: return typeInt
;
717 case TIMEADDWITHHOUR
: return typeTime
;
718 case TIMEADDWITHMIN
: return typeTime
;
719 case TIMEADDWITHSEC
: return typeTime
;
720 case TIMESUBWITHHOUR
: return typeTime
;
721 case TIMESUBWITHMIN
: return typeTime
;
722 case TIMESUBWITHSEC
: return typeTime
;
723 case TIMESTAMPADDWITHYEAR
: return typeTimeStamp
;
724 case TIMESTAMPADDWITHMON
: return typeTimeStamp
;
725 case TIMESTAMPADDWITHDAY
: return typeTimeStamp
;
726 case TIMESTAMPSUBWITHYEAR
: return typeTimeStamp
;
727 case TIMESTAMPSUBWITHMON
: return typeTimeStamp
;
728 case TIMESTAMPSUBWITHDAY
: return typeTimeStamp
;
729 case TIMESTAMPADDWITHHOUR
: return typeTimeStamp
;
730 case TIMESTAMPADDWITHMIN
: return typeTimeStamp
;
731 case TIMESTAMPADDWITHSEC
: return typeTimeStamp
;
732 case TIMESTAMPSUBWITHHOUR
: return typeTimeStamp
;
733 case TIMESTAMPSUBWITHMIN
: return typeTimeStamp
;
734 case TIMESTAMPSUBWITHSEC
: return typeTimeStamp
;
735 case TIMESTAMPDIFFYEAR
:
736 case TIMESTAMPDIFFMON
:
737 case TIMESTAMPDIFFDAY
:
738 case TIMESTAMPDIFFHOUR
:
739 case TIMESTAMPDIFFMIN
:
740 case TIMESTAMPDIFFSEC
:
741 case EXTRACTYEARFROMDAY
:
742 case EXTRACTMONFROMDAY
:
743 case EXTRACTDAYFROMDAY
:
744 case EXTRACTHOURFROMTIME
:
745 case EXTRACTMINFROMTIME
:
746 case EXTRACTSECFROMTIME
:
747 case EXTRACTYEARFROMTIMESTAMP
:
748 case EXTRACTMONFROMTIMESTAMP
:
749 case EXTRACTDAYFROMTIMESTAMP
:
750 case EXTRACTHOURFROMTIMESTAMP
:
751 case EXTRACTMINFROMTIMESTAMP
:
752 case EXTRACTSECFROMTIMESTAMP
:return typeInt
;
753 case DATEFROMTIMESTAMP
: return typeDate
;
754 case TIMEFROMTIMESTAMP
: return typeTime
;
755 default: return typeInt
;
760 char* AllDataType::getSQLString(DataType type
)
764 case typeInt
: return "INT";
765 case typeLong
: return "INT";
766 case typeLongLong
: return "BIGINT";
767 case typeShort
: return "SMALLINT";
768 case typeByteInt
: return "TINYINT";
769 case typeDouble
: return "REAL";
770 case typeFloat
: return "FLOAT";
771 case typeDate
: return "DATE";
772 case typeTime
: return "TIME";
773 case typeTimeStamp
: return "TIMESTAMP";
774 case typeString
: return "CHAR";
775 case typeVarchar
: return "VARCHAR";
776 case typeBinary
: return "BINARY";
777 default: return "UNKNOWN";
782 SQLSMALLINT
AllDataType::convertToSQLType(DataType type
)
806 return SQL_TYPE_DATE
;
808 return SQL_TYPE_TIME
;
810 return SQL_TYPE_TIMESTAMP
;
820 SQLSMALLINT
AllDataType::convertToCSQLSQLType(DataType type
)
844 return SQL_TYPE_DATE
;
846 return SQL_TYPE_TIME
;
848 return SQL_TYPE_TIMESTAMP
;
859 SQLSMALLINT
AllDataType::convertToSQL_C_Type(DataType type
,TDBInfo tdbname
)
869 if(tdbname
== postgres
)
872 return SQL_C_SBIGINT
;
877 return SQL_C_STINYINT
;
886 return SQL_C_TYPE_DATE
;
888 return SQL_C_TYPE_TIME
;
890 return SQL_C_TYPE_TIMESTAMP
;
900 DataType
AllDataType::convertFromSQLType(SQLSMALLINT type
,int length
,int scale
,TDBInfo tdbname
)
902 if(tdbname
==postgres
)
921 case SQL_TYPE_TIMESTAMP
:
922 return typeTimeStamp
;
925 case SQL_LONGVARCHAR
:
953 case SQL_TYPE_TIMESTAMP
:
954 return typeTimeStamp
;
957 case SQL_LONGVARCHAR
:
966 void AllDataType::subVal(void* dest
, void *src
, DataType type
)
971 *(int*)dest
= *(int*)dest
- *(int*)src
;
974 *(long*)dest
= *(long*)dest
- *(long*)src
;
977 *(long long*)dest
= *(long long*)dest
- *(long long*)src
;
980 *(short*)dest
= *(short*)dest
- *(short*)src
;
983 *(char*)dest
= *(char*)dest
- *(char*)src
;
986 *(double*)dest
= *(double*)dest
- *(double*)src
;
989 *(float*)dest
= *(float*)dest
- *(float*)src
;
1001 void AllDataType::mulVal(void* dest
, void *src
, DataType type
)
1006 *(int*)dest
= *(int*)dest
* (*(int*)src
);
1009 *(long*)dest
= *(long*)dest
* (*(long*)src
);
1012 *(long long*)dest
= *(long long*)dest
* (*(long long*)src
);
1015 *(short*)dest
= *(short*)dest
* (*(short*)src
);
1018 *(char*)dest
= *(char*)dest
* (*(char*)src
);
1021 *(double*)dest
= *(double*)dest
* (*(double*)src
);
1024 *(float*)dest
= *(float*)dest
* (*(float*)src
);
1036 void AllDataType::mudVal(void* dest
, void *src
, DataType type
)
1038 if (type
== typeInt
)
1040 *(int*)dest
= *(int*)dest
% (*(int*)src
);
1046 *(int*)dest
= *(int*)dest
% (*(int*)src
);
1049 *(long*)dest
= *(long*)dest
% (*(long*)src
);
1052 *(long long*)dest
= *(long long*)dest
% (*(long long*)src
);
1055 *(short*)dest
= *(short*)dest
% (*(short*)src
);
1058 *(char*)dest
= *(char*)dest
% (*(char*)src
);
1061 *(double*)dest
= *(long long*)dest
% (*(long long*)src
);
1064 *(float*)dest
= *(int*)dest
% (*(int*)src
);
1076 void AllDataType::divVal(void* dest
, void *src
, DataType type
)
1078 if (type
== typeInt
)
1080 *(int*)dest
= *(int*)dest
/ (*(int*)src
);
1086 *(int*)dest
= *(int*)dest
/ (*(int*)src
);
1089 *(long*)dest
= *(long*)dest
/ (*(long*)src
);
1092 *(long long*)dest
= *(long long*)dest
/ (*(long long*)src
);
1095 *(short*)dest
= *(short*)dest
/ (*(short*)src
);
1098 *(char*)dest
= *(char*)dest
/ (*(char*)src
);
1101 *(double*)dest
= *(double *)dest
/ (*(double*)src
);
1104 *(float*)dest
= *(float*)dest
/ (*(float*)src
);
1116 void AllDataType::divVal(double* dest
, int src
, DataType type
)
1128 *dest
= *dest
/ src
;
1141 void AllDataType::increment(void* dest
, void *src
, DataType type
)
1146 *(int*)dest
= *(int*)src
+ 1;
1149 *(long*)dest
= *(long*)src
+ 1;
1152 *(long long*)dest
= *(long long*)src
+ 1;
1155 *(char*)dest
= *(char*)src
+ 1;
1158 *(short*)dest
= *(short*)src
+ 1;
1161 *(double*)dest
= *(double*)src
+ 1;
1164 *(float*)dest
= *(float*)src
+ 1;
1171 bool AllDataType::isValueZero(void *src
, DataType type
)
1176 if (*(int*)src
== 0) return true;
1179 if (*(int*)src
== 0) return true;
1182 if (*(int*)src
== 0) return true;
1185 if (*(int*)src
== 0) return true;
1188 if (*(int*)src
== 0) return true;
1191 if (*(int*)src
== 0) return true;
1199 bool AllDataType::compareIntVal(void* src1
, void *src2
, ComparisionOp op
)
1201 printf("This function should never be called by anyone\n");
1202 if (OpEquals
== op
) {
1203 if (*(int*)src1
== *(int*)src2
) return true;
1205 }else if (OpGreaterThan
== op
) {
1206 if (*(int*)src1
> *(int*)src2
) return true;
1208 }else if (OpLessThan
== op
) {
1209 if (*(int*)src1
< *(int*)src2
) return true;
1211 }else if (OpLessThanEquals
== op
) {
1212 if (*(int*)src1
<= *(int*)src2
) return true;
1214 }else if (OpGreaterThanEquals
== op
) {
1215 if (*(int*)src1
>= *(int*)src2
) return true;
1217 }else if (OpNotEquals
== op
) {
1218 if (*(int*)src1
!= *(int*)src2
) return true;
1224 bool AllDataType::compareLongVal(void* src1
, void *src2
, ComparisionOp op
)
1226 bool result
= false;
1230 if (*(long*)src1
== *(long*)src2
) result
= true;
1231 else result
= false;
1234 if (*(long*)src1
!= *(long*)src2
) result
= true;
1235 else result
= false;
1238 if (*(long*)src1
< *(long*)src2
) result
= true;
1239 else result
= false;
1241 case OpLessThanEquals
:
1242 if (*(long*)src1
<= *(long*)src2
) result
= true;
1243 else result
= false;
1246 if (*(long*)src1
> *(long*)src2
) result
= true;
1247 else result
= false;
1249 case OpGreaterThanEquals
:
1250 if (*(long*)src1
>= *(long*)src2
) result
= true;
1251 else result
= false;
1257 bool AllDataType::compareLongLongVal(void* src1
, void *src2
,
1260 bool result
= false;
1264 if (*(long long*)src1
== *(long long*)src2
) result
= true;
1265 else result
= false;
1268 if (*(long long*)src1
!= *(long long*)src2
) result
= true;
1269 else result
= false;
1272 if (*(long long*)src1
< *(long long*)src2
) result
= true;
1273 else result
= false;
1275 case OpLessThanEquals
:
1276 if (*(long long*)src1
<= *(long long*)src2
) result
= true;
1277 else result
= false;
1280 if (*(long long*)src1
> *(long long*)src2
) result
= true;
1281 else result
= false;
1283 case OpGreaterThanEquals
:
1284 if (*(long long*)src1
>= *(long long*)src2
) result
= true;
1285 else result
= false;
1291 bool AllDataType::compareShortVal(void* src1
, void *src2
, ComparisionOp op
)
1293 bool result
= false;
1297 if (*(short*)src1
== *(short*)src2
) result
= true;
1298 else result
= false;
1301 if (*(short*)src1
!= *(short*)src2
) result
= true;
1302 else result
= false;
1305 if (*(short*)src1
< *(short*)src2
) result
= true;
1306 else result
= false;
1308 case OpLessThanEquals
:
1309 if (*(short*)src1
<= *(short*)src2
) result
= true;
1310 else result
= false;
1313 if (*(short*)src1
> *(short*)src2
) result
= true;
1314 else result
= false;
1316 case OpGreaterThanEquals
:
1317 if (*(short*)src1
>= *(short*)src2
) result
= true;
1318 else result
= false;
1324 bool AllDataType::compareByteIntVal(void* src1
, void *src2
, ComparisionOp op
)
1326 bool result
= false;
1330 if (*(ByteInt
*)src1
== *(ByteInt
*)src2
) result
= true;
1331 else result
= false;
1334 if (*(ByteInt
*)src1
!= *(ByteInt
*)src2
) result
= true;
1335 else result
= false;
1338 if (*(ByteInt
*)src1
< *(ByteInt
*)src2
) result
= true;
1339 else result
= false;
1341 case OpLessThanEquals
:
1342 if (*(ByteInt
*)src1
<= *(ByteInt
*)src2
) result
= true;
1343 else result
= false;
1346 if (*(ByteInt
*)src1
> *(ByteInt
*)src2
) result
= true;
1347 else result
= false;
1349 case OpGreaterThanEquals
:
1350 if (*(ByteInt
*)src1
>= *(ByteInt
*)src2
) result
= true;
1351 else result
= false;
1357 bool AllDataType::compareDoubleVal(void* src1
, void *src2
, ComparisionOp op
)
1359 bool result
= false;
1363 if (*(double*)src1
== *(double*)src2
) result
= true;
1364 else result
= false;
1367 if (*(double*)src1
!= *(double*)src2
) result
= true;
1368 else result
= false;
1371 if (*(double*)src1
< *(double*)src2
) result
= true;
1372 else result
= false;
1374 case OpLessThanEquals
:
1375 if (*(double*)src1
<= *(double*)src2
) result
= true;
1376 else result
= false;
1379 if (*(double*)src1
> *(double*)src2
) result
= true;
1380 else result
= false;
1382 case OpGreaterThanEquals
:
1383 if (*(double*)src1
>= *(double*)src2
) result
= true;
1384 else result
= false;
1390 bool AllDataType::compareFloatVal(void* src1
, void *src2
, ComparisionOp op
)
1392 bool result
= false;
1396 if (*(float*)src1
== *(float*)src2
) result
= true;
1397 else result
= false;
1400 if (*(float*)src1
!= *(float*)src2
) result
= true;
1401 else result
= false;
1404 if (*(float*)src1
< *(float*)src2
) result
= true;
1405 else result
= false;
1407 case OpLessThanEquals
:
1408 if (*(float*)src1
<= *(float*)src2
) result
= true;
1409 else result
= false;
1412 if (*(float*)src1
> *(float*)src2
) result
= true;
1413 else result
= false;
1415 case OpGreaterThanEquals
:
1416 if (*(float*)src1
>= *(float*)src2
) result
= true;
1417 else result
= false;
1423 bool AllDataType::compareDateVal(void* src1
, void *src2
, ComparisionOp op
)
1425 bool result
= false;
1429 if (*(Date
*)src1
== *(Date
*)src2
) result
= true;
1430 else result
= false;
1433 if (*(Date
*)src1
!= *(Date
*)src2
) result
= true;
1434 else result
= false;
1437 if (*(Date
*)src1
< *(Date
*)src2
) result
= true;
1438 else result
= false;
1440 case OpLessThanEquals
:
1441 if (*(Date
*)src1
<= *(Date
*)src2
) result
= true;
1442 else result
= false;
1445 if (*(Date
*)src1
> *(Date
*)src2
) result
= true;
1446 else result
= false;
1448 case OpGreaterThanEquals
:
1449 if (*(Date
*)src1
>= *(Date
*)src2
) result
= true;
1450 else result
= false;
1456 bool AllDataType::compareTimeVal(void* src1
, void *src2
, ComparisionOp op
)
1458 bool result
= false;
1462 if (*(Time
*)src1
== *(Time
*)src2
) result
= true;
1463 else result
= false;
1466 if (*(Time
*)src1
!= *(Time
*)src2
) result
= true;
1467 else result
= false;
1470 if (*(Time
*)src1
< *(Time
*)src2
) result
= true;
1471 else result
= false;
1473 case OpLessThanEquals
:
1474 if (*(Time
*)src1
<= *(Time
*)src2
) result
= true;
1475 else result
= false;
1478 if (*(Time
*)src1
> *(Time
*)src2
) result
= true;
1479 else result
= false;
1481 case OpGreaterThanEquals
:
1482 if (*(Time
*)src1
>= *(Time
*)src2
) result
= true;
1483 else result
= false;
1489 bool AllDataType::compareTimeStampVal(void* src1
, void *src2
, ComparisionOp op
)
1491 bool result
= false;
1495 if (*(TimeStamp
*)src1
== *(TimeStamp
*)src2
) result
= true;
1496 else result
= false;
1499 if (*(TimeStamp
*)src1
!= *(TimeStamp
*)src2
) result
= true;
1500 else result
= false;
1503 if (*(TimeStamp
*)src1
< *(TimeStamp
*)src2
) result
= true;
1504 else result
= false;
1506 case OpLessThanEquals
:
1507 if (*(TimeStamp
*)src1
<= *(TimeStamp
*)src2
) result
= true;
1508 else result
= false;
1511 if (*(TimeStamp
*)src1
> *(TimeStamp
*)src2
) result
= true;
1512 else result
= false;
1514 case OpGreaterThanEquals
:
1515 if (*(TimeStamp
*)src1
>= *(TimeStamp
*)src2
) result
= true;
1516 else result
= false;
1522 bool AllDataType::compareStringVal(void* src1
, void *src2
, ComparisionOp op
)
1524 if (OpEquals
== op
) {
1525 if (strcmp((char*)src1
, (char*)src2
) ==0) return true;
1527 }else if (OpGreaterThan
== op
) {
1528 if (strcmp((char*)src1
, (char*)src2
) >0) return true;
1530 }else if (OpLessThan
== op
) {
1531 if (strcmp((char*)src1
, (char*)src2
) <0 ) return true;
1533 }else if (OpLessThanEquals
== op
) {
1534 // printf("Illegal Operator:Not Supported for String\n");
1536 if (strcmp((char*)src1
, (char*)src2
)<= 0) return true;
1538 }else if (OpGreaterThanEquals
== op
) {
1539 // printf("Illegal Operator:Not Supported for String\n");
1541 if (strcmp((char*)src1
, (char*)src2
) >=0) return true;
1543 }else if (OpNotEquals
== op
) {
1544 if (strcmp((char*)src1
, (char*)src2
) != 0) return true;
1546 }else if (OpLike
== op
) {
1547 return !os::strmatch((char*)src2
, (char*)src1
);
1549 printf("Illegeal Operator:Not supported for String\n");
1553 bool AllDataType::compareBinaryVal(void* src1
, void *src2
,
1554 ComparisionOp op
, int length
)
1556 bool result
= false;
1557 int ret
= os::memcmp(src1
, src2
, length
);
1561 if (ret
== 0 ) result
= true; else result
= false;
1564 if (ret
!= 0 ) result
= true; else result
= false;
1567 if (ret
< 0 ) result
= true; else result
= false;
1569 case OpLessThanEquals
:
1570 printf("Illegal Operator:Not Supported for Binary\n");
1573 if (ret
> 0 ) result
= true; else result
= false;
1575 case OpGreaterThanEquals
:
1576 printf("Illegal Operator:Not Supported for Binary\n");
1582 void* AllDataType::alloc(DataType type
, int length
)
1588 dest
= malloc(sizeof(int));
1591 dest
= malloc(sizeof(long));
1594 dest
= malloc(sizeof(long long));
1597 dest
= malloc(sizeof(short));
1600 dest
= malloc(sizeof(char));
1603 dest
= malloc(sizeof(double));
1606 dest
= malloc(sizeof(float));
1610 //fldDef.length_ = sizeof(long double);
1614 if (length
== 0 ) return NULL
;
1615 dest
= malloc(length
);
1618 if (length
== 0 || length
> 512) return NULL
;
1619 dest
= malloc(length
);
1620 memset(dest
, 0, length
);
1623 dest
= malloc(sizeof(Date
));
1626 dest
= malloc(sizeof(Time
));
1629 dest
= malloc(sizeof(TimeStamp
));
1635 void AllDataType::memoryset(void *value
,DataType type
)
1640 value
= ::memset(value
, 0, sizeof(int));
1643 value
= ::memset(value
, 0, sizeof(long));
1646 value
=::memset(value
, 0, sizeof(long long));
1649 value
= ::memset(value
, 0, sizeof(short));
1652 value
= ::memset(value
, 0, sizeof(char));
1655 value
= ::memset(value
, 0, sizeof(double));
1658 value
= ::memset(value
, 0, sizeof(float));
1664 *(char*)value
= '\0';
1665 //if (length == 0 ) return NULL;
1666 //dest = malloc(length);
1669 /* if (length == 0 || length > 256 ) return NULL;
1671 memset(dest, 0, length);*/
1674 value
= ::memset(value
, 0, sizeof(Date
));
1677 value
= ::memset(value
, 0, sizeof(Time
));
1680 value
= ::memset(value
, 0, sizeof(TimeStamp
));
1688 DbRetVal
AllDataType::strToValue(void* dest
, char *src
, DataType type
, int length
)
1696 sscanf( src
, "%d", &val
);
1701 sscanf( src
, "%ld", &val
);
1704 case typeLongLong
: {
1706 sscanf( src
, "%lld", &val
);
1707 *(long long*)dest
= val
;
1711 sscanf( src
, "%hd", &val
);
1712 *(short*)dest
= val
;
1716 sscanf( src
, "%hhd", &val
);
1717 *(char*)dest
= *(char *)&val
;
1721 sscanf( src
, "%lg", &val
);
1722 *(double*)dest
= val
;
1726 sscanf( src
, "%f", &val
);
1727 *(float*)dest
= val
;
1733 strncpy((char*)dest
, (char*)src
, length
);
1734 char *d
=(char*)dest
;
1739 if (strlen(src
) == 11) {
1740 if ( src
[6] == '-' || src
[6] == '/' ) {
1741 Date::changeToCsqlFormat(src
);
1744 res
= sscanf( src
, "%d-%d-%d", &y
, &m
, &d
);
1746 res
= sscanf( src
, "%d/%d/%d", &y
, &m
, &d
);
1747 if (strcmp(src
,"now")==0 || strcmp(src
,"NOW")==0){
1748 Date
*dt
= (Date
*) dest
;
1749 dt
->parseFrom((char*)src
);
1754 fprintf(stderr
,"Error reading date. yyyy{-/}mm{-/}dd is the valid format.");
1757 /* Looking up at ranges of year-month-day */
1758 if(!date
.isValidDate(y
, m
, d
)){
1759 fprintf(stderr
,"Error reading date. The value \"%d-%d-%d\" is inappropriate.",y
,m
,d
);
1762 Date
dateObj(y
,m
,d
);
1763 *(Date
*)dest
= dateObj
;
1767 res
= sscanf( src
, "%d:%d:%d", &h
, &m
, &s
);
1768 if(strcmp(src
,"now")==0 || strcmp(src
,"NOW")==0){
1769 Time
*dt
= (Time
*) dest
;
1770 dt
->parseFrom((char*)src
);
1776 res
= sscanf( src
, "%d-%d-%d %d:%d:%d", &y
, &mn
, &d
, &h
, &m
, &s
);
1778 fprintf(stderr
, "Error reading time, hh:mm:ss is the valid format.");
1783 if(!time
.isValidTime(h
, m
, s
)){
1784 fprintf(stderr
,"Error reading Time. The value \"%d-%d-%d\" is inappropriate.",h
,m
,s
);
1787 Time
timeObj(h
,m
,s
);
1788 *(Time
*)dest
= timeObj
;
1790 case typeTimeStamp
: {
1791 int d
,m
,y
, h
,mn
,s
, res
=0;
1792 bool isNow
= ( strcasecmp(src
,"now")==0 );
1793 if(!isNow
&& isalpha(int(src
[5]))) {
1794 TimeStamp::changeToCsqlFormat(src
);
1796 res
= sscanf( src
, "%d-%d-%d %d:%d:%d", &y
, &m
, &d
, &h
, &mn
, &s
);
1798 res
= sscanf( src
, "%d-%d-%d, %d:%d:%d", &y
, &m
, &d
, &h
, &mn
, &s
);
1800 res
= sscanf( src
, "%d/%d/%d %d:%d:%d", &y
, &m
, &d
, &h
, &mn
, &s
);
1802 res
= sscanf( src
, "%d/%d/%d, %d:%d:%d", &y
, &m
, &d
, &h
, &mn
, &s
);
1805 TimeStamp
*dt
= (TimeStamp
*) dest
;
1806 dt
->parseFrom((char*)src
);
1811 fprintf(stderr
, "Error reading timestamp, yyyy{-/}mm{-/}dd[,] hh:mm:ss is the valid format.");
1814 /* Looking up at 'YY-MM-DD' */
1815 if(!date
.isValidDate(y
, m
, d
)){
1816 fprintf(stderr
,"Error reading date. The value \"%d-%d-%d\" is inappropriate.",y
,m
,d
);
1819 /* Looking up at 'Hour-Min-Sec' */
1820 if(!time
.isValidTime(h
, m
, s
)){
1821 fprintf(stderr
,"Error reading Time. The value \"%d-%d-%d\" is inappropriate.",h
,m
,s
);
1824 TimeStamp
timeStampObj(y
,m
,d
,h
,mn
,s
);
1825 *(TimeStamp
*)dest
= timeStampObj
;
1828 memset ((void *) dest
, 0, length
);
1829 unsigned char c
= 0;
1830 const char *str
= (const char *)src
;
1833 if( i
> (length
*2)-1 ){ i
= (length
*2)-1 ; }
1834 bool evenlegth
=false;
1835 if(i
%2){ evenlegth
=true;}
1836 unsigned char *val
= (unsigned char *)dest
+(length
-1);
1839 if (!isxdigit((int)c
)) {
1840 printError(ErrBadArg
, "Invalid hexadecimal value");
1843 if (c
<= '9') c
-= '0';
1844 else if (c
>= 'a') c
= c
- 'a' + 10;
1845 else c
= c
- 'A' + 10;
1848 if ((i
+1) % 2) { *val
= *val
| (c
<<4); val
--;}
1851 if (i
% 2) { *val
= *val
| (c
<<4); val
--;}
1865 void AllDataType::convert(DataType srcType
, void *src
,
1866 DataType destType
, void *dest
, int length
)
1868 switch ((DataType
) destType
)
1870 case typeInt
: convertToInt(dest
, src
, srcType
); break;
1871 case typeLong
: convertToLong(dest
, src
, srcType
); break;
1872 case typeLongLong
: convertToLongLong(dest
, src
, srcType
); break;
1873 case typeShort
: convertToShort(dest
, src
, srcType
); break;
1874 case typeByteInt
: convertToByteInt(dest
, src
, srcType
); break;
1876 case typeFloat
: convertToFloat(dest
, src
, srcType
); break;
1877 case typeDouble
: convertToDouble(dest
, src
, srcType
); break;
1880 case typeDecimal
: convertToDouble(dest
, src
, srcType
); break;
1882 case typeString
: convertToString(dest
, src
, srcType
); break;
1883 case typeBinary
: convertToBinary(dest
, src
, srcType
,length
); break;
1884 case typeDate
: convertToDate(dest
, src
, srcType
); break;
1885 case typeTime
: convertToTime(dest
, src
, srcType
); break;
1886 case typeTimeStamp
: convertToTimeStamp(dest
, src
, srcType
); break;
1891 void AllDataType::convertToInt( void* dest
, void* src
, DataType srcType
)
1895 case typeInt
: *(int *)dest
= *(int *)src
; break;
1896 case typeLong
: *(int *)dest
=(int) *(long *)src
; break;
1897 case typeLongLong
: *(int *)dest
=(int) *(long long *)src
; break;
1898 case typeShort
: *(int *)dest
=(int) *(short *)src
; break;
1899 case typeByteInt
: *(int *)dest
=(int) *(char *)src
; break;
1901 case typeFloat
: *(int *)dest
= (int) *(float *)src
; break;
1902 case typeDouble
: *(int *)dest
=(int) *(double *)src
; break;
1904 case typeString
: sscanf((const char*)src
, "%d", (int*) dest
); break;
1910 default: *(int *)dest
= (int) 0;
1914 void AllDataType::convertToLong( void* dest
, void* src
, DataType srcType
)
1918 case typeInt
: *(long *)dest
=(long) *(int *)src
; break;
1919 case typeLong
: *(long *)dest
= *(long *)src
; break;
1920 case typeLongLong
: *(long *)dest
=(long) *(long long *)src
; break;
1921 case typeShort
: *(long *)dest
=(long) *(short *)src
; break;
1922 case typeByteInt
: *(long *)dest
=(long) *(char *)src
; break;
1924 case typeFloat
: *(long *)dest
= (long) *(float *)src
; break;
1925 case typeDouble
: *(long *)dest
=(long) *(double *)src
; break;
1927 case typeString
: sscanf((const char*)src
, "%ld", (long*) dest
); break;
1933 default: *(long *)dest
= (long) 0;
1938 void AllDataType::convertToLongLong( void* dest
, void* src
, DataType srcType
)
1942 case typeInt
: *(long long *)dest
=(long long) *(int *)src
; break;
1943 case typeLong
: *(long long *)dest
= (long long) *(long *)src
; break;
1944 case typeLongLong
: *(long long *)dest
= *(long long *)src
; break;
1945 case typeShort
: *(long long *)dest
=(long long) *(short *)src
; break;
1946 case typeByteInt
: *(long long *)dest
=(long long) *(char *)src
; break;
1948 case typeFloat
: *(long long *)dest
= (long long) *(float *)src
; break;
1949 case typeDouble
: *(long long *)dest
=(long long) *(double *)src
; break;
1951 case typeString
: sscanf((const char*)src
, "%lld", (long long*) dest
); break;
1957 default: *(long long *)dest
= (long long) 0;
1961 void AllDataType::convertToShort( void* dest
, void* src
, DataType srcType
)
1965 case typeInt
: *(short*)dest
=(short) *(int*)src
; break;
1966 case typeLong
: *(short*)dest
= (short) *(long*)src
; break;
1967 case typeLongLong
: *(short*)dest
= (short) *(long long*)src
; break;
1968 case typeShort
: *(short*)dest
= *(short*)src
; break;
1969 case typeByteInt
: *(short*)dest
=(short) *(char *)src
; break;
1971 case typeFloat
: *(short*)dest
= (short) *(float *)src
; break;
1972 case typeDouble
: *(short*)dest
=(short) *(double *)src
; break;
1974 case typeString
: sscanf((const char*)src
, "%hd", (short*) dest
); break;
1980 default: *(short*)dest
= (short) 0;
1984 void AllDataType::convertToByteInt( void* dest
, void* src
, DataType srcType
)
1988 case typeInt
: *(char*)dest
= (char) *(int*)src
; break;
1989 case typeLong
: *(char*)dest
= (char) *(long*)src
; break;
1990 case typeLongLong
: *(char*)dest
= (char) *(long long*)src
; break;
1991 case typeShort
: *(char*)dest
= (char) *(short*)src
; break;
1992 case typeByteInt
: *(char*)dest
= *(char *)src
; break;
1994 case typeFloat
: *(char*)dest
= (char) *(float *)src
; break;
1995 case typeDouble
: *(char*)dest
=(char) *(double *)src
; break;
1997 case typeString
: sscanf((const char*)src
, "%hhd", (char*) dest
); break;
2003 default: *(char*)dest
= (char) 0;
2007 void AllDataType::convertToFloat( void* dest
, void* src
, DataType srcType
)
2011 case typeInt
: *(float *)dest
=(float) *(int *)src
; break;
2012 case typeLong
: *(float *)dest
=(float) *(long *)src
; break;
2013 case typeLongLong
: *(float *)dest
=(float) *(long long *)src
; break;
2014 case typeShort
: *(float *)dest
=(float) *(short *)src
; break;
2015 case typeByteInt
: *(float *)dest
=(float) *(char *)src
; break;
2017 case typeFloat
: *(float *)dest
= *(float *)src
; break;
2018 case typeDouble
: *(float *)dest
=(float) *(double *)src
; break;
2020 case typeString
: sscanf((const char*)src
, "%f", (float*) dest
); break;
2026 default: *(float *)dest
= (float) 0;
2030 void AllDataType::convertToDouble( void* dest
, void* src
, DataType srcType
)
2034 case typeInt
: *(double *)dest
=(double) *(int *)src
; break;
2035 case typeLong
: *(double *)dest
=(double) *(long *)src
; break;
2036 case typeLongLong
: *(double *)dest
=(double) *(long long *)src
; break;
2037 case typeShort
: *(double *)dest
=(double) *(short *)src
; break;
2038 case typeByteInt
: *(double *)dest
=(double) *(char *)src
; break;
2040 case typeFloat
: *(double *)dest
=(double) *(float *)src
; break;
2041 case typeDouble
: *(double *)dest
= *(double *)src
; break;
2043 case typeString
: sscanf((const char*)src
, "%lf", (double*) dest
); break;
2049 default: *(double *)dest
= (double) 0;
2053 void AllDataType::convertToString( void* dest
, void* src
, DataType srcType
, int length
,TDBInfo tdbname
)
2059 Util::itoa(*(int*)src
, (char*)dest
);
2064 sprintf ((char *)dest
, "%ld", *(long *)src
);
2069 sprintf ((char *)dest
, "%lld", *(long long *)src
);
2074 sprintf ((char *)dest
, "%hd", *(short *)src
);
2079 sprintf ((char *)dest
, "%hhd", *(char *)src
);
2085 sprintf ((char *)dest
, "%f", *(float *)src
);
2090 sprintf ((char *) dest
, "%lf", *(double *)src
);
2096 strcpy((char*)dest
, (char*)src
);
2101 Date
* dt
= (Date
*)src
;
2102 sprintf((char*) dest
, "%d/%d/%d", dt
->year(),dt
->month(), dt
->dayOfMonth());
2107 Time
* tm
= (Time
*)src
;
2108 sprintf((char*)dest
,"%d:%d:%d.%d", tm
->hours(), tm
->minutes(), tm
->seconds(), 0);
2113 TimeStamp
* tm
= (TimeStamp
*)src
;
2114 sprintf((char*)dest
, "%d/%d/%d %d:%d:%d.%d", tm
->year(),tm
->month(), tm
->dayOfMonth(), tm
->hours(),tm
->minutes(), tm
->seconds(), 0 );
2119 unsigned char *c
= (unsigned char *) src
;
2120 unsigned char *str
= (unsigned char *) dest
;
2121 unsigned char p
= 0;
2123 while (i
< length
) {
2125 if (p
< 10) sprintf ((char *)str
++, "%c", '0' + p
);
2126 else sprintf((char *)str
++, "%c", 'A' + p
- 10);
2128 if (p
< 10) sprintf ((char *)str
++, "%c", '0' + p
);
2129 else sprintf((char *)str
++, "%c", 'A' + p
- 10);
2135 default: ((char*)dest
)[0] = '\0';
2139 void AllDataType::convertToDate( void* dest
, void* src
, DataType srcType
)
2156 Date
*dt
= (Date
*) dest
;
2157 dt
->parseFrom((char*)src
);
2160 default: ((char*)dest
)[0] = '\0';
2164 void AllDataType::convertToTime( void* dest
, void* src
, DataType srcType
)
2181 Time
*dt
= (Time
*) dest
;
2182 dt
->parseFrom((char*)src
);
2185 default: ((char*)dest
)[0] = '\0';
2189 void AllDataType::convertToTimeStamp( void* dest
, void* src
, DataType srcType
)
2206 TimeStamp
*dt
= (TimeStamp
*) dest
;
2207 dt
->parseFrom((char*)src
);
2210 default: ((char*)dest
)[0] = '\0';
2214 void AllDataType::convertToBinary(void *dest
, void *src
, DataType srcType
, int length
)
2220 memset ((void *) dest
, 0, length
);
2221 unsigned char c
= 0;
2222 const char *str
= (const char *)src
;
2224 i
= strlen((char*)src
)-1;
2225 if( i
> (length
*2)-1 ){ i
= (length
*2)-1 ; }
2226 bool evenlegth
=false;
2227 if(i
%2){ evenlegth
=true;}
2228 unsigned char *val
= (unsigned char *)dest
+(length
-1);
2231 if (c
<= '9') c
-= '0';
2232 else if (c
>= 'a') c
= c
- 'a' + 10;
2233 else c
= c
- 'A' + 10;
2236 if ((i
+1) % 2) { *val
= *val
| (c
<<4); val
--;}
2239 if (i
% 2) { *val
= *val
| (c
<<4); val
--;}
2248 int AllDataType::printVal(void* src
, DataType srcType
, int length
,int dbFlag
)
2250 //dbFlag is the database flag 0:mysql (default), 1:postgres
2256 count
= printf ("%d", *(int *)src
);
2261 count
= printf ("%ld", *(long *)src
);
2268 convertToLongLong((void*)&temp
, src
,typeString
);
2269 count
= printf ("%lld", temp
);
2271 else count
= printf ("%lld", *(long long *)src
);
2276 count
= printf("%hd", *(short *)src
);
2281 count
= printf("%hhd", *(char *)src
);
2287 count
= printf("%f", *(float *)src
);
2292 if (*(double*)src
> 9999999999999999.0F
)
2293 count
= printf("%g", *(double *)src
);
2295 count
= printf("%lf", *(double *)src
);
2302 count
= printf("%s", (char*)src
);
2307 Date
* dt
= (Date
*)src
;
2308 count
= printf("%d/%d/%d", dt
->year(),
2309 dt
->month(), dt
->dayOfMonth());
2314 Time
* tm
= (Time
*)src
;
2315 count
= printf("%d:%d:%d.%d", tm
->hours(), tm
->minutes(), tm
->seconds(), 0);
2320 TimeStamp
* tm
= (TimeStamp
*)src
;
2321 count
= printf("%d/%d/%d %d:%d:%d.%d", tm
->year(),
2322 tm
->month(), tm
->dayOfMonth(), tm
->hours(),
2323 tm
->minutes(), tm
->seconds(), 0 );
2328 unsigned char *c
= (unsigned char *) src
;
2329 unsigned char p
= 0;
2331 bool isDigitFound
=false;
2332 while (i
< length
) {
2334 if(('0'+p
)!='0'|| isDigitFound
){
2335 if (p
< 10) printf ("%c", '0' + p
);
2336 else printf("%c", 'A' + p
- 10);
2340 if(('0'+p
)!='0' || isDigitFound
){
2341 if (p
< 10) printf ("%c", '0' + p
);
2342 else printf("%c", 'A' + p
- 10);
2350 default: { printf("DataType not supported\n"); break; }