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 ALLREADY_HAVE_WINDOWS_TYPE
26 #define SmallestValJulDate (1721426)
32 Date::Date(int year
, int month
, int day
)
33 { YMDToJulian(year
, month
, day
, julianDate
); }
34 int Date::set(int year
, int month
, int day
)
35 { return YMDToJulian(year
,month
,day
,julianDate
); }
36 int Date::get(int &year
, int &month
, int &day
) const
37 { return julianToYMD(julianDate
,year
,month
,day
); }
39 int Date::parseFrom(const char *s
) {
42 if(strcmp(s
,"now")==0 || strcmp(s
,"NOW")==0){
43 time_t cnow
= ::time(NULL
);
44 #if defined(SOLARIS) && defined(REMOTE_SOLARIS)
45 struct std::tm
*tmval
= (struct std::tm
*) localtime(&cnow
);
46 return set(year
=tmval
->tm_year
+1900, month
=tmval
->tm_mon
+1, day
=tmval
->tm_mday
);
48 struct tm
*tmval
= localtime(&cnow
);
49 return set(year
=tmval
->tm_year
+1900,month
=tmval
->tm_mon
+1,day
=tmval
->tm_mday
);
56 count
= sscanf(s
,"%d-%d-%d",&year
,&month
,&day
);
60 count
= sscanf(s
,"%d/%d/%d",&year
,&month
,&day
);
65 if (count
< 3) return -1;
66 if (year
< 100) year
+= 1900;
67 if (!isValidDate(year
, month
, day
))
69 return set(year
,month
,day
);
73 void Date::changeToCsqlFormat(char *src
)
80 strncpy(dstPtr
, srcPtr
, 4);
84 if(strncasecmp(srcPtr
,"JAN",3) == 0) strncpy(dstPtr
, "01", 2);
85 else if(strncasecmp(srcPtr
,"FEB",3)== 0) strncpy(dstPtr
, "02", 2);
86 else if(strncasecmp(srcPtr
,"MAR",3)== 0) strncpy(dstPtr
, "03", 2);
87 else if(strncasecmp(srcPtr
,"APR",3)== 0) strncpy(dstPtr
, "04", 2);
88 else if(strncasecmp(srcPtr
,"MAY",3)== 0) strncpy(dstPtr
, "05", 2);
89 else if(strncasecmp(srcPtr
,"JUN",3)== 0) strncpy(dstPtr
, "06", 2);
90 else if(strncasecmp(srcPtr
,"JUL",3)== 0) strncpy(dstPtr
, "07", 2);
91 else if(strncasecmp(srcPtr
,"AUG",3)== 0) strncpy(dstPtr
, "08", 2);
92 else if(strncasecmp(srcPtr
,"SEP",3)== 0) strncpy(dstPtr
, "09", 2);
93 else if(strncasecmp(srcPtr
,"OCT",3)== 0) strncpy(dstPtr
, "10", 2);
94 else if(strncasecmp(srcPtr
,"NOV",3)== 0) strncpy(dstPtr
, "11", 2);
95 else if(strncasecmp(srcPtr
,"DEC",3)== 0) strncpy(dstPtr
, "12", 2);
98 strncpy(dstPtr
, src
, 2);
103 void Date::addDay(int noOfDays
)
105 julianDate
= julianDate
+ noOfDays
;
107 void Date::subDay(int noOfDays
)
109 julianDate
= julianDate
- noOfDays
;
112 void Date::addMonth(int noOfMons
)
114 int year
, month
, day
;
123 void Date::subMonth(int noOfMons
)
125 int year
, month
, day
;
129 year
-= (noOfMons
/12);
131 month
-= (noOfMons
%12);
138 void Date::addYear(int noOfYrs
)
140 int year
, month
, day
;
146 void Date::subYear(int noOfYrs
)
148 int year
, month
, day
;
155 int Date::dayOfMonth() const {
156 int year
, month
, day
;
160 int Date::month() const {
161 int year
, month
, day
;
165 int Date::year() const {
166 int year
, month
, day
;
171 int Date::dayOfWeek() const { return dayOfWeek(julianDate
); }
173 const char *Date::dayOfWeekName() const
174 { return dayOfWeekName(dayOfWeek(julianDate
)); }
176 const char *Date::dayOfWeekAbbr() const
177 { return dayOfWeekAbbr(dayOfWeek(julianDate
)); }
179 static const char *day_names
[] = {
180 "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
182 static const char *day_abbrs
[] = {
183 "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
186 static const char *month_names
[] = {
187 "January", "February", "March", "April", "May", "June",
188 "July", "August", "September", "October", "November", "December"
190 static const char *month_abbrs
[] = {
191 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
192 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
196 static int daysBeforeMonth
[] = {
197 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365
199 static int days_per_month
[] = {
200 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
203 const char * Date::dayOfWeekName(int day
)
204 { return (day
< 1 || day
> 7) ? 0 : day_names
[day
-1]; }
206 const char * Date::dayOfWeekAbbr(int day
)
207 { return (day
< 1 || day
> 7) ? 0 : day_abbrs
[day
-1]; }
209 const char * Date::monthName() const { return monthName(month()); }
210 const char * Date::monthAbbr() const { return monthAbbr(month()); }
211 const char * Date::monthName(int month
)
212 { return (month
< 1 || month
> 12) ? 0 : month_names
[month
-1]; }
213 const char * Date::monthAbbr(int month
)
214 { return (month
< 1 || month
> 12) ? 0 : month_abbrs
[month
-1]; }
215 Date
operator+(const Date
&d1
, int days
)
216 { return Date(d1
.julianDate
+ days
); }
217 Date
operator+(int days
, const Date
&d1
)
218 { return Date(d1
.julianDate
+ days
); }
219 Date
operator-(const Date
&d1
, int days
)
220 { return Date(d1
.julianDate
- days
); }
222 int operator-(const Date
&d1
, const Date
& d2
)
223 { 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
; }
231 int operator>=(const Date
&d1
,const Date
&d2
)
232 { return d1
.julianDate
>= d2
.julianDate
; }
233 int operator==(const Date
&d1
,const Date
&d2
)
234 { return d1
.julianDate
== d2
.julianDate
; }
235 int operator!=(const Date
&d1
,const Date
&d2
)
236 { return d1
.julianDate
!= d2
.julianDate
; }
238 bool Date::isValid() const
239 { return julianDate
>= SmallestValJulDate
; }
241 bool Date::isLeapYear(int year
)
243 return (year
% 400 == 0) || ((year
% 4 == 0) && !(year
% 100 == 0));
246 int Date::dayOfYear() const {
249 int tmp
= daysBeforeMonth
[month
-1];
250 if (month
>= 3 && isLeapYear(year
))
255 int Date::daysInMonth(int month
, int year
) {
257 int tmp
= days_per_month
[month
];
258 if (month
== 1 && isLeapYear(year
)) tmp
++;
262 bool Date::isValidDate(int year
, int month
, int day
) {
264 if (year
< 1 || year
> 9999) return false;
265 if (month
< 1 || month
> 12) return false;
266 return (day
>= 1) && (day
<= daysInMonth(month
,year
));
269 // Algorithm Author: Robert G. Tantzen
270 int Date::YMDToJulian(int year
, int mon
, int day
, JulianRep
&jul
) {
271 if (!isValidDate(year
, mon
, day
))
272 { jul
= (JulianRep
)0; return -1; }
274 // year, month, day are assumed to be valid
275 int m
= mon
, d
= day
, y
= year
;
279 else { m
+= 9; --y
; }
282 j
= (146097*c
)/4 + (1461*ya
)/4 + (153*m
+2)/5 + d
+ 1721119;
287 // Julian date converter. Takes a julian date (the number of days since some
288 // distant epoch or other), and returns month, day of month, and year in
289 // integer references.
290 // Algorithm Author: Robert G. Tantzen
291 int Date::dayOfWeek(JulianRep jul
) {
292 return (int)((jul
+1)%7+1);
295 int Date::julianToYMD(JulianRep jul
, int &year
, int &month
, int &day
) {
299 if (j
< SmallestValJulDate
)
300 { year
= month
= day
= 0; return -1; }
303 y
= (4 * j
- 1)/146097;
304 j
= 4 * j
- 1 - 146097 * y
;
306 j
= (4 * d
+ 3)/1461;
307 d
= 4 * d
+ 3 - 1461 * j
;
310 d
= 5 * d
- 3 - 153 * m
;
314 else { m
-= 9; ++y
; }
321 #define MAX_VALID_SECONDS (60 * 60 * 24 -1)
322 Time::Time(int hours
, int mins
, int secs
, int usec
)
323 { set(hours
,mins
,secs
, usec
); }
325 int Time::set(int hours
, int mins
, int secs
, int usec
) {
326 if((hours
| mins
| secs
| usec
) < 0) { timeVal
= -1; return -1; }
327 if(hours
>= 24 | mins
>= 60 | secs
>= 62)
328 { timeVal
= -1; return -1; }
329 timeVal
= secs
+ mins
* 60 + hours
* 3600;
331 if(usec
) timeVal
+= usec
/100;
335 int Time::get(int &hours
, int &mins
, int &secs
) const {
336 if (timeVal
< 0) return -1;
337 int s
= timeVal
/10000;
346 int Time::addSec(int secs
)
348 timeVal
+= (secs
*10000);
349 int quit
= timeVal
/864000000;
350 if(0==quit
) return 0;
351 timeVal
%= 864000000;
355 int Time::subSec(int secs
)
357 timeVal
-= (secs
*10000);
358 int quit
= timeVal
/864000000;
359 if(0==quit
) return 0;
360 timeVal
%= 864000000;
363 int Time::addMin(int mins
)
365 timeVal
+= (mins
* 60 * 10000);
366 int quit
= timeVal
/864000000;
367 if(0==quit
) return 0;
368 timeVal
%= 864000000;
371 int Time::subMin(int mins
)
373 timeVal
-= (mins
* 60 * 10000);
374 int quit
= timeVal
/864000000;
375 if(0==quit
) return 0;
376 timeVal
%= 864000000;
379 int Time::addHour(int hours
)
383 timeVal
+= (hours
* 60 * 60 * 10000);
384 int quit
= day
+(timeVal
/864000000);
385 if(0==quit
) return 0;
386 timeVal
%= 864000000;
389 int Time::subHour(int hours
)
391 timeVal
-= (hours
* 60 * 60 * 10000);
392 int quit
= timeVal
/864000000;
395 if(quit
<0) timeVal
+= ( 864000000 * quit
*(-1) );
396 else timeVal
+=864000000;
398 if(0==quit
) return 0;
399 timeVal
%= 864000000;
403 int Time::seconds() const { return (timeVal
/10000) % 60; }
404 int Time::minutes() const { return (timeVal
/(60*10000)) % 60; }
405 int Time::hours() const { return timeVal
/ (3600*10000); }
406 int Time::msec() const { return (timeVal
% 10000) / 10; }
407 int Time::usec() const { return (timeVal
% 10000) * 100; }
409 int Time::setMsec(int ms
) {
410 if(ms
< 0 || ms
>= 1000) return -1;
411 timeVal
= timeVal
+(10*ms
);
414 int Time::setUsec(int us
) {
415 if(us
< 0 || us
>= 1000000) return -1;
416 timeVal
= timeVal
+us
/100;
420 bool Time::isValid() const
421 { return timeVal
>= 0 && timeVal
<= (10000*(MAX_VALID_SECONDS
+1)-1); }
423 bool Time::isValidTime(int hours
, int mins
, int secs
) {
424 return (hours
>= 0 && hours
< 24) &&
425 (mins
>= 0 && mins
< 60) &&
426 (secs
>= 0 && secs
< 60);
429 Time
operator+(const Time
&t1
, int seconds
)
430 { return Time(t1
.timeVal
+ seconds
*10000); }
431 Time
operator+(int seconds
, const Time
&t1
)
432 { return Time(t1
.timeVal
+ seconds
*10000); }
433 Time
operator-(const Time
&t1
, int seconds
)
434 { return Time(t1
.timeVal
- seconds
*10000); }
436 int operator-(const Time
&t1
, const Time
& t2
)
437 { return (t1
.timeVal
- t2
.timeVal
)/10000; }
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
; }
445 int operator>=(const Time
&t1
,const Time
&t2
)
446 { return t1
.timeVal
>= t2
.timeVal
; }
447 int operator==(const Time
&t1
,const Time
&t2
)
448 { return t1
.timeVal
== t2
.timeVal
; }
449 int operator!=(const Time
&t1
,const Time
&t2
)
450 { return t1
.timeVal
!= t2
.timeVal
; }
452 int Time::parseFrom(const char *s
) {
455 if(strcmp(s
,"now")==0 || strcmp(s
,"NOW")==0){
456 time_t cnow
= ::time(NULL
);
457 #if defined(SOLARIS) && defined(REMOTE_SOLARIS)
458 struct std::tm
*tmval
= (struct std::tm
*) localtime(&cnow
);
459 return set(hours
=tmval
->tm_hour
,mins
=tmval
->tm_min
,secs
=tmval
->tm_sec
);
461 struct tm
*tmval
= localtime(&cnow
);
462 return set(hours
=tmval
->tm_hour
,mins
=tmval
->tm_min
,secs
=tmval
->tm_sec
);
466 count
= sscanf(s
,"%d:%d:%d",&hours
,&mins
,&secs
);
467 if (count
< 2) return -1;
468 if (count
== 2) secs
= 0;
470 if (!isValidTime(hours
,mins
,secs
))
472 return set(hours
,mins
,secs
);
475 int TimeStamp::parseFrom(const char *s
) {
479 if(strcmp(s
,"now")==0 || strcmp(s
,"NOW")==0){
480 time_t cnow
= ::time(NULL
);
481 #if defined(SOLARIS) && defined(REMOTE_SOLARIS)
482 struct std::tm
*tmval
= (struct std::tm
*) localtime(&cnow
);
483 setDate(year
=tmval
->tm_year
+1900,month
=tmval
->tm_mon
+1,day
=tmval
->tm_mday
);
484 return setTime(hours
=tmval
->tm_hour
,mins
=tmval
->tm_min
,secs
=tmval
->tm_sec
);
486 struct tm
*tmval
= localtime(&cnow
);
487 setDate(year
=tmval
->tm_year
+1900,month
=tmval
->tm_mon
+1,day
=tmval
->tm_mday
);
488 return setTime(hours
=tmval
->tm_hour
,mins
=tmval
->tm_min
,secs
=tmval
->tm_sec
);
495 count
= sscanf(s
,"%d-%d-%d %d:%d:%d",&year
,&month
,&day
, &hours
, &mins
, &secs
);
499 count
= sscanf(s
,"%d/%d/%d %d:%d:%d",&year
,&month
,&day
, &hours
, &mins
, &secs
);
504 if (count
< 5) return -1;
505 if (count
== 5) secs
= 0;
506 if (year
< 100) year
+= 1900;
508 if (!date
.isValidDate(year
, month
, day
))
511 setDate(year
,month
,day
);
514 if (!time
.isValidTime(hours
,mins
,secs
))
516 return setTime(hours
,mins
,secs
);
519 void TimeStamp::addHour(int hours
)
521 int day
= time
.addHour(hours
);
522 if(day
!=0){ date
.addDay(day
);}
525 void TimeStamp::subHour(int hours
)
527 int day
= time
.subHour(hours
);
528 if(day
!=0){ date
.subDay(day
);}
531 void TimeStamp::addMin(int noOfMins
)
533 int day
= time
.addMin(noOfMins
);
534 if(day
!=0){ date
.addDay(day
);}
537 void TimeStamp::subMin(int noOfMins
)
539 int day
= time
.subMin(noOfMins
);
540 if(day
!=0) {date
.subDay(day
);}
542 void TimeStamp::addSec(int noOfSecs
)
544 int day
= time
.addSec(noOfSecs
);
545 if(day
!=0){ date
.addDay(day
);}
547 void TimeStamp::subSec(int noOfSecs
)
549 int day
= time
.subSec(noOfSecs
);
550 if(day
!=0){ date
.subDay(day
);}
553 int TimeStamp::secDiff(TimeStamp
&ts
)
555 int day1
= date
.getCalDay();
556 int day2
= Date(ts
).getCalDay();
557 int sec1
= time
.getCalSec();
558 int sec2
= Time(ts
).getCalSec();
559 return (((day1
*24*60*60)+sec1
) - ((day2
*24*60*60)+sec2
));
561 int TimeStamp::minDiff(TimeStamp
&ts
)
563 int day1
= date
.getCalDay();
564 int day2
= Date(ts
).getCalDay();
565 int sec1
= time
.getCalSec();
566 int sec2
= Time(ts
).getCalSec();
567 int secdiff
= (((day1
*24*60*60)+sec1
) - ((day2
*24*60*60)+sec2
));
572 int TimeStamp::hourDiff(TimeStamp
&ts
)
574 int day1
= date
.getCalDay();
575 int day2
= Date(ts
).getCalDay();
576 int sec1
= time
.getCalSec();
577 int sec2
= Time(ts
).getCalSec();
578 int secdiff
= (((day1
*24*60*60)+sec1
) - ((day2
*24*60*60)+sec2
));
579 return (secdiff
/3600);
582 int TimeStamp::dayDiff(TimeStamp
&ts
)
584 int day1
= date
.getCalDay();
585 int day2
= Date(ts
).getCalDay();
586 int sec1
= time
.getCalSec();
587 int sec2
= Time(ts
).getCalSec();
588 int secdiff
= (((day1
*24*60*60)+sec1
) - ((day2
*24*60*60)+sec2
));
589 return (secdiff
/(3600*24));
593 int TimeStamp::monthDiff(TimeStamp
&ts
)
595 int day1
= date
.getCalDay();
596 int day2
= Date(ts
).getCalDay();
597 int sec1
= time
.getCalSec();
598 int sec2
= Time(ts
).getCalSec();
599 int secdiff
= (((day1
*24*60*60)+sec1
) - ((day2
*24*60*60)+sec2
));
600 return (secdiff
/(3600*24*30));
603 int TimeStamp::yearDiff(TimeStamp
&ts
)
605 int day1
= date
.getCalDay();
606 int day2
= Date(ts
).getCalDay();
607 int sec1
= time
.getCalSec();
608 int sec2
= Time(ts
).getCalSec();
609 int secdiff
= (((day1
*24*60*60)+sec1
) - ((day2
*24*60*60)+sec2
));
610 return (secdiff
/(3600*24*30*12));
612 void TimeStamp::changeToCsqlFormat(char *src
)
619 strncpy(dstPtr
, srcPtr
, 4);
623 if(strncasecmp(srcPtr
,"JAN",3) == 0) strncpy(dstPtr
, "01", 2);
624 else if(strncasecmp(srcPtr
,"FEB",3)== 0) strncpy(dstPtr
, "02", 2);
625 else if(strncasecmp(srcPtr
,"MAR",3)== 0) strncpy(dstPtr
, "03", 2);
626 else if(strncasecmp(srcPtr
,"APR",3)== 0) strncpy(dstPtr
, "04", 2);
627 else if(strncasecmp(srcPtr
,"MAY",3)== 0) strncpy(dstPtr
, "05", 2);
628 else if(strncasecmp(srcPtr
,"JUN",3)== 0) strncpy(dstPtr
, "06", 2);
629 else if(strncasecmp(srcPtr
,"JUL",3)== 0) strncpy(dstPtr
, "07", 2);
630 else if(strncasecmp(srcPtr
,"AUG",3)== 0) strncpy(dstPtr
, "08", 2);
631 else if(strncasecmp(srcPtr
,"SEP",3)== 0) strncpy(dstPtr
, "09", 2);
632 else if(strncasecmp(srcPtr
,"OCT",3)== 0) strncpy(dstPtr
, "10", 2);
633 else if(strncasecmp(srcPtr
,"NOV",3)== 0) strncpy(dstPtr
, "11", 2);
634 else if(strncasecmp(srcPtr
,"DEC",3)== 0) strncpy(dstPtr
, "12", 2);
637 strncpy(dstPtr
, src
, 2);
640 strncpy(dstPtr
, srcPtr
, 9);
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
.date
> d2
.date
: d1
.time
> d2
.time
; }
649 int operator<=(const TimeStamp
&d1
, const TimeStamp
&d2
)
650 { return (d1
.date
!= d2
.date
) ? d1
.date
< d2
.date
: d1
.time
<= d2
.time
; }
651 int operator>=(const TimeStamp
&d1
, const TimeStamp
&d2
)
652 { return (d1
.date
!= d2
.date
) ? d1
.date
> d2
.date
: d1
.time
>= d2
.time
; }
653 int operator==(const TimeStamp
&d1
, const TimeStamp
&d2
)
654 { return d1
.date
== d2
.date
&& d1
.time
== d2
.time
; }
655 int operator!=(const TimeStamp
&d1
, const TimeStamp
&d2
)
656 { return d1
.date
!= d2
.date
|| d1
.time
!= d2
.time
; }
658 DataType
AllDataType::getCsqlTypeFromFunctionType(FunctionType type
)
662 case DATEDIFF
: return typeDate
;
663 case TIMEDIFF
: return typeTime
;
664 case DATEADDWITHYEAR
:
667 case DATESUBWITHYEAR
:
670 case TIMEADDWITHHOUR
:
673 case TIMESUBWITHHOUR
:
675 case TIMESUBWITHSEC
: return typeInt
;
676 case TIMESTAMPADDWITHYEAR
:
677 case TIMESTAMPADDWITHMON
:
678 case TIMESTAMPADDWITHDAY
:
679 case TIMESTAMPSUBWITHYEAR
:
680 case TIMESTAMPSUBWITHMON
:
681 case TIMESTAMPSUBWITHDAY
:
682 case TIMESTAMPADDWITHHOUR
:
683 case TIMESTAMPADDWITHMIN
:
684 case TIMESTAMPADDWITHSEC
:
685 case TIMESTAMPSUBWITHHOUR
:
686 case TIMESTAMPSUBWITHMIN
:
687 case TIMESTAMPSUBWITHSEC
: return typeInt
;
688 case TIMESTAMPDIFFYEAR
:
689 case TIMESTAMPDIFFMON
:
690 case TIMESTAMPDIFFDAY
:
691 case TIMESTAMPDIFFHOUR
:
692 case TIMESTAMPDIFFMIN
:
693 case TIMESTAMPDIFFSEC
: return typeTimeStamp
;
694 case EXTRACTYEARFROMDAY
:
695 case EXTRACTMONFROMDAY
:
696 case EXTRACTDAYFROMDAY
:return typeDate
;
697 case EXTRACTHOURFROMTIME
:
698 case EXTRACTMINFROMTIME
:
699 case EXTRACTSECFROMTIME
: return typeTime
;
700 case EXTRACTYEARFROMTIMESTAMP
:
701 case EXTRACTMONFROMTIMESTAMP
:
702 case EXTRACTDAYFROMTIMESTAMP
:
703 case EXTRACTHOURFROMTIMESTAMP
:
704 case EXTRACTMINFROMTIMESTAMP
:
705 case EXTRACTSECFROMTIMESTAMP
: return typeTimeStamp
;
706 case DATEFROMTIMESTAMP
: return typeTimeStamp
;
707 case TIMEFROMTIMESTAMP
: return typeTimeStamp
;
708 default: return typeInt
;
711 DataType
AllDataType::getCsqlTypeFromFunctionTypeForComparision(FunctionType type
)
715 case DATEDIFF
: return typeInt
;
716 case DATEADDWITHYEAR
: return typeDate
;
717 case DATEADDWITHMON
: return typeDate
;
718 case DATEADDWITHDAY
: return typeDate
;
719 case DATESUBWITHYEAR
: return typeDate
;
720 case DATESUBWITHMON
: return typeDate
;
721 case DATESUBWITHDAY
: return typeDate
;
722 case TIMEDIFF
: return typeInt
;
723 case TIMEADDWITHHOUR
: return typeTime
;
724 case TIMEADDWITHMIN
: return typeTime
;
725 case TIMEADDWITHSEC
: return typeTime
;
726 case TIMESUBWITHHOUR
: return typeTime
;
727 case TIMESUBWITHMIN
: return typeTime
;
728 case TIMESUBWITHSEC
: return typeTime
;
729 case TIMESTAMPADDWITHYEAR
: return typeTimeStamp
;
730 case TIMESTAMPADDWITHMON
: return typeTimeStamp
;
731 case TIMESTAMPADDWITHDAY
: return typeTimeStamp
;
732 case TIMESTAMPSUBWITHYEAR
: return typeTimeStamp
;
733 case TIMESTAMPSUBWITHMON
: return typeTimeStamp
;
734 case TIMESTAMPSUBWITHDAY
: return typeTimeStamp
;
735 case TIMESTAMPADDWITHHOUR
: return typeTimeStamp
;
736 case TIMESTAMPADDWITHMIN
: return typeTimeStamp
;
737 case TIMESTAMPADDWITHSEC
: return typeTimeStamp
;
738 case TIMESTAMPSUBWITHHOUR
: return typeTimeStamp
;
739 case TIMESTAMPSUBWITHMIN
: return typeTimeStamp
;
740 case TIMESTAMPSUBWITHSEC
: return typeTimeStamp
;
741 case TIMESTAMPDIFFYEAR
:
742 case TIMESTAMPDIFFMON
:
743 case TIMESTAMPDIFFDAY
:
744 case TIMESTAMPDIFFHOUR
:
745 case TIMESTAMPDIFFMIN
:
746 case TIMESTAMPDIFFSEC
:
747 case EXTRACTYEARFROMDAY
:
748 case EXTRACTMONFROMDAY
:
749 case EXTRACTDAYFROMDAY
:
750 case EXTRACTHOURFROMTIME
:
751 case EXTRACTMINFROMTIME
:
752 case EXTRACTSECFROMTIME
:
753 case EXTRACTYEARFROMTIMESTAMP
:
754 case EXTRACTMONFROMTIMESTAMP
:
755 case EXTRACTDAYFROMTIMESTAMP
:
756 case EXTRACTHOURFROMTIMESTAMP
:
757 case EXTRACTMINFROMTIMESTAMP
:
758 case EXTRACTSECFROMTIMESTAMP
:return typeInt
;
759 case DATEFROMTIMESTAMP
: return typeDate
;
760 case TIMEFROMTIMESTAMP
: return typeTime
;
761 default: return typeInt
;
766 char* AllDataType::getSQLString(DataType type
)
770 case typeInt
: return "INT";
771 case typeLong
: return "INT";
772 case typeLongLong
: return "BIGINT";
773 case typeShort
: return "SMALLINT";
774 case typeByteInt
: return "TINYINT";
775 case typeDouble
: return "REAL";
776 case typeFloat
: return "FLOAT";
777 case typeDate
: return "DATE";
778 case typeTime
: return "TIME";
779 case typeTimeStamp
: return "TIMESTAMP";
780 case typeString
: return "CHAR";
781 case typeVarchar
: return "VARCHAR";
782 case typeBinary
: return "BINARY";
783 default: return "UNKNOWN";
788 short AllDataType::convertToSQLType(DataType type
)
812 return SQL_TYPE_DATE
;
814 return SQL_TYPE_TIME
;
816 return SQL_TYPE_TIMESTAMP
;
826 SQLSMALLINT
AllDataType::convertToCSQLSQLType(DataType type
)
850 return SQL_TYPE_DATE
;
852 return SQL_TYPE_TIME
;
854 return SQL_TYPE_TIMESTAMP
;
865 SQLSMALLINT
AllDataType::convertToSQL_C_Type(DataType type
,TDBInfo tdbname
)
875 if(tdbname
== postgres
)
878 return SQL_C_SBIGINT
;
883 return SQL_C_STINYINT
;
892 return SQL_C_TYPE_DATE
;
894 return SQL_C_TYPE_TIME
;
896 return SQL_C_TYPE_TIMESTAMP
;
906 DataType
AllDataType::convertFromSQLType(SQLSMALLINT type
,int length
,int scale
,TDBInfo tdbname
)
908 if(tdbname
==postgres
)
927 case SQL_TYPE_TIMESTAMP
:
928 return typeTimeStamp
;
931 case SQL_LONGVARCHAR
:
959 case SQL_TYPE_TIMESTAMP
:
960 return typeTimeStamp
;
963 case SQL_LONGVARCHAR
:
972 void AllDataType::subVal(void* dest
, void *src
, DataType type
)
977 *(int*)dest
= *(int*)dest
- *(int*)src
;
980 *(long*)dest
= *(long*)dest
- *(long*)src
;
983 *(long long*)dest
= *(long long*)dest
- *(long long*)src
;
986 *(short*)dest
= *(short*)dest
- *(short*)src
;
989 *(char*)dest
= *(char*)dest
- *(char*)src
;
992 *(double*)dest
= *(double*)dest
- *(double*)src
;
995 *(float*)dest
= *(float*)dest
- *(float*)src
;
1007 void AllDataType::mulVal(void* dest
, void *src
, DataType type
)
1012 *(int*)dest
= *(int*)dest
* (*(int*)src
);
1015 *(long*)dest
= *(long*)dest
* (*(long*)src
);
1018 *(long long*)dest
= *(long long*)dest
* (*(long long*)src
);
1021 *(short*)dest
= *(short*)dest
* (*(short*)src
);
1024 *(char*)dest
= *(char*)dest
* (*(char*)src
);
1027 *(double*)dest
= *(double*)dest
* (*(double*)src
);
1030 *(float*)dest
= *(float*)dest
* (*(float*)src
);
1042 void AllDataType::mudVal(void* dest
, void *src
, DataType type
)
1044 if (type
== typeInt
)
1046 *(int*)dest
= *(int*)dest
% (*(int*)src
);
1052 *(int*)dest
= *(int*)dest
% (*(int*)src
);
1055 *(long*)dest
= *(long*)dest
% (*(long*)src
);
1058 *(long long*)dest
= *(long long*)dest
% (*(long long*)src
);
1061 *(short*)dest
= *(short*)dest
% (*(short*)src
);
1064 *(char*)dest
= *(char*)dest
% (*(char*)src
);
1067 *(double*)dest
= *(long long*)dest
% (*(long long*)src
);
1070 *(float*)dest
= *(int*)dest
% (*(int*)src
);
1082 void AllDataType::divVal(void* dest
, void *src
, DataType type
)
1084 if (type
== typeInt
)
1086 *(int*)dest
= *(int*)dest
/ (*(int*)src
);
1092 *(int*)dest
= *(int*)dest
/ (*(int*)src
);
1095 *(long*)dest
= *(long*)dest
/ (*(long*)src
);
1098 *(long long*)dest
= *(long long*)dest
/ (*(long long*)src
);
1101 *(short*)dest
= *(short*)dest
/ (*(short*)src
);
1104 *(char*)dest
= *(char*)dest
/ (*(char*)src
);
1107 *(double*)dest
= *(double *)dest
/ (*(double*)src
);
1110 *(float*)dest
= *(float*)dest
/ (*(float*)src
);
1122 void AllDataType::divVal(double* dest
, int src
, DataType type
)
1134 *dest
= *dest
/ src
;
1147 void AllDataType::increment(void* dest
, void *src
, DataType type
)
1152 *(int*)dest
= *(int*)src
+ 1;
1155 *(long*)dest
= *(long*)src
+ 1;
1158 *(long long*)dest
= *(long long*)src
+ 1;
1161 *(char*)dest
= *(char*)src
+ 1;
1164 *(short*)dest
= *(short*)src
+ 1;
1167 *(double*)dest
= *(double*)src
+ 1;
1170 *(float*)dest
= *(float*)src
+ 1;
1177 bool AllDataType::isValueZero(void *src
, DataType type
)
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;
1194 if (*(int*)src
== 0) return true;
1197 if (*(int*)src
== 0) return true;
1205 bool AllDataType::compareIntVal(void* src1
, void *src2
, ComparisionOp op
)
1207 printf("This function should never be called by anyone\n");
1208 if (OpEquals
== op
) {
1209 if (*(int*)src1
== *(int*)src2
) return true;
1211 }else if (OpGreaterThan
== op
) {
1212 if (*(int*)src1
> *(int*)src2
) return true;
1214 }else if (OpLessThan
== op
) {
1215 if (*(int*)src1
< *(int*)src2
) return true;
1217 }else if (OpLessThanEquals
== op
) {
1218 if (*(int*)src1
<= *(int*)src2
) return true;
1220 }else if (OpGreaterThanEquals
== op
) {
1221 if (*(int*)src1
>= *(int*)src2
) return true;
1223 }else if (OpNotEquals
== op
) {
1224 if (*(int*)src1
!= *(int*)src2
) return true;
1230 bool AllDataType::compareLongVal(void* src1
, void *src2
, ComparisionOp op
)
1232 bool result
= false;
1236 if (*(long*)src1
== *(long*)src2
) result
= true;
1237 else result
= false;
1240 if (*(long*)src1
!= *(long*)src2
) result
= true;
1241 else result
= false;
1244 if (*(long*)src1
< *(long*)src2
) result
= true;
1245 else result
= false;
1247 case OpLessThanEquals
:
1248 if (*(long*)src1
<= *(long*)src2
) result
= true;
1249 else result
= false;
1252 if (*(long*)src1
> *(long*)src2
) result
= true;
1253 else result
= false;
1255 case OpGreaterThanEquals
:
1256 if (*(long*)src1
>= *(long*)src2
) result
= true;
1257 else result
= false;
1263 bool AllDataType::compareLongLongVal(void* src1
, void *src2
,
1266 bool result
= false;
1270 if (*(long long*)src1
== *(long long*)src2
) result
= true;
1271 else result
= false;
1274 if (*(long long*)src1
!= *(long long*)src2
) result
= true;
1275 else result
= false;
1278 if (*(long long*)src1
< *(long long*)src2
) result
= true;
1279 else result
= false;
1281 case OpLessThanEquals
:
1282 if (*(long long*)src1
<= *(long long*)src2
) result
= true;
1283 else result
= false;
1286 if (*(long long*)src1
> *(long long*)src2
) result
= true;
1287 else result
= false;
1289 case OpGreaterThanEquals
:
1290 if (*(long long*)src1
>= *(long long*)src2
) result
= true;
1291 else result
= false;
1297 bool AllDataType::compareShortVal(void* src1
, void *src2
, ComparisionOp op
)
1299 bool result
= false;
1303 if (*(short*)src1
== *(short*)src2
) result
= true;
1304 else result
= false;
1307 if (*(short*)src1
!= *(short*)src2
) result
= true;
1308 else result
= false;
1311 if (*(short*)src1
< *(short*)src2
) result
= true;
1312 else result
= false;
1314 case OpLessThanEquals
:
1315 if (*(short*)src1
<= *(short*)src2
) result
= true;
1316 else result
= false;
1319 if (*(short*)src1
> *(short*)src2
) result
= true;
1320 else result
= false;
1322 case OpGreaterThanEquals
:
1323 if (*(short*)src1
>= *(short*)src2
) result
= true;
1324 else result
= false;
1330 bool AllDataType::compareByteIntVal(void* src1
, void *src2
, ComparisionOp op
)
1332 bool result
= false;
1336 if (*(ByteInt
*)src1
== *(ByteInt
*)src2
) result
= true;
1337 else result
= false;
1340 if (*(ByteInt
*)src1
!= *(ByteInt
*)src2
) result
= true;
1341 else result
= false;
1344 if (*(ByteInt
*)src1
< *(ByteInt
*)src2
) result
= true;
1345 else result
= false;
1347 case OpLessThanEquals
:
1348 if (*(ByteInt
*)src1
<= *(ByteInt
*)src2
) result
= true;
1349 else result
= false;
1352 if (*(ByteInt
*)src1
> *(ByteInt
*)src2
) result
= true;
1353 else result
= false;
1355 case OpGreaterThanEquals
:
1356 if (*(ByteInt
*)src1
>= *(ByteInt
*)src2
) result
= true;
1357 else result
= false;
1363 bool AllDataType::compareDoubleVal(void* src1
, void *src2
, ComparisionOp op
)
1365 bool result
= false;
1369 if (*(double*)src1
== *(double*)src2
) result
= true;
1370 else result
= false;
1373 if (*(double*)src1
!= *(double*)src2
) result
= true;
1374 else result
= false;
1377 if (*(double*)src1
< *(double*)src2
) result
= true;
1378 else result
= false;
1380 case OpLessThanEquals
:
1381 if (*(double*)src1
<= *(double*)src2
) result
= true;
1382 else result
= false;
1385 if (*(double*)src1
> *(double*)src2
) result
= true;
1386 else result
= false;
1388 case OpGreaterThanEquals
:
1389 if (*(double*)src1
>= *(double*)src2
) result
= true;
1390 else result
= false;
1396 bool AllDataType::compareFloatVal(void* src1
, void *src2
, ComparisionOp op
)
1398 bool result
= false;
1402 if (*(float*)src1
== *(float*)src2
) result
= true;
1403 else result
= false;
1406 if (*(float*)src1
!= *(float*)src2
) result
= true;
1407 else result
= false;
1410 if (*(float*)src1
< *(float*)src2
) result
= true;
1411 else result
= false;
1413 case OpLessThanEquals
:
1414 if (*(float*)src1
<= *(float*)src2
) result
= true;
1415 else result
= false;
1418 if (*(float*)src1
> *(float*)src2
) result
= true;
1419 else result
= false;
1421 case OpGreaterThanEquals
:
1422 if (*(float*)src1
>= *(float*)src2
) result
= true;
1423 else result
= false;
1429 bool AllDataType::compareDateVal(void* src1
, void *src2
, ComparisionOp op
)
1431 bool result
= false;
1435 if (*(Date
*)src1
== *(Date
*)src2
) result
= true;
1436 else result
= false;
1439 if (*(Date
*)src1
!= *(Date
*)src2
) result
= true;
1440 else result
= false;
1443 if (*(Date
*)src1
< *(Date
*)src2
) result
= true;
1444 else result
= false;
1446 case OpLessThanEquals
:
1447 if (*(Date
*)src1
<= *(Date
*)src2
) result
= true;
1448 else result
= false;
1451 if (*(Date
*)src1
> *(Date
*)src2
) result
= true;
1452 else result
= false;
1454 case OpGreaterThanEquals
:
1455 if (*(Date
*)src1
>= *(Date
*)src2
) result
= true;
1456 else result
= false;
1462 bool AllDataType::compareTimeVal(void* src1
, void *src2
, ComparisionOp op
)
1464 bool result
= false;
1468 if (*(Time
*)src1
== *(Time
*)src2
) result
= true;
1469 else result
= false;
1472 if (*(Time
*)src1
!= *(Time
*)src2
) result
= true;
1473 else result
= false;
1476 if (*(Time
*)src1
< *(Time
*)src2
) result
= true;
1477 else result
= false;
1479 case OpLessThanEquals
:
1480 if (*(Time
*)src1
<= *(Time
*)src2
) result
= true;
1481 else result
= false;
1484 if (*(Time
*)src1
> *(Time
*)src2
) result
= true;
1485 else result
= false;
1487 case OpGreaterThanEquals
:
1488 if (*(Time
*)src1
>= *(Time
*)src2
) result
= true;
1489 else result
= false;
1495 bool AllDataType::compareTimeStampVal(void* src1
, void *src2
, ComparisionOp op
)
1497 bool result
= false;
1501 if (*(TimeStamp
*)src1
== *(TimeStamp
*)src2
) result
= true;
1502 else result
= false;
1505 if (*(TimeStamp
*)src1
!= *(TimeStamp
*)src2
) result
= true;
1506 else result
= false;
1509 if (*(TimeStamp
*)src1
< *(TimeStamp
*)src2
) result
= true;
1510 else result
= false;
1512 case OpLessThanEquals
:
1513 if (*(TimeStamp
*)src1
<= *(TimeStamp
*)src2
) result
= true;
1514 else result
= false;
1517 if (*(TimeStamp
*)src1
> *(TimeStamp
*)src2
) result
= true;
1518 else result
= false;
1520 case OpGreaterThanEquals
:
1521 if (*(TimeStamp
*)src1
>= *(TimeStamp
*)src2
) result
= true;
1522 else result
= false;
1528 bool AllDataType::compareStringVal(void* src1
, void *src2
, ComparisionOp op
)
1530 if (OpEquals
== op
) {
1531 if (strcmp((char*)src1
, (char*)src2
) ==0) return true;
1533 }else if (OpGreaterThan
== op
) {
1534 if (strcmp((char*)src1
, (char*)src2
) >0) return true;
1536 }else if (OpLessThan
== op
) {
1537 if (strcmp((char*)src1
, (char*)src2
) <0 ) return true;
1539 }else if (OpLessThanEquals
== op
) {
1540 // printf("Illegal Operator:Not Supported for String\n");
1542 if (strcmp((char*)src1
, (char*)src2
)<= 0) return true;
1544 }else if (OpGreaterThanEquals
== op
) {
1545 // printf("Illegal Operator:Not Supported for String\n");
1547 if (strcmp((char*)src1
, (char*)src2
) >=0) return true;
1549 }else if (OpNotEquals
== op
) {
1550 if (strcmp((char*)src1
, (char*)src2
) != 0) return true;
1552 }else if (OpLike
== op
) {
1553 return !os::strmatch((char*)src2
, (char*)src1
);
1555 printf("Illegeal Operator:Not supported for String\n");
1559 bool AllDataType::compareBinaryVal(void* src1
, void *src2
,
1560 ComparisionOp op
, int length
)
1562 bool result
= false;
1563 int ret
= os::memcmp(src1
, src2
, length
);
1567 if (ret
== 0 ) result
= true; else result
= false;
1570 if (ret
!= 0 ) result
= true; else result
= false;
1573 if (ret
< 0 ) result
= true; else result
= false;
1575 case OpLessThanEquals
:
1576 printf("Illegal Operator:Not Supported for Binary\n");
1579 if (ret
> 0 ) result
= true; else result
= false;
1581 case OpGreaterThanEquals
:
1582 printf("Illegal Operator:Not Supported for Binary\n");
1588 void* AllDataType::alloc(DataType type
, int length
)
1594 dest
= malloc(sizeof(int));
1597 dest
= malloc(sizeof(long));
1600 dest
= malloc(sizeof(long long));
1603 dest
= malloc(sizeof(short));
1606 dest
= malloc(sizeof(char));
1609 dest
= malloc(sizeof(double));
1612 dest
= malloc(sizeof(float));
1616 //fldDef.length_ = sizeof(long double);
1620 if (length
== 0 ) return NULL
;
1621 dest
= malloc(length
);
1624 if (length
== 0 || length
> 512) return NULL
;
1625 dest
= malloc(length
);
1626 memset(dest
, 0, length
);
1629 dest
= malloc(sizeof(Date
));
1632 dest
= malloc(sizeof(Time
));
1635 dest
= malloc(sizeof(TimeStamp
));
1641 void AllDataType::memoryset(void *value
,DataType type
)
1646 value
= ::memset(value
, 0, sizeof(int));
1649 value
= ::memset(value
, 0, sizeof(long));
1652 value
=::memset(value
, 0, sizeof(long long));
1655 value
= ::memset(value
, 0, sizeof(short));
1658 value
= ::memset(value
, 0, sizeof(char));
1661 value
= ::memset(value
, 0, sizeof(double));
1664 value
= ::memset(value
, 0, sizeof(float));
1670 *(char*)value
= '\0';
1671 //if (length == 0 ) return NULL;
1672 //dest = malloc(length);
1675 /* if (length == 0 || length > 256 ) return NULL;
1677 memset(dest, 0, length);*/
1680 value
= ::memset(value
, 0, sizeof(Date
));
1683 value
= ::memset(value
, 0, sizeof(Time
));
1686 value
= ::memset(value
, 0, sizeof(TimeStamp
));
1694 DbRetVal
AllDataType::strToValue(void* dest
, char *src
, DataType type
, int length
)
1702 sscanf( src
, "%d", &val
);
1707 sscanf( src
, "%ld", &val
);
1710 case typeLongLong
: {
1712 sscanf( src
, "%lld", &val
);
1713 *(long long*)dest
= val
;
1717 sscanf( src
, "%hd", &val
);
1718 *(short*)dest
= val
;
1722 sscanf( src
, "%hhd", &val
);
1723 *(char*)dest
= *(char *)&val
;
1727 sscanf( src
, "%lg", &val
);
1728 *(double*)dest
= val
;
1732 sscanf( src
, "%f", &val
);
1733 *(float*)dest
= val
;
1739 strncpy((char*)dest
, (char*)src
, length
);
1740 char *d
=(char*)dest
;
1745 if (strlen(src
) == 11) {
1746 if ( src
[6] == '-' || src
[6] == '/' ) {
1747 Date::changeToCsqlFormat(src
);
1750 res
= sscanf( src
, "%d-%d-%d", &y
, &m
, &d
);
1752 res
= sscanf( src
, "%d/%d/%d", &y
, &m
, &d
);
1753 if (strcmp(src
,"now")==0 || strcmp(src
,"NOW")==0){
1754 Date
*dt
= (Date
*) dest
;
1755 dt
->parseFrom((char*)src
);
1760 fprintf(stderr
,"Error reading date. yyyy{-/}mm{-/}dd is the valid format.");
1763 /* Looking up at ranges of year-month-day */
1764 if(!date
.isValidDate(y
, m
, d
)){
1765 fprintf(stderr
,"Error reading date. The value \"%d-%d-%d\" is inappropriate.",y
,m
,d
);
1769 Date
dateObj(y
,m
,d
);
1770 *(Date
*)dest
= dateObj
;
1774 res
= sscanf( src
, "%d:%d:%d", &h
, &m
, &s
);
1775 if(strcmp(src
,"now")==0 || strcmp(src
,"NOW")==0){
1776 Time
*dt
= (Time
*) dest
;
1777 dt
->parseFrom((char*)src
);
1783 res
= sscanf( src
, "%d-%d-%d %d:%d:%d", &y
, &mn
, &d
, &h
, &m
, &s
);
1785 fprintf(stderr
, "Error reading time, hh:mm:ss is the valid format.");
1791 if(!time
.isValidTime(h
, m
, s
)){
1792 fprintf(stderr
,"Error reading Time. The value \"%d-%d-%d\" is inappropriate.",h
,m
,s
);
1796 Time
timeObj(h
,m
,s
);
1797 *(Time
*)dest
= timeObj
;
1799 case typeTimeStamp
: {
1800 int d
,m
,y
, h
,mn
,s
, res
=0;
1801 bool isNow
= ( strcasecmp(src
,"now")==0 );
1802 if(!isNow
&& isalpha(int(src
[5]))) {
1803 TimeStamp::changeToCsqlFormat(src
);
1805 res
= sscanf( src
, "%d-%d-%d %d:%d:%d", &y
, &m
, &d
, &h
, &mn
, &s
);
1807 res
= sscanf( src
, "%d-%d-%d, %d:%d:%d", &y
, &m
, &d
, &h
, &mn
, &s
);
1809 res
= sscanf( src
, "%d/%d/%d %d:%d:%d", &y
, &m
, &d
, &h
, &mn
, &s
);
1811 res
= sscanf( src
, "%d/%d/%d, %d:%d:%d", &y
, &m
, &d
, &h
, &mn
, &s
);
1814 TimeStamp
*dt
= (TimeStamp
*) dest
;
1815 dt
->parseFrom((char*)src
);
1820 fprintf(stderr
, "Error reading timestamp, yyyy{-/}mm{-/}dd[,] hh:mm:ss is the valid format.");
1824 /* Looking up at 'YY-MM-DD' */
1825 if(!date
.isValidDate(y
, m
, d
)){
1826 fprintf(stderr
,"Error reading date. The value \"%d-%d-%d\" is inappropriate.",y
,m
,d
);
1830 /* Looking up at 'Hour-Min-Sec' */
1831 if(!time
.isValidTime(h
, m
, s
)){
1832 fprintf(stderr
,"Error reading Time. The value \"%d-%d-%d\" is inappropriate.",h
,m
,s
);
1836 TimeStamp
timeStampObj(y
,m
,d
,h
,mn
,s
);
1837 *(TimeStamp
*)dest
= timeStampObj
;
1840 memset ((void *) dest
, 0, length
);
1841 unsigned char c
= 0;
1842 const char *str
= (const char *)src
;
1845 if( i
> (length
*2)-1 ){ i
= (length
*2)-1 ; }
1846 bool evenlegth
=false;
1847 if(i
%2){ evenlegth
=true;}
1848 unsigned char *val
= (unsigned char *)dest
+(length
-1);
1851 if (!isxdigit((int)c
)) {
1852 printError(ErrBadArg
, "Invalid hexadecimal value");
1855 if (c
<= '9') c
-= '0';
1856 else if (c
>= 'a') c
= c
- 'a' + 10;
1857 else c
= c
- 'A' + 10;
1860 if ((i
+1) % 2) { *val
= *val
| (c
<<4); val
--;}
1863 if (i
% 2) { *val
= *val
| (c
<<4); val
--;}
1877 void AllDataType::convert(DataType srcType
, void *src
,
1878 DataType destType
, void *dest
, int length
)
1880 switch ((DataType
) destType
)
1882 case typeInt
: convertToInt(dest
, src
, srcType
); break;
1883 case typeLong
: convertToLong(dest
, src
, srcType
); break;
1884 case typeLongLong
: convertToLongLong(dest
, src
, srcType
); break;
1885 case typeShort
: convertToShort(dest
, src
, srcType
); break;
1886 case typeByteInt
: convertToByteInt(dest
, src
, srcType
); break;
1888 case typeFloat
: convertToFloat(dest
, src
, srcType
); break;
1889 case typeDouble
: convertToDouble(dest
, src
, srcType
); break;
1892 case typeDecimal
: convertToDouble(dest
, src
, srcType
); break;
1894 case typeString
: convertToString(dest
, src
, srcType
); break;
1895 case typeBinary
: convertToBinary(dest
, src
, srcType
,length
); break;
1896 case typeDate
: convertToDate(dest
, src
, srcType
); break;
1897 case typeTime
: convertToTime(dest
, src
, srcType
); break;
1898 case typeTimeStamp
: convertToTimeStamp(dest
, src
, srcType
); break;
1903 void AllDataType::convertToInt( void* dest
, void* src
, DataType srcType
)
1907 case typeInt
: *(int *)dest
= *(int *)src
; break;
1908 case typeLong
: *(int *)dest
=(int) *(long *)src
; break;
1909 case typeLongLong
: *(int *)dest
=(int) *(long long *)src
; break;
1910 case typeShort
: *(int *)dest
=(int) *(short *)src
; break;
1911 case typeByteInt
: *(int *)dest
=(int) *(char *)src
; break;
1913 case typeFloat
: *(int *)dest
= (int) *(float *)src
; break;
1914 case typeDouble
: *(int *)dest
=(int) *(double *)src
; break;
1916 case typeString
: sscanf((const char*)src
, "%d", (int*) dest
); break;
1922 default: *(int *)dest
= (int) 0;
1926 void AllDataType::convertToLong( void* dest
, void* src
, DataType srcType
)
1930 case typeInt
: *(long *)dest
=(long) *(int *)src
; break;
1931 case typeLong
: *(long *)dest
= *(long *)src
; break;
1932 case typeLongLong
: *(long *)dest
=(long) *(long long *)src
; break;
1933 case typeShort
: *(long *)dest
=(long) *(short *)src
; break;
1934 case typeByteInt
: *(long *)dest
=(long) *(char *)src
; break;
1936 case typeFloat
: *(long *)dest
= (long) *(float *)src
; break;
1937 case typeDouble
: *(long *)dest
=(long) *(double *)src
; break;
1939 case typeString
: sscanf((const char*)src
, "%ld", (long*) dest
); break;
1945 default: *(long *)dest
= (long) 0;
1950 void AllDataType::convertToLongLong( void* dest
, void* src
, DataType srcType
)
1954 case typeInt
: *(long long *)dest
=(long long) *(int *)src
; break;
1955 case typeLong
: *(long long *)dest
= (long long) *(long *)src
; break;
1956 case typeLongLong
: *(long long *)dest
= *(long long *)src
; break;
1957 case typeShort
: *(long long *)dest
=(long long) *(short *)src
; break;
1958 case typeByteInt
: *(long long *)dest
=(long long) *(char *)src
; break;
1960 case typeFloat
: *(long long *)dest
= (long long) *(float *)src
; break;
1961 case typeDouble
: *(long long *)dest
=(long long) *(double *)src
; break;
1963 case typeString
: sscanf((const char*)src
, "%lld", (long long*) dest
); break;
1969 default: *(long long *)dest
= (long long) 0;
1973 void AllDataType::convertToShort( void* dest
, void* src
, DataType srcType
)
1977 case typeInt
: *(short*)dest
=(short) *(int*)src
; break;
1978 case typeLong
: *(short*)dest
= (short) *(long*)src
; break;
1979 case typeLongLong
: *(short*)dest
= (short) *(long long*)src
; break;
1980 case typeShort
: *(short*)dest
= *(short*)src
; break;
1981 case typeByteInt
: *(short*)dest
=(short) *(char *)src
; break;
1983 case typeFloat
: *(short*)dest
= (short) *(float *)src
; break;
1984 case typeDouble
: *(short*)dest
=(short) *(double *)src
; break;
1986 case typeString
: sscanf((const char*)src
, "%hd", (short*) dest
); break;
1992 default: *(short*)dest
= (short) 0;
1996 void AllDataType::convertToByteInt( void* dest
, void* src
, DataType srcType
)
2000 case typeInt
: *(char*)dest
= (char) *(int*)src
; break;
2001 case typeLong
: *(char*)dest
= (char) *(long*)src
; break;
2002 case typeLongLong
: *(char*)dest
= (char) *(long long*)src
; break;
2003 case typeShort
: *(char*)dest
= (char) *(short*)src
; break;
2004 case typeByteInt
: *(char*)dest
= *(char *)src
; break;
2006 case typeFloat
: *(char*)dest
= (char) *(float *)src
; break;
2007 case typeDouble
: *(char*)dest
=(char) *(double *)src
; break;
2009 case typeString
: sscanf((const char*)src
, "%hhd", (char*) dest
); break;
2015 default: *(char*)dest
= (char) 0;
2019 void AllDataType::convertToFloat( void* dest
, void* src
, DataType srcType
)
2023 case typeInt
: *(float *)dest
=(float) *(int *)src
; break;
2024 case typeLong
: *(float *)dest
=(float) *(long *)src
; break;
2025 case typeLongLong
: *(float *)dest
=(float) *(long long *)src
; break;
2026 case typeShort
: *(float *)dest
=(float) *(short *)src
; break;
2027 case typeByteInt
: *(float *)dest
=(float) *(char *)src
; break;
2029 case typeFloat
: *(float *)dest
= *(float *)src
; break;
2030 case typeDouble
: *(float *)dest
=(float) *(double *)src
; break;
2032 case typeString
: sscanf((const char*)src
, "%f", (float*) dest
); break;
2038 default: *(float *)dest
= (float) 0;
2042 void AllDataType::convertToDouble( void* dest
, void* src
, DataType srcType
)
2046 case typeInt
: *(double *)dest
=(double) *(int *)src
; break;
2047 case typeLong
: *(double *)dest
=(double) *(long *)src
; break;
2048 case typeLongLong
: *(double *)dest
=(double) *(long long *)src
; break;
2049 case typeShort
: *(double *)dest
=(double) *(short *)src
; break;
2050 case typeByteInt
: *(double *)dest
=(double) *(char *)src
; break;
2052 case typeFloat
: *(double *)dest
=(double) *(float *)src
; break;
2053 case typeDouble
: *(double *)dest
= *(double *)src
; break;
2055 case typeString
: sscanf((const char*)src
, "%lf", (double*) dest
); break;
2061 default: *(double *)dest
= (double) 0;
2065 void AllDataType::convertToString( void* dest
, void* src
, DataType srcType
, int length
,TDBInfo tdbname
)
2071 Util::itoa(*(int*)src
, (char*)dest
);
2076 sprintf ((char *)dest
, "%ld", *(long *)src
);
2081 sprintf ((char *)dest
, "%lld", *(long long *)src
);
2086 sprintf ((char *)dest
, "%hd", *(short *)src
);
2091 sprintf ((char *)dest
, "%hhd", *(char *)src
);
2097 sprintf ((char *)dest
, "%f", *(float *)src
);
2102 sprintf ((char *) dest
, "%lf", *(double *)src
);
2108 strcpy((char*)dest
, (char*)src
);
2113 Date
* dt
= (Date
*)src
;
2114 sprintf((char*) dest
, "%d/%d/%d", dt
->year(),dt
->month(), dt
->dayOfMonth());
2119 Time
* tm
= (Time
*)src
;
2120 sprintf((char*)dest
,"%d:%d:%d.%d", tm
->hours(), tm
->minutes(), tm
->seconds(), 0);
2125 TimeStamp
* tm
= (TimeStamp
*)src
;
2126 sprintf((char*)dest
, "%d/%d/%d %d:%d:%d.%d", tm
->year(),tm
->month(), tm
->dayOfMonth(), tm
->hours(),tm
->minutes(), tm
->seconds(), 0 );
2131 unsigned char *c
= (unsigned char *) src
;
2132 unsigned char *str
= (unsigned char *) dest
;
2133 unsigned char p
= 0;
2135 while (i
< length
) {
2137 if (p
< 10) sprintf ((char *)str
++, "%c", '0' + p
);
2138 else sprintf((char *)str
++, "%c", 'A' + p
- 10);
2140 if (p
< 10) sprintf ((char *)str
++, "%c", '0' + p
);
2141 else sprintf((char *)str
++, "%c", 'A' + p
- 10);
2147 default: ((char*)dest
)[0] = '\0';
2151 void AllDataType::convertToDate( void* dest
, void* src
, DataType srcType
)
2168 Date
*dt
= (Date
*) dest
;
2169 dt
->parseFrom((char*)src
);
2172 default: ((char*)dest
)[0] = '\0';
2176 void AllDataType::convertToTime( void* dest
, void* src
, DataType srcType
)
2193 Time
*dt
= (Time
*) dest
;
2194 dt
->parseFrom((char*)src
);
2197 default: ((char*)dest
)[0] = '\0';
2201 void AllDataType::convertToTimeStamp( void* dest
, void* src
, DataType srcType
)
2218 TimeStamp
*dt
= (TimeStamp
*) dest
;
2219 dt
->parseFrom((char*)src
);
2222 default: ((char*)dest
)[0] = '\0';
2226 void AllDataType::convertToBinary(void *dest
, void *src
, DataType srcType
, int length
)
2232 memset ((void *) dest
, 0, length
);
2233 unsigned char c
= 0;
2234 const char *str
= (const char *)src
;
2236 i
= strlen((char*)src
)-1;
2237 if( i
> (length
*2)-1 ){ i
= (length
*2)-1 ; }
2238 bool evenlegth
=false;
2239 if(i
%2){ evenlegth
=true;}
2240 unsigned char *val
= (unsigned char *)dest
+(length
-1);
2243 if (c
<= '9') c
-= '0';
2244 else if (c
>= 'a') c
= c
- 'a' + 10;
2245 else c
= c
- 'A' + 10;
2248 if ((i
+1) % 2) { *val
= *val
| (c
<<4); val
--;}
2251 if (i
% 2) { *val
= *val
| (c
<<4); val
--;}
2260 int AllDataType::printVal(void* src
, DataType srcType
, int length
,int dbFlag
)
2262 //dbFlag is the database flag 0:mysql (default), 1:postgres
2268 count
= printf ("%d", *(int *)src
);
2273 count
= printf ("%ld", *(long *)src
);
2280 convertToLongLong((void*)&temp
, src
,typeString
);
2281 count
= printf ("%lld", temp
);
2283 else count
= printf ("%lld", *(long long *)src
);
2288 count
= printf("%hd", *(short *)src
);
2293 count
= printf("%hhd", *(char *)src
);
2299 count
= printf("%f", *(float *)src
);
2304 if (*(double*)src
> 9999999999999999.0F
)
2305 count
= printf("%g", *(double *)src
);
2307 count
= printf("%lf", *(double *)src
);
2314 count
= printf("%s", (char*)src
);
2319 Date
* dt
= (Date
*)src
;
2320 count
= printf("%d/%d/%d", dt
->year(),
2321 dt
->month(), dt
->dayOfMonth());
2326 Time
* tm
= (Time
*)src
;
2327 count
= printf("%d:%d:%d.%d", tm
->hours(), tm
->minutes(), tm
->seconds(), 0);
2332 TimeStamp
* tm
= (TimeStamp
*)src
;
2333 count
= printf("%d/%d/%d %d:%d:%d.%d", tm
->year(),
2334 tm
->month(), tm
->dayOfMonth(), tm
->hours(),
2335 tm
->minutes(), tm
->seconds(), 0 );
2340 unsigned char *c
= (unsigned char *) src
;
2341 unsigned char p
= 0;
2343 bool isDigitFound
=false;
2344 while (i
< length
) {
2346 if(('0'+p
)!='0'|| isDigitFound
){
2347 if (p
< 10) printf ("%c", '0' + p
);
2348 else printf("%c", 'A' + p
- 10);
2352 if(('0'+p
)!='0' || isDigitFound
){
2353 if (p
< 10) printf ("%c", '0' + p
);
2354 else printf("%c", 'A' + p
- 10);
2362 default: { printf("DataType not supported\n"); break; }