?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
error in parsing date and time leads to wrong value being inserted into the table
[csql.git] / src / storage / DataType.cxx
blob369d8efbadb608dd1b497b02f5d306f625701ff8
1 /***************************************************************************
2 * Copyright (C) 2007 by www.databasecache.com *
3 * Contact: praba_tuty@databasecache.com *
4 * *
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. *
9 * *
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. *
14 * *
15 ***************************************************************************/
16 #include<os.h>
17 #include<DataType.h>
18 #include<Debug.h>
19 //#include<Config.h>
20 #define SmallestValJulDate (1721426)
21 #if defined(SOLARIS)
22 #undef _TIME_H
23 #endif
24
25
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); }
32
33 int Date::parseFrom(const char *s) {
34 int month,day,year;
35 int count;char *p;
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);
41 #else
42 struct tm *tmval = localtime(&cnow);
43 return set(year=tmval->tm_year+1900,month=tmval->tm_mon+1,day=tmval->tm_mday);
44 #endif
45 }
46 else{
47 p=(char*)s;
48 while(*p!='\0'){
49 if(*p=='-'){
50 count = sscanf(s,"%d-%d-%d",&year,&month,&day);
51 break;
52 }
53 if(*p=='/'){
54 count = sscanf(s,"%d/%d/%d",&year,&month,&day);
55 break;
56 }
57 p++;
58 }
59 if (count < 3) return -1;
60 if (year < 100) year += 1900;
61 if (!isValidDate(year, month, day))
62 return -1;
63 return set(year,month,day);
64 }
65 }
66
67 void Date::changeToCsqlFormat(char *src)
68 {
69 char dst[10]="";
70 char *srcPtr = src;
71 char *dstPtr = dst;
72 dst[0]='\0';
73 srcPtr = src + 7;
74 strncpy(dstPtr, srcPtr, 4);
75 dst[4] = '-';
76 dstPtr = &dst[5];
77 srcPtr = src + 3;
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);
90 dst[7]='-';
91 dstPtr = &dst[8];
92 strncpy(dstPtr, src, 2);
93 dst[10] = '\0';
94 strcpy(src, dst);
95 return;
96 }
97 void Date::addDay(int noOfDays)
98 {
99 julianDate = julianDate + noOfDays;
100 }
101 void Date::subDay(int noOfDays)
102 {
103 julianDate = julianDate - noOfDays;
104 }
105
106 void Date::addMonth(int noOfMons)
107 {
108 int year, month, day;
109 get(year,month,day);
110 month += noOfMons;
111 if(month > 12){
112 year += (month /12);
113 month %= 12;
114 }
115 set(year,month,day);
116 }
117 void Date::subMonth(int noOfMons)
118 {
119 int year, month, day;
120 get(year,month,day);
121 if(noOfMons>12)
122 {
123 year -= (noOfMons/12);
124 }
125 month -= (noOfMons%12);
126 if(month<0){
127 year -= 1;
128 month += 12;
129 }
130 set(year,month,day);
131 }
132 void Date::addYear(int noOfYrs )
133 {
134 int year, month, day;
135 get(year,month,day);
136 year += noOfYrs;
137 set(year,month,day);
138 }
139
140 void Date::subYear(int noOfYrs )
141 {
142 int year, month, day;
143 get(year,month,day);
144 year -= noOfYrs;
145 set(year,month,day);
146 }
147
148
149 int Date::dayOfMonth() const {
150 int year, month, day;
151 get(year,month,day);
152 return day;
153 }
154 int Date::month() const {
155 int year, month, day;
156 get(year,month,day);
157 return month;
158 }
159 int Date::year() const {
160 int year, month, day;
161 get(year,month,day);
162 return year;
163 }
164
165 int Date::dayOfWeek() const { return dayOfWeek(julianDate); }
166
167 const char *Date::dayOfWeekName() const
168 { return dayOfWeekName(dayOfWeek(julianDate)); }
169
170 const char *Date::dayOfWeekAbbr() const
171 { return dayOfWeekAbbr(dayOfWeek(julianDate)); }
172
173 static const char *day_names[] = {
174 "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
175 };
176 static const char *day_abbrs[] = {
177 "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
178 };
179
180 static const char *month_names[] = {
181 "January", "February", "March", "April", "May", "June",
182 "July", "August", "September", "October", "November", "December"
183 };
184 static const char *month_abbrs[] = {
185 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
186 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
187 };
188
189
190 static int daysBeforeMonth[] = {
191 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365
192 };
193 static int days_per_month[] = {
194 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
195 };
196
197 const char * Date::dayOfWeekName(int day)
198 { return (day < 1 || day > 7) ? 0 : day_names[day-1]; }
199
200 const char * Date::dayOfWeekAbbr(int day)
201 { return (day < 1 || day > 7) ? 0 : day_abbrs[day-1]; }
202
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); }
215
216 int operator-(const Date &d1, const Date& d2)
217 { return d1.julianDate - d2.julianDate; }
218
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; }
231
232 bool Date::isValid() const
233 { return julianDate >= SmallestValJulDate; }
234
235 bool Date::isLeapYear(int year)
236 {
237 return (year % 400 == 0) || ((year % 4 == 0) && !(year % 100 == 0));
238 }
239
240 int Date::dayOfYear() const {
241 int year,month,day;
242 get(year,month,day);
243 int tmp = daysBeforeMonth[month-1];
244 if (month >= 3 && isLeapYear(year))
245 tmp++;
246 return tmp + day;
247 }
248
249 int Date::daysInMonth(int month, int year) {
250 --month;
251 int tmp = days_per_month[month];
252 if (month == 1 && isLeapYear(year)) tmp++;
253 return tmp;
254 }
255
256 bool Date::isValidDate(int year, int month, int day) {
257
258 if (year < 1 || year > 9999) return false;
259 if (month < 1 || month > 12) return false;
260 return (day >= 1) && (day <= daysInMonth(month,year));
261 }
262
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; }
267
268 // year, month, day are assumed to be valid
269 int m = mon, d = day, y = year;
270 int c, ya, j;
271
272 if (m > 2) m -= 3;
273 else { m += 9; --y; }
274 c = y/100;
275 ya = y - (100 * c);
276 j = (146097*c)/4 + (1461*ya)/4 + (153*m+2)/5 + d + 1721119;
277 jul = (JulianRep)j;
278 return 0;
279 }
280
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);
287 }
288
289 int Date::julianToYMD(JulianRep jul, int &year, int &month, int &day) {
290 int j = jul;
291 int d, m, y;
292
293 if (j < SmallestValJulDate)
294 { year = month = day = 0; return -1; }
295
296 j -= 1721119;
297 y = (4 * j - 1)/146097;
298 j = 4 * j - 1 - 146097 * y;
299 d = j/4;
300 j = (4 * d + 3)/1461;
301 d = 4 * d + 3 - 1461 * j;
302 d = (d + 4)/4;
303 m = (5 * d - 3)/153;
304 d = 5 * d - 3 - 153 * m;
305 d = (d + 5) / 5;
306 y = 100 * y + j;
307 if (m < 10) m += 3;
308 else { m -= 9; ++y; }
309 month = m;
310 day = d;
311 year = y;
312 return 0;
313 }
314
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); }
318
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;
324 timeVal *= 10000;
325 if(usec) timeVal += usec/100;
326 return 0;
327 }
328
329 int Time::get(int &hours, int &mins, int &secs) const {
330 if (timeVal < 0) return -1;
331 int s = timeVal/10000;
332 secs = s % 60;
333 s /= 60;
334 mins = s % 60;
335 s /= 60;
336 hours = s;
337 return 0;
338 }
339
340 int Time::addSec(int secs)
341 {
342 timeVal += (secs *10000);
343 int quit = timeVal /864000000;
344 if(0==quit) return 0;
345 timeVal %= 864000000;
346 return quit;
347 }
348
349 int Time::subSec(int secs)
350 {
351 timeVal -= (secs *10000);
352 int quit = timeVal /864000000;
353 if(0==quit) return 0;
354 timeVal %= 864000000;
355 return quit;
356 }
357 int Time::addMin(int mins)
358 {
359 timeVal += (mins * 60 * 10000);
360 int quit = timeVal /864000000;
361 if(0==quit) return 0;
362 timeVal %= 864000000;
363 return quit;
364 }
365 int Time::subMin(int mins)
366 {
367 timeVal -= (mins * 60 * 10000);
368 int quit = timeVal /864000000;
369 if(0==quit) return 0;
370 timeVal %= 864000000;
371 return quit;
372 }
373 int Time::addHour(int hours)
374 {
375 int day=hours/24;
376 hours%=24;
377 timeVal += (hours* 60 * 60 * 10000);
378 int quit = day+(timeVal /864000000);
379 if(0==quit) return 0;
380 timeVal %= 864000000;
381 return quit;
382 }
383 int Time::subHour(int hours)
384 {
385 timeVal -= (hours* 60 * 60 * 10000);
386 int quit = timeVal /864000000;
387 if(timeVal < 0) {
388 quit += -1;
389 if(quit<0) timeVal += ( 864000000 * quit *(-1) );
390 else timeVal +=864000000;
391 }
392 if(0==quit) return 0;
393 timeVal %= 864000000;
394 return quit;
395 }
396
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; }
402
403 int Time::setMsec(int ms) {
404 if(ms < 0 || ms >= 1000) return -1;
405 timeVal = timeVal+(10*ms);
406 return 0;
407 }
408 int Time::setUsec(int us) {
409 if(us < 0 || us >= 1000000) return -1;
410 timeVal = timeVal +us/100;
411 return 0;
412 }
413
414 bool Time::isValid() const
415 { return timeVal >= 0 && timeVal <= (10000*(MAX_VALID_SECONDS+1)-1); }
416
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);
421 }
422
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); }
429
430 int operator-(const Time &t1, const Time& t2)
431 { return (t1.timeVal - t2.timeVal)/10000; }
432
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; }
445
446 int Time::parseFrom(const char *s) {
447 int hours,mins,secs;
448 int count;char *p;
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);
454 #else
455 struct tm *tmval = localtime(&cnow);
456 return set(hours=tmval->tm_hour,mins=tmval->tm_min,secs=tmval->tm_sec);
457 #endif
458 }
459 else{
460 count = sscanf(s,"%d:%d:%d",&hours,&mins,&secs);
461 if (count < 2) return -1;
462 if (count == 2) secs = 0;
463
464 if (!isValidTime(hours,mins,secs))
465 return -1;
466 return set(hours,mins,secs);
467 }
468 }
469 int TimeStamp::parseFrom(const char *s) {
470 int hours,mins,secs;
471 int month,day,year;
472 int count;char *p;
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);
479 #else
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);
483 #endif
484 }
485 else{
486 p=(char*)s;
487 while(*p!='\0'){
488 if(*p=='-'){
489 count = sscanf(s,"%d-%d-%d %d:%d:%d",&year,&month,&day, &hours, &mins, &secs);
490 break;
491 }
492 if(*p=='/'){
493 count = sscanf(s,"%d/%d/%d %d:%d:%d",&year,&month,&day, &hours, &mins, &secs);
494 break;
495 }
496 p++;
497 }
498 if (count < 5) return -1;
499 if (count == 5) secs = 0;
500 if (year < 100) year += 1900;
501
502 if (!date.isValidDate(year, month, day))
503 return -1;
504
505 setDate(year,month,day);
506
507
508 if (!time.isValidTime(hours,mins,secs))
509 return -1;
510 return setTime(hours,mins,secs);
511 }
512 }
513 void TimeStamp::addHour(int hours )
514 {
515 int day = time.addHour(hours);
516 if(day!=0){ date.addDay(day);}
517 }
518
519 void TimeStamp::subHour(int hours )
520 {
521 int day = time.subHour(hours);
522 if(day!=0){ date.subDay(day);}
523 }
524
525 void TimeStamp::addMin(int noOfMins )
526 {
527 int day = time.addMin(noOfMins);
528 if(day!=0){ date.addDay(day);}
529 }
530
531 void TimeStamp::subMin(int noOfMins)
532 {
533 int day = time.subMin(noOfMins);
534 if(day!=0) {date.subDay(day);}
535 }
536 void TimeStamp::addSec(int noOfSecs)
537 {
538 int day = time.addSec(noOfSecs);
539 if(day!=0){ date.addDay(day);}
540 }
541 void TimeStamp::subSec(int noOfSecs)
542 {
543 int day = time.subSec(noOfSecs);
544 if(day!=0){ date.subDay(day);}
545 }
546
547 int TimeStamp::secDiff(TimeStamp &ts)
548 {
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));
554 }
555 int TimeStamp::minDiff(TimeStamp &ts)
556 {
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));
562
563 return (secdiff/60);
564 }
565
566 int TimeStamp::hourDiff(TimeStamp &ts)
567 {
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);
574 }
575
576 int TimeStamp::dayDiff(TimeStamp &ts)
577 {
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));
584
585 }
586
587 int TimeStamp::monthDiff(TimeStamp &ts)
588 {
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));
595
596 }
597 int TimeStamp::yearDiff(TimeStamp &ts)
598 {
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));
605 }
606 void TimeStamp::changeToCsqlFormat(char *src)
607 {
608 char dst[20];
609 char *srcPtr = src;
610 char *dstPtr = dst;
611 dst[0]='\0';
612 srcPtr = src + 7;
613 strncpy(dstPtr, srcPtr, 4);
614 dst[4] = '-';
615 dstPtr = &dst[5];
616 srcPtr = src + 3;
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);
629 dst[7]='-';
630 dstPtr = &dst[8];
631 strncpy(dstPtr, src, 2);
632 dstPtr = &dst[10];
633 srcPtr = src + 11;
634 strncpy(dstPtr, srcPtr, 9);
635 dst[19]='\0';
636 strcpy(src, dst);
637 return;
638 }
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; }
651
652 DataType AllDataType::getCsqlTypeFromFunctionType(FunctionType type)
653 {
654 switch(type)
655 {
656 case DATEDIFF: return typeDate;
657 case TIMEDIFF: return typeTime;
658 case DATEADDWITHYEAR:
659 case DATEADDWITHMON:
660 case DATEADDWITHDAY:
661 case DATESUBWITHYEAR:
662 case DATESUBWITHMON:
663 case DATESUBWITHDAY:
664 case TIMEADDWITHHOUR:
665 case TIMEADDWITHMIN:
666 case TIMEADDWITHSEC:
667 case TIMESUBWITHHOUR:
668 case TIMESUBWITHMIN:
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;
703 }
704 }
705 DataType AllDataType::getCsqlTypeFromFunctionTypeForComparision(FunctionType type)
706 {
707 switch(type)
708 {
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;
756 }
757
758 }
759
760 char* AllDataType::getSQLString(DataType type)
761 {
762 switch(type)
763 {
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";
778 }
779 }
780
781
782 SQLSMALLINT AllDataType::convertToSQLType(DataType type)
783 {
784 switch(type)
785 {
786 case typeInt:
787 return SQL_INTEGER;
788 case typeLong:
789 return SQL_INTEGER;
790 case typeLongLong:
791 //TODO
792 return SQL_BIGINT;
793 case typeShort:
794 return SQL_SMALLINT;
795 case typeByteInt:
796 //TODO
797 return SQL_INTEGER;
798 case typeDouble:
799 return SQL_DOUBLE;
800 case typeFloat:
801 return SQL_REAL;
802 case typeDecimal:
803 //TODO
804 return SQL_INTEGER;
805 case typeDate:
806 return SQL_TYPE_DATE;
807 case typeTime:
808 return SQL_TYPE_TIME;
809 case typeTimeStamp:
810 return SQL_TYPE_TIMESTAMP;
811 case typeString:
812 return SQL_CHAR;
813 case typeBinary:
814 return SQL_BINARY;
815 case typeVarchar:
816 return SQL_VARCHAR;
817 }
818 return SQL_INTEGER;
819 }
820 SQLSMALLINT AllDataType::convertToCSQLSQLType(DataType type)
821 {
822 switch(type)
823 {
824 case typeInt:
825 return SQL_INTEGER;
826 case typeLong:
827 return SQL_INTEGER;
828 case typeLongLong:
829 //TODO
830 return SQL_BIGINT;
831 case typeShort:
832 return SQL_SMALLINT;
833 case typeByteInt:
834 //TODO
835 return SQL_TINYINT;
836 case typeDouble:
837 return SQL_DOUBLE;
838 case typeFloat:
839 return SQL_REAL;
840 case typeDecimal:
841 //TODO
842 return SQL_INTEGER;
843 case typeDate:
844 return SQL_TYPE_DATE;
845 case typeTime:
846 return SQL_TYPE_TIME;
847 case typeTimeStamp:
848 return SQL_TYPE_TIMESTAMP;
849 case typeString:
850 return SQL_CHAR;
851 case typeBinary:
852 return SQL_BINARY;
853 case typeVarchar:
854 return SQL_VARCHAR;
855 }
856 return SQL_INTEGER;
857 }
858
859 SQLSMALLINT AllDataType::convertToSQL_C_Type(DataType type,TDBInfo tdbname)
860 {
861 switch(type)
862 {
863 case typeInt:
864 return SQL_C_SLONG;
865 case typeLong:
866 return SQL_C_SLONG;
867 case typeLongLong:
868 {
869 if(tdbname == postgres)
870 return SQL_C_CHAR;
871 else
872 return SQL_C_SBIGINT;
873 }
874 case typeShort:
875 return SQL_C_SSHORT;
876 case typeByteInt:
877 return SQL_C_STINYINT;
878 case typeDouble:
879 return SQL_C_DOUBLE;
880 case typeFloat:
881 return SQL_C_FLOAT;
882 case typeDecimal:
883 //TODO
884 return SQL_INTEGER;
885 case typeDate:
886 return SQL_C_TYPE_DATE;
887 case typeTime:
888 return SQL_C_TYPE_TIME;
889 case typeTimeStamp:
890 return SQL_C_TYPE_TIMESTAMP;
891 case typeVarchar:
892 case typeString:
893 return SQL_C_CHAR;
894 case typeBinary:
895 return SQL_C_BINARY;
896 }
897 return SQL_C_SLONG;
898 }
899
900 DataType AllDataType::convertFromSQLType(SQLSMALLINT type,int length,int scale,TDBInfo tdbname)
901 {
902 if(tdbname==postgres)
903 {
904 switch(type)
905 {
906 case SQL_INTEGER :
907 return typeInt;
908 case SQL_SMALLINT:
909 return typeShort;
910 case SQL_BIGINT:
911 return typeLongLong;
912 case SQL_FLOAT:
913 case SQL_DOUBLE:
914 return typeDouble;
915 case SQL_REAL:
916 return typeFloat;
917 case SQL_TYPE_DATE:
918 return typeDate;
919 case SQL_TYPE_TIME :
920 return typeTime;
921 case SQL_TYPE_TIMESTAMP :
922 return typeTimeStamp;
923 case SQL_CHAR:
924 return typeString;
925 case SQL_LONGVARCHAR:
926 return typeString;
927 case SQL_VARCHAR:
928 return typeVarchar;
929 case SQL_BINARY:
930 return typeBinary;
931 }
932 return typeInt;
933 }
934 switch(type)
935 {
936 case SQL_TINYINT:
937 return typeByteInt;
938 case SQL_INTEGER :
939 return typeInt;
940 case SQL_SMALLINT:
941 return typeShort;
942 case SQL_BIGINT:
943 return typeLongLong;
944 case SQL_DOUBLE:
945 return typeDouble;
946 case SQL_FLOAT:
947 case SQL_REAL:
948 return typeFloat;
949 case SQL_TYPE_DATE:
950 return typeDate;
951 case SQL_TYPE_TIME :
952 return typeTime;
953 case SQL_TYPE_TIMESTAMP :
954 return typeTimeStamp;
955 case SQL_CHAR:
956 return typeString;
957 case SQL_LONGVARCHAR:
958 return typeString;
959 case SQL_VARCHAR:
960 return typeVarchar;
961 case SQL_BINARY:
962 return typeBinary;
963 }
964 return typeInt;
965 }
966 void AllDataType::subVal(void* dest, void *src, DataType type)
967 {
968 switch(type)
969 {
970 case typeInt:
971 *(int*)dest = *(int*)dest - *(int*)src;
972 break;
973 case typeLong:
974 *(long*)dest = *(long*)dest - *(long*)src;
975 break;
976 case typeLongLong:
977 *(long long*)dest = *(long long*)dest - *(long long*)src;
978 break;
979 case typeShort:
980 *(short*)dest = *(short*)dest - *(short*)src;
981 break;
982 case typeByteInt:
983 *(char*)dest = *(char*)dest - *(char*)src;
984 break;
985 case typeDouble:
986 *(double*)dest = *(double*)dest - *(double*)src;
987 break;
988 case typeFloat:
989 *(float*)dest = *(float*)dest - *(float*)src;
990 break;
991 case typeDecimal:
992 case typeDate:
993 case typeTime:
994 case typeTimeStamp:
995 case typeBinary:
996 default:
997 break;
998 }
999 return;
1000 }
1001 void AllDataType::mulVal(void* dest, void *src, DataType type)
1002 {
1003 switch(type)
1004 {
1005 case typeInt:
1006 *(int*)dest = *(int*)dest * (*(int*)src);
1007 break;
1008 case typeLong:
1009 *(long*)dest = *(long*)dest * (*(long*)src);
1010 break;
1011 case typeLongLong:
1012 *(long long*)dest = *(long long*)dest * (*(long long*)src);
1013 break;
1014 case typeShort:
1015 *(short*)dest = *(short*)dest * (*(short*)src);
1016 break;
1017 case typeByteInt:
1018 *(char*)dest = *(char*)dest * (*(char*)src);
1019 break;
1020 case typeDouble:
1021 *(double*)dest = *(double*)dest * (*(double*)src);
1022 break;
1023 case typeFloat:
1024 *(float*)dest = *(float*)dest * (*(float*)src);
1025 break;
1026 case typeDecimal:
1027 case typeDate:
1028 case typeTime:
1029 case typeTimeStamp:
1030 case typeBinary:
1031 default:
1032 break;
1033 }
1034 return;
1035 }
1036 void AllDataType::mudVal(void* dest, void *src, DataType type)
1037 {
1038 if (type == typeInt)
1039 {
1040 *(int*)dest = *(int*)dest % (*(int*)src);
1041 return;
1042 }
1043 switch(type)
1044 {
1045 case typeInt:
1046 *(int*)dest = *(int*)dest % (*(int*)src);
1047 break;
1048 case typeLong:
1049 *(long*)dest = *(long*)dest % (*(long*)src);
1050 break;
1051 case typeLongLong:
1052 *(long long*)dest = *(long long*)dest % (*(long long*)src);
1053 break;
1054 case typeShort:
1055 *(short*)dest = *(short*)dest % (*(short*)src);
1056 break;
1057 case typeByteInt:
1058 *(char*)dest = *(char*)dest % (*(char*)src);
1059 break;
1060 case typeDouble:
1061 *(double*)dest = *(long long*)dest % (*(long long*)src);
1062 break;
1063 case typeFloat:
1064 *(float*)dest = *(int*)dest % (*(int*)src);
1065 break;
1066 case typeDecimal:
1067 case typeDate:
1068 case typeTime:
1069 case typeTimeStamp:
1070 case typeBinary:
1071 default:
1072 break;
1073 }
1074 return;
1075 }
1076 void AllDataType::divVal(void* dest, void *src, DataType type)
1077 {
1078 if (type == typeInt)
1079 {
1080 *(int*)dest = *(int*)dest / (*(int*)src);
1081 return;
1082 }
1083 switch(type)
1084 {
1085 case typeInt:
1086 *(int*)dest = *(int*)dest / (*(int*)src);
1087 break;
1088 case typeLong:
1089 *(long*)dest = *(long*)dest / (*(long*)src);
1090 break;
1091 case typeLongLong:
1092 *(long long*)dest = *(long long*)dest / (*(long long*)src);
1093 break;
1094 case typeShort:
1095 *(short*)dest = *(short*)dest / (*(short*)src);
1096 break;
1097 case typeByteInt:
1098 *(char*)dest = *(char*)dest / (*(char*)src);
1099 break;
1100 case typeDouble:
1101 *(double*)dest = *(double *)dest / (*(double*)src);
1102 break;
1103 case typeFloat:
1104 *(float*)dest = *(float*)dest / (*(float*)src);
1105 break;
1106 case typeDecimal:
1107 case typeDate:
1108 case typeTime:
1109 case typeTimeStamp:
1110 case typeBinary:
1111 default:
1112 break;
1113 }
1114 return;
1115 }
1116 void AllDataType::divVal(double* dest, int src, DataType type)
1117 {
1118 switch(type)
1119 {
1120 case typeInt:
1121 case typeLong:
1122 case typeLongLong:
1123 case typeShort:
1124 case typeByteInt:
1125 case typeDouble:
1126 case typeFloat:
1127 case typeDecimal:
1128 *dest = *dest / src;
1129 break;
1130 //TODO::for porting
1131 case typeDate:
1132 case typeTime:
1133 case typeTimeStamp:
1134 case typeBinary:
1135 default:
1136 break;
1137 }
1138 return;
1139 }
1140
1141 void AllDataType::increment(void* dest, void *src, DataType type)
1142 {
1143 switch(type)
1144 {
1145 case typeInt:
1146 *(int*)dest = *(int*)src + 1;
1147 break;
1148 case typeLong:
1149 *(long*)dest = *(long*)src + 1;
1150 break;
1151 case typeLongLong:
1152 *(long long*)dest = *(long long*)src + 1;
1153 break;
1154 case typeByteInt:
1155 *(char*)dest = *(char*)src + 1;
1156 break;
1157 case typeShort:
1158 *(short*)dest = *(short*)src + 1;
1159 break;
1160 case typeDouble:
1161 *(double*)dest = *(double*)src + 1;
1162 break;
1163 case typeFloat:
1164 *(float*)dest = *(float*)src+ 1;
1165 break;
1166 default:
1167 break;
1168 }
1169 }
1170
1171 bool AllDataType::isValueZero(void *src, DataType type)
1172 {
1173 switch(type)
1174 {
1175 case typeInt:
1176 if (*(int*)src == 0) return true;
1177 else return false;
1178 case typeLong:
1179 if (*(int*)src == 0) return true;
1180 else return false;
1181 case typeLongLong:
1182 if (*(int*)src == 0) return true;
1183 else return false;
1184 case typeShort:
1185 if (*(int*)src == 0) return true;
1186 else return false;
1187 case typeDouble:
1188 if (*(int*)src == 0) return true;
1189 else return false;
1190 case typeFloat:
1191 if (*(int*)src == 0) return true;
1192 else return false;
1193 default:
1194 break;
1195 }
1196 return false;
1197 }
1198
1199 bool AllDataType::compareIntVal(void* src1, void *src2, ComparisionOp op)
1200 {
1201 printf("This function should never be called by anyone\n");
1202 if (OpEquals == op) {
1203 if (*(int*)src1 == *(int*)src2) return true;
1204 else return false;
1205 }else if (OpGreaterThan == op) {
1206 if (*(int*)src1 > *(int*)src2) return true;
1207 else return false;
1208 }else if (OpLessThan == op) {
1209 if (*(int*)src1 < *(int*)src2) return true;
1210 else return false;
1211 }else if (OpLessThanEquals == op) {
1212 if (*(int*)src1 <= *(int*)src2) return true;
1213 else return false;
1214 }else if (OpGreaterThanEquals == op) {
1215 if (*(int*)src1 >= *(int*)src2) return true;
1216 else return false;
1217 }else if (OpNotEquals == op) {
1218 if (*(int*)src1 != *(int*)src2) return true;
1219 else return false;
1220 }
1221 return false;
1222 }
1223
1224 bool AllDataType::compareLongVal(void* src1, void *src2, ComparisionOp op)
1225 {
1226 bool result = false;
1227 switch(op)
1228 {
1229 case OpEquals:
1230 if (*(long*)src1 == *(long*)src2) result = true;
1231 else result = false;
1232 break;
1233 case OpNotEquals:
1234 if (*(long*)src1 != *(long*)src2) result = true;
1235 else result = false;
1236 break;
1237 case OpLessThan:
1238 if (*(long*)src1 < *(long*)src2) result = true;
1239 else result = false;
1240 break;
1241 case OpLessThanEquals:
1242 if (*(long*)src1 <= *(long*)src2) result = true;
1243 else result = false;
1244 break;
1245 case OpGreaterThan:
1246 if (*(long*)src1 > *(long*)src2) result = true;
1247 else result = false;
1248 break;
1249 case OpGreaterThanEquals:
1250 if (*(long*)src1 >= *(long*)src2) result = true;
1251 else result = false;
1252 break;
1253 }
1254 return result;
1255 }
1256
1257 bool AllDataType::compareLongLongVal(void* src1, void *src2,
1258 ComparisionOp op)
1259 {
1260 bool result = false;
1261 switch(op)
1262 {
1263 case OpEquals:
1264 if (*(long long*)src1 == *(long long*)src2) result = true;
1265 else result = false;
1266 break;
1267 case OpNotEquals:
1268 if (*(long long*)src1 != *(long long*)src2) result = true;
1269 else result = false;
1270 break;
1271 case OpLessThan:
1272 if (*(long long*)src1 < *(long long*)src2) result = true;
1273 else result = false;
1274 break;
1275 case OpLessThanEquals:
1276 if (*(long long*)src1 <= *(long long*)src2) result = true;
1277 else result = false;
1278 break;
1279 case OpGreaterThan:
1280 if (*(long long*)src1 > *(long long*)src2) result = true;
1281 else result = false;
1282 break;
1283 case OpGreaterThanEquals:
1284 if (*(long long*)src1 >= *(long long*)src2) result = true;
1285 else result = false;
1286 break;
1287 }
1288 return result;
1289 }
1290
1291 bool AllDataType::compareShortVal(void* src1, void *src2, ComparisionOp op)
1292 {
1293 bool result = false;
1294 switch(op)
1295 {
1296 case OpEquals:
1297 if (*(short*)src1 == *(short*)src2) result = true;
1298 else result = false;
1299 break;
1300 case OpNotEquals:
1301 if (*(short*)src1 != *(short*)src2) result = true;
1302 else result = false;
1303 break;
1304 case OpLessThan:
1305 if (*(short*)src1 < *(short*)src2) result = true;
1306 else result = false;
1307 break;
1308 case OpLessThanEquals:
1309 if (*(short*)src1 <= *(short*)src2) result = true;
1310 else result = false;
1311 break;
1312 case OpGreaterThan:
1313 if (*(short*)src1 > *(short*)src2) result = true;
1314 else result = false;
1315 break;
1316 case OpGreaterThanEquals:
1317 if (*(short*)src1 >= *(short*)src2) result = true;
1318 else result = false;
1319 break;
1320 }
1321 return result;
1322 }
1323
1324 bool AllDataType::compareByteIntVal(void* src1, void *src2, ComparisionOp op)
1325 {
1326 bool result = false;
1327 switch(op)
1328 {
1329 case OpEquals:
1330 if (*(ByteInt*)src1 == *(ByteInt*)src2) result = true;
1331 else result = false;
1332 break;
1333 case OpNotEquals:
1334 if (*(ByteInt*)src1 != *(ByteInt*)src2) result = true;
1335 else result = false;
1336 break;
1337 case OpLessThan:
1338 if (*(ByteInt*)src1 < *(ByteInt*)src2) result = true;
1339 else result = false;
1340 break;
1341 case OpLessThanEquals:
1342 if (*(ByteInt*)src1 <= *(ByteInt*)src2) result = true;
1343 else result = false;
1344 break;
1345 case OpGreaterThan:
1346 if (*(ByteInt*)src1 > *(ByteInt*)src2) result = true;
1347 else result = false;
1348 break;
1349 case OpGreaterThanEquals:
1350 if (*(ByteInt*)src1 >= *(ByteInt*)src2) result = true;
1351 else result = false;
1352 break;
1353 }
1354 return result;
1355 }
1356
1357 bool AllDataType::compareDoubleVal(void* src1, void *src2, ComparisionOp op)
1358 {
1359 bool result = false;
1360 switch(op)
1361 {
1362 case OpEquals:
1363 if (*(double*)src1 == *(double*)src2) result = true;
1364 else result = false;
1365 break;
1366 case OpNotEquals:
1367 if (*(double*)src1 != *(double*)src2) result = true;
1368 else result = false;
1369 break;
1370 case OpLessThan:
1371 if (*(double*)src1 < *(double*)src2) result = true;
1372 else result = false;
1373 break;
1374 case OpLessThanEquals:
1375 if (*(double*)src1 <= *(double*)src2) result = true;
1376 else result = false;
1377 break;
1378 case OpGreaterThan:
1379 if (*(double*)src1 > *(double*)src2) result = true;
1380 else result = false;
1381 break;
1382 case OpGreaterThanEquals:
1383 if (*(double*)src1 >= *(double*)src2) result = true;
1384 else result = false;
1385 break;
1386 }
1387 return result;
1388 }
1389
1390 bool AllDataType::compareFloatVal(void* src1, void *src2, ComparisionOp op)
1391 {
1392 bool result = false;
1393 switch(op)
1394 {
1395 case OpEquals:
1396 if (*(float*)src1 == *(float*)src2) result = true;
1397 else result = false;
1398 break;
1399 case OpNotEquals:
1400 if (*(float*)src1 != *(float*)src2) result = true;
1401 else result = false;
1402 break;
1403 case OpLessThan:
1404 if (*(float*)src1 < *(float*)src2) result = true;
1405 else result = false;
1406 break;
1407 case OpLessThanEquals:
1408 if (*(float*)src1 <= *(float*)src2) result = true;
1409 else result = false;
1410 break;
1411 case OpGreaterThan:
1412 if (*(float*)src1 > *(float*)src2) result = true;
1413 else result = false;
1414 break;
1415 case OpGreaterThanEquals:
1416 if (*(float*)src1 >= *(float*)src2) result = true;
1417 else result = false;
1418 break;
1419 }
1420 return result;
1421 }
1422
1423 bool AllDataType::compareDateVal(void* src1, void *src2, ComparisionOp op)
1424 {
1425 bool result = false;
1426 switch(op)
1427 {
1428 case OpEquals:
1429 if (*(Date*)src1 == *(Date*)src2) result = true;
1430 else result = false;
1431 break;
1432 case OpNotEquals:
1433 if (*(Date*)src1 != *(Date*)src2) result = true;
1434 else result = false;
1435 break;
1436 case OpLessThan:
1437 if (*(Date*)src1 < *(Date*)src2) result = true;
1438 else result = false;
1439 break;
1440 case OpLessThanEquals:
1441 if (*(Date*)src1 <= *(Date*)src2) result = true;
1442 else result = false;
1443 break;
1444 case OpGreaterThan:
1445 if (*(Date*)src1 > *(Date*)src2) result = true;
1446 else result = false;
1447 break;
1448 case OpGreaterThanEquals:
1449 if (*(Date*)src1 >= *(Date*)src2) result = true;
1450 else result = false;
1451 break;
1452 }
1453 return result;
1454 }
1455
1456 bool AllDataType::compareTimeVal(void* src1, void *src2, ComparisionOp op)
1457 {
1458 bool result = false;
1459 switch(op)
1460 {
1461 case OpEquals:
1462 if (*(Time*)src1 == *(Time*)src2) result = true;
1463 else result = false;
1464 break;
1465 case OpNotEquals:
1466 if (*(Time*)src1 != *(Time*)src2) result = true;
1467 else result = false;
1468 break;
1469 case OpLessThan:
1470 if (*(Time*)src1 < *(Time*)src2) result = true;
1471 else result = false;
1472 break;
1473 case OpLessThanEquals:
1474 if (*(Time*)src1 <= *(Time*)src2) result = true;
1475 else result = false;
1476 break;
1477 case OpGreaterThan:
1478 if (*(Time*)src1 > *(Time*)src2) result = true;
1479 else result = false;
1480 break;
1481 case OpGreaterThanEquals:
1482 if (*(Time*)src1 >= *(Time*)src2) result = true;
1483 else result = false;
1484 break;
1485 }
1486 return result;
1487 }
1488
1489 bool AllDataType::compareTimeStampVal(void* src1, void *src2, ComparisionOp op)
1490 {
1491 bool result = false;
1492 switch(op)
1493 {
1494 case OpEquals:
1495 if (*(TimeStamp*)src1 == *(TimeStamp*)src2) result = true;
1496 else result = false;
1497 break;
1498 case OpNotEquals:
1499 if (*(TimeStamp*)src1 != *(TimeStamp*)src2) result = true;
1500 else result = false;
1501 break;
1502 case OpLessThan:
1503 if (*(TimeStamp*)src1 < *(TimeStamp*)src2) result = true;
1504 else result = false;
1505 break;
1506 case OpLessThanEquals:
1507 if (*(TimeStamp*)src1 <= *(TimeStamp*)src2) result = true;
1508 else result = false;
1509 break;
1510 case OpGreaterThan:
1511 if (*(TimeStamp*)src1 > *(TimeStamp*)src2) result = true;
1512 else result = false;
1513 break;
1514 case OpGreaterThanEquals:
1515 if (*(TimeStamp*)src1 >= *(TimeStamp*)src2) result = true;
1516 else result = false;
1517 break;
1518 }
1519 return result;
1520 }
1521
1522 bool AllDataType::compareStringVal(void* src1, void *src2, ComparisionOp op)
1523 {
1524 if (OpEquals == op) {
1525 if (strcmp((char*)src1, (char*)src2) ==0) return true;
1526 else return false;
1527 }else if (OpGreaterThan == op) {
1528 if (strcmp((char*)src1, (char*)src2) >0) return true;
1529 else return false;
1530 }else if (OpLessThan == op) {
1531 if (strcmp((char*)src1, (char*)src2) <0 ) return true;
1532 else return false;
1533 }else if (OpLessThanEquals == op) {
1534 // printf("Illegal Operator:Not Supported for String\n");
1535 // return false;
1536 if (strcmp((char*)src1, (char*)src2)<= 0) return true;
1537 else return false;
1538 }else if (OpGreaterThanEquals == op) {
1539 // printf("Illegal Operator:Not Supported for String\n");
1540 // return false;
1541 if (strcmp((char*)src1, (char*)src2) >=0) return true;
1542 else return false;
1543 }else if (OpNotEquals == op) {
1544 if (strcmp((char*)src1, (char*)src2) != 0) return true;
1545 else return false;
1546 }else if (OpLike == op) {
1547 return !os::strmatch((char*)src2, (char*)src1);
1548 }
1549 printf("Illegeal Operator:Not supported for String\n");
1550 return false;
1551 }
1552
1553 bool AllDataType::compareBinaryVal(void* src1, void *src2,
1554 ComparisionOp op, int length)
1555 {
1556 bool result = false;
1557 int ret = os::memcmp(src1, src2, length);
1558 switch(op)
1559 {
1560 case OpEquals:
1561 if (ret == 0 ) result= true; else result = false;
1562 break;
1563 case OpNotEquals:
1564 if (ret != 0 ) result= true; else result = false;
1565 break;
1566 case OpLessThan:
1567 if (ret < 0 ) result= true; else result = false;
1568 break;
1569 case OpLessThanEquals:
1570 printf("Illegal Operator:Not Supported for Binary\n");
1571 break;
1572 case OpGreaterThan:
1573 if (ret > 0 ) result= true; else result = false;
1574 break;
1575 case OpGreaterThanEquals:
1576 printf("Illegal Operator:Not Supported for Binary\n");
1577 break;
1578 }
1579 return result;
1580 }
1581
1582 void* AllDataType::alloc(DataType type, int length)
1583 {
1584 void *dest;
1585 switch(type)
1586 {
1587 case typeInt:
1588 dest = malloc(sizeof(int));
1589 break;
1590 case typeLong:
1591 dest = malloc(sizeof(long));
1592 break;
1593 case typeLongLong:
1594 dest = malloc(sizeof(long long));
1595 break;
1596 case typeShort:
1597 dest = malloc(sizeof(short));
1598 break;
1599 case typeByteInt:
1600 dest = malloc(sizeof(char));
1601 break;
1602 case typeDouble:
1603 dest = malloc(sizeof(double));
1604 break;
1605 case typeFloat:
1606 dest = malloc(sizeof(float));
1607 break;
1608 case typeDecimal:
1609 //TODO::for porting
1610 //fldDef.length_ = sizeof(long double);
1611 break;
1612 case typeVarchar:
1613 case typeString:
1614 if (length == 0 ) return NULL;
1615 dest = malloc(length);
1616 break;
1617 case typeBinary:
1618 if (length == 0 || length > 512) return NULL;
1619 dest = malloc(length);
1620 memset(dest, 0, length);
1621 break;
1622 case typeDate:
1623 dest = malloc(sizeof(Date));
1624 break;
1625 case typeTime:
1626 dest = malloc(sizeof(Time));
1627 break;
1628 case typeTimeStamp:
1629 dest = malloc(sizeof(TimeStamp));
1630 break;
1631 }
1632 return dest;
1633 }
1634
1635 void AllDataType::memoryset(void *value,DataType type)
1636 {
1637 switch(type)
1638 {
1639 case typeInt:
1640 value= ::memset(value, 0, sizeof(int));
1641 break;
1642 case typeLong:
1643 value = ::memset(value, 0, sizeof(long));
1644 break;
1645 case typeLongLong:
1646 value =::memset(value, 0, sizeof(long long));
1647 break;
1648 case typeShort:
1649 value = ::memset(value, 0, sizeof(short));
1650 break;
1651 case typeByteInt:
1652 value = ::memset(value, 0, sizeof(char));
1653 break;
1654 case typeDouble:
1655 value = ::memset(value, 0, sizeof(double));
1656 break;
1657 case typeFloat:
1658 value = ::memset(value, 0, sizeof(float));
1659 break;
1660 case typeDecimal:
1661 break;
1662 case typeString:
1663 case typeVarchar:
1664 *(char*)value = '\0';
1665 //if (length == 0 ) return NULL;
1666 //dest = malloc(length);
1667 break;
1668 case typeBinary:
1669 /* if (length == 0 || length > 256 ) return NULL;
1670
1671 memset(dest, 0, length);*/
1672 break;
1673 case typeDate:
1674 value = ::memset(value, 0, sizeof(Date));
1675 break;
1676 case typeTime:
1677 value = ::memset(value, 0, sizeof(Time));
1678 break;
1679 case typeTimeStamp:
1680 value = ::memset(value, 0, sizeof(TimeStamp));
1681 break;
1682 defalut:
1683 break;
1684 }
1685 }
1686
1687
1688 DbRetVal AllDataType::strToValue(void* dest, char *src, DataType type, int length)
1689 {
1690 Date date;
1691 Time time;
1692 switch(type)
1693 {
1694 case typeInt: {
1695 int val;
1696 sscanf( src, "%d", &val);
1697 *(int*)dest = val;
1698 break; }
1699 case typeLong: {
1700 long val;
1701 sscanf( src, "%ld", &val);
1702 *(long*)dest = val;
1703 break; }
1704 case typeLongLong: {
1705 long long val;
1706 sscanf( src, "%lld", &val);
1707 *(long long*)dest = val;
1708 break; }
1709 case typeShort: {
1710 short val;
1711 sscanf( src, "%hd", &val);
1712 *(short*)dest = val;
1713 break; }
1714 case typeByteInt: {
1715 char val;
1716 sscanf( src, "%hhd", &val);
1717 *(char*)dest = *(char *)&val;
1718 break; }
1719 case typeDouble: {
1720 double val;
1721 sscanf( src, "%lg", &val);
1722 *(double*)dest = val;
1723 break; }
1724 case typeFloat: {
1725 float val;
1726 sscanf( src, "%f", &val);
1727 *(float*)dest = val;
1728 break; }
1729 case typeDecimal:
1730 //TODO::for porting
1731 case typeString:
1732 case typeVarchar: {
1733 strncpy((char*)dest, (char*)src, length);
1734 char *d =(char*)dest;
1735 d[length-1] = '\0';
1736 break;}
1737 case typeDate: {
1738 int d,m,y,res=0;
1739 if (strlen(src) == 11) {
1740 if ( src[6] == '-' || src[6] == '/' ) {
1741 Date::changeToCsqlFormat(src);
1742 }
1743 }
1744 res = sscanf( src, "%d-%d-%d", &y, &m, &d );
1745 if( res != 3 )
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);
1750 break;
1751 }
1752 if( res != 3 )
1753 {
1754 fprintf(stderr,"Error reading date. yyyy{-/}mm{-/}dd is the valid format.");
1755 d=m=y=0;
1756 }
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);
1760 d=m=y=0;
1761 return ErrBadArg;
1762 }
1763 Date dateObj(y,m,d);
1764 *(Date*)dest = dateObj;
1765 break; }
1766 case typeTime: {
1767 int h,m,s,res=0;
1768 res = sscanf( src, "%d:%d:%d", &h, &m, &s );
1769 if(strcmp(src,"now")==0 || strcmp(src,"NOW")==0){
1770 Time *dt = (Time*) dest;
1771 dt->parseFrom((char*)src);
1772 break;
1773 }
1774 if( res != 3 )
1775 {
1776 int d,mn,y;
1777 res = sscanf( src, "%d-%d-%d %d:%d:%d", &y, &mn, &d, &h, &m, &s );
1778 if(res!=6){
1779 fprintf(stderr, "Error reading time, hh:mm:ss is the valid format.");
1780 h=m=s=0;
1781 return ErrBadArg;
1782 }
1783 }
1784 /* validate time */
1785 if(!time.isValidTime(h, m, s)){
1786 fprintf(stderr,"Error reading Time. The value \"%d-%d-%d\" is inappropriate.",h,m,s);
1787 h=m=s=0;
1788 return ErrBadArg;
1789 }
1790 Time timeObj(h,m,s);
1791 *(Time*)dest = timeObj;
1792 break; }
1793 case typeTimeStamp: {
1794 int d,m,y, h,mn,s, res=0;
1795 bool isNow = ( strcasecmp(src,"now")==0 );
1796 if(!isNow && isalpha(int(src[5]))) {
1797 TimeStamp::changeToCsqlFormat(src);
1798 }
1799 res = sscanf( src, "%d-%d-%d %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1800 if( res != 6 )
1801 res = sscanf( src, "%d-%d-%d, %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1802 if( res != 6 )
1803 res = sscanf( src, "%d/%d/%d %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1804 if( res != 6 )
1805 res = sscanf( src, "%d/%d/%d, %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1806
1807 if(isNow){
1808 TimeStamp *dt = (TimeStamp*) dest;
1809 dt->parseFrom((char*)src);
1810 break;
1811 }
1812 if ( res != 6 )
1813 {
1814 fprintf(stderr, "Error reading timestamp, yyyy{-/}mm{-/}dd[,] hh:mm:ss is the valid format.");
1815 d=m=y=h=mn=s=0;
1816 return ErrBadArg;
1817 }
1818 /* Looking up at 'YY-MM-DD' */
1819 if(!date.isValidDate(y, m, d)){
1820 fprintf(stderr,"Error reading date. The value \"%d-%d-%d\" is inappropriate.",y,m,d);
1821 d=m=y=h=mn=s=0;
1822 return ErrBadArg;
1823 }
1824 /* Looking up at 'Hour-Min-Sec' */
1825 if(!time.isValidTime(h, m, s)){
1826 fprintf(stderr,"Error reading Time. The value \"%d-%d-%d\" is inappropriate.",h,m,s);
1827 d=m=y=h=mn=s=0;
1828 return ErrBadArg;
1829 }
1830 TimeStamp timeStampObj(y,m,d,h,mn,s);
1831 *(TimeStamp*)dest = timeStampObj;
1832 break; }
1833 case typeBinary: {
1834 memset ((void *) dest, 0, length);
1835 unsigned char c = 0;
1836 const char *str = (const char *)src;
1837 int i=0;
1838 i = strlen(src)-1;
1839 if( i > (length*2)-1 ){ i = (length*2)-1 ; }
1840 bool evenlegth=false;
1841 if(i%2){ evenlegth=true;}
1842 unsigned char *val = (unsigned char *)dest+(length-1);
1843 while (i >= 0) {
1844 c = str[i];
1845 if (!isxdigit((int)c)) {
1846 printError(ErrBadArg, "Invalid hexadecimal value");
1847 return ErrBadArg;
1848 }
1849 if (c <= '9') c -= '0';
1850 else if (c >= 'a') c = c - 'a' + 10;
1851 else c = c - 'A' + 10;
1852 if(evenlegth)
1853 {
1854 if ((i+1) % 2) { *val = *val | (c<<4); val--;}
1855 else { *val = c; }
1856 }else{
1857 if (i % 2) { *val = *val | (c<<4); val--;}
1858 else { *val = c; }
1859 }
1860 i--;
1861 }
1862 break;
1863 }
1864 default:
1865 break;
1866 }
1867 return OK;
1868 }
1869
1870
1871 void AllDataType::convert(DataType srcType, void *src,
1872 DataType destType, void *dest, int length)
1873 {
1874 switch ((DataType) destType )
1875 {
1876 case typeInt: convertToInt(dest, src, srcType); break;
1877 case typeLong: convertToLong(dest, src, srcType); break;
1878 case typeLongLong: convertToLongLong(dest, src, srcType); break;
1879 case typeShort: convertToShort(dest, src, srcType); break;
1880 case typeByteInt: convertToByteInt(dest, src, srcType); break;
1881
1882 case typeFloat: convertToFloat(dest, src, srcType); break;
1883 case typeDouble: convertToDouble(dest, src, srcType); break;
1884
1885 //TODO
1886 case typeDecimal: convertToDouble(dest, src, srcType); break;
1887 case typeVarchar:
1888 case typeString: convertToString(dest, src, srcType); break;
1889 case typeBinary: convertToBinary(dest, src, srcType,length); break;
1890 case typeDate: convertToDate(dest, src, srcType); break;
1891 case typeTime: convertToTime(dest, src, srcType); break;
1892 case typeTimeStamp: convertToTimeStamp(dest, src, srcType); break;
1893 default: return;
1894 }
1895 }
1896
1897 void AllDataType::convertToInt( void* dest, void* src, DataType srcType )
1898 {
1899 switch(srcType)
1900 {
1901 case typeInt: *(int *)dest = *(int *)src; break;
1902 case typeLong: *(int *)dest =(int) *(long *)src; break;
1903 case typeLongLong: *(int *)dest =(int) *(long long *)src; break;
1904 case typeShort: *(int *)dest =(int) *(short *)src; break;
1905 case typeByteInt: *(int *)dest =(int) *(char *)src; break;
1906
1907 case typeFloat: *(int *)dest = (int) *(float *)src; break;
1908 case typeDouble: *(int *)dest =(int) *(double *)src; break;
1909 case typeVarchar:
1910 case typeString: sscanf((const char*)src, "%d", (int*) dest); break;
1911
1912 case typeDate:
1913 case typeTime:
1914 case typeTimeStamp:
1915 case typeBinary:
1916 default: *(int *)dest = (int) 0;
1917 }
1918 }
1919
1920 void AllDataType::convertToLong( void* dest, void* src, DataType srcType )
1921 {
1922 switch(srcType)
1923 {
1924 case typeInt: *(long *)dest =(long) *(int *)src; break;
1925 case typeLong: *(long *)dest = *(long *)src; break;
1926 case typeLongLong: *(long *)dest =(long) *(long long *)src; break;
1927 case typeShort: *(long *)dest =(long) *(short *)src; break;
1928 case typeByteInt: *(long *)dest =(long) *(char *)src; break;
1929
1930 case typeFloat: *(long *)dest = (long) *(float *)src; break;
1931 case typeDouble: *(long *)dest =(long) *(double *)src; break;
1932 case typeVarchar:
1933 case typeString: sscanf((const char*)src, "%ld", (long*) dest); break;
1934
1935 case typeDate:
1936 case typeTime:
1937 case typeTimeStamp:
1938 case typeBinary:
1939 default: *(long *)dest = (long) 0;
1940 }
1941 }
1942
1943
1944 void AllDataType::convertToLongLong( void* dest, void* src, DataType srcType )
1945 {
1946 switch(srcType)
1947 {
1948 case typeInt: *(long long *)dest =(long long) *(int *)src; break;
1949 case typeLong: *(long long *)dest = (long long) *(long *)src; break;
1950 case typeLongLong: *(long long *)dest = *(long long *)src; break;
1951 case typeShort: *(long long *)dest =(long long) *(short *)src; break;
1952 case typeByteInt: *(long long *)dest =(long long) *(char *)src; break;
1953
1954 case typeFloat: *(long long *)dest = (long long) *(float *)src; break;
1955 case typeDouble: *(long long *)dest =(long long) *(double *)src; break;
1956 case typeVarchar:
1957 case typeString: sscanf((const char*)src, "%lld", (long long*) dest); break;
1958
1959 case typeDate:
1960 case typeTime:
1961 case typeTimeStamp:
1962 case typeBinary:
1963 default: *(long long *)dest = (long long) 0;
1964 }
1965 }
1966
1967 void AllDataType::convertToShort( void* dest, void* src, DataType srcType )
1968 {
1969 switch(srcType)
1970 {
1971 case typeInt: *(short*)dest =(short) *(int*)src; break;
1972 case typeLong: *(short*)dest = (short) *(long*)src; break;
1973 case typeLongLong: *(short*)dest = (short) *(long long*)src; break;
1974 case typeShort: *(short*)dest = *(short*)src; break;
1975 case typeByteInt: *(short*)dest =(short) *(char *)src; break;
1976
1977 case typeFloat: *(short*)dest = (short) *(float *)src; break;
1978 case typeDouble: *(short*)dest =(short) *(double *)src; break;
1979 case typeVarchar:
1980 case typeString: sscanf((const char*)src, "%hd", (short*) dest); break;
1981
1982 case typeDate:
1983 case typeTime:
1984 case typeTimeStamp:
1985 case typeBinary:
1986 default: *(short*)dest = (short) 0;
1987 }
1988 }
1989
1990 void AllDataType::convertToByteInt( void* dest, void* src, DataType srcType )
1991 {
1992 switch(srcType)
1993 {
1994 case typeInt: *(char*)dest = (char) *(int*)src; break;
1995 case typeLong: *(char*)dest = (char) *(long*)src; break;
1996 case typeLongLong: *(char*)dest = (char) *(long long*)src; break;
1997 case typeShort: *(char*)dest = (char) *(short*)src; break;
1998 case typeByteInt: *(char*)dest = *(char *)src; break;
1999
2000 case typeFloat: *(char*)dest = (char) *(float *)src; break;
2001 case typeDouble: *(char*)dest =(char) *(double *)src; break;
2002 case typeVarchar:
2003 case typeString: sscanf((const char*)src, "%hhd", (char*) dest); break;
2004
2005 case typeDate:
2006 case typeTime:
2007 case typeTimeStamp:
2008 case typeBinary:
2009 default: *(char*)dest = (char) 0;
2010 }
2011 }
2012
2013 void AllDataType::convertToFloat( void* dest, void* src, DataType srcType )
2014 {
2015 switch(srcType)
2016 {
2017 case typeInt: *(float *)dest =(float) *(int *)src; break;
2018 case typeLong: *(float *)dest =(float) *(long *)src; break;
2019 case typeLongLong: *(float *)dest =(float) *(long long *)src; break;
2020 case typeShort: *(float *)dest =(float) *(short *)src; break;
2021 case typeByteInt: *(float *)dest =(float) *(char *)src; break;
2022
2023 case typeFloat: *(float *)dest = *(float *)src; break;
2024 case typeDouble: *(float *)dest =(float) *(double *)src; break;
2025 case typeVarchar:
2026 case typeString: sscanf((const char*)src, "%f", (float*) dest); break;
2027
2028 case typeDate:
2029 case typeTime:
2030 case typeTimeStamp:
2031 case typeBinary:
2032 default: *(float *)dest = (float) 0;
2033 }
2034 }
2035
2036 void AllDataType::convertToDouble( void* dest, void* src, DataType srcType )
2037 {
2038 switch(srcType)
2039 {
2040 case typeInt: *(double *)dest =(double) *(int *)src; break;
2041 case typeLong: *(double *)dest =(double) *(long *)src; break;
2042 case typeLongLong: *(double *)dest =(double) *(long long *)src; break;
2043 case typeShort: *(double *)dest =(double) *(short *)src; break;
2044 case typeByteInt: *(double *)dest =(double) *(char *)src; break;
2045
2046 case typeFloat: *(double *)dest =(double) *(float *)src; break;
2047 case typeDouble: *(double *)dest = *(double *)src; break;
2048 case typeVarchar:
2049 case typeString: sscanf((const char*)src, "%lf", (double*) dest); break;
2050
2051 case typeDate:
2052 case typeTime:
2053 case typeTimeStamp:
2054 case typeBinary:
2055 default: *(double *)dest = (double) 0;
2056 }
2057 }
2058
2059 void AllDataType::convertToString( void* dest, void* src, DataType srcType, int length,TDBInfo tdbname )
2060 {
2061 switch(srcType)
2062 {
2063 case typeInt:
2064 {
2065 Util::itoa(*(int*)src, (char*)dest);
2066 break;
2067 }
2068 case typeLong:
2069 {
2070 sprintf ((char *)dest, "%ld", *(long *)src);
2071 break;
2072 }
2073 case typeLongLong:
2074 {
2075 sprintf ((char *)dest, "%lld", *(long long *)src);
2076 break;
2077 }
2078 case typeShort:
2079 {
2080 sprintf ((char *)dest, "%hd", *(short *)src);
2081 break;
2082 }
2083 case typeByteInt:
2084 {
2085 sprintf ((char *)dest, "%hhd", *(char *)src);
2086 break;
2087 }
2088
2089 case typeFloat:
2090 {
2091 sprintf ((char *)dest, "%f", *(float *)src);
2092 break;
2093 }
2094 case typeDouble:
2095 {
2096 sprintf ((char *) dest, "%lf", *(double *)src);
2097 break;
2098 }
2099 case typeVarchar:
2100 case typeString:
2101 {
2102 strcpy((char*)dest, (char*)src);
2103 break;
2104 }
2105 case typeDate:
2106 {
2107 Date* dt = (Date*)src;
2108 sprintf((char*) dest, "%d/%d/%d", dt->year(),dt->month(), dt->dayOfMonth());
2109 break;
2110 }
2111 case typeTime:
2112 {
2113 Time* tm = (Time*)src;
2114 sprintf((char*)dest,"%d:%d:%d.%d", tm->hours(), tm->minutes(), tm->seconds(), 0);
2115 break;
2116 }
2117 case typeTimeStamp:
2118 {
2119 TimeStamp* tm = (TimeStamp*)src;
2120 sprintf((char*)dest, "%d/%d/%d %d:%d:%d.%d", tm->year(),tm->month(), tm->dayOfMonth(), tm->hours(),tm->minutes(), tm->seconds(), 0 );
2121 break;
2122 }
2123 case typeBinary:
2124 {
2125 unsigned char *c = (unsigned char *) src;
2126 unsigned char *str = (unsigned char *) dest;
2127 unsigned char p = 0;
2128 int i = 0;
2129 while (i < length) {
2130 p = *c >> 4;
2131 if (p < 10) sprintf ((char *)str++, "%c", '0' + p);
2132 else sprintf((char *)str++, "%c", 'A' + p - 10);
2133 p = *c & 0xF;
2134 if (p < 10) sprintf ((char *)str++, "%c", '0' + p);
2135 else sprintf((char *)str++, "%c", 'A' + p - 10);
2136 i++; c++;
2137 }
2138 break;
2139 }
2140
2141 default: ((char*)dest)[0] = '\0';
2142 }
2143
2144 }
2145 void AllDataType::convertToDate( void* dest, void* src, DataType srcType )
2146 {
2147 switch(srcType)
2148 {
2149 case typeInt:
2150 case typeLong:
2151 case typeLongLong:
2152 case typeShort:
2153 case typeByteInt:
2154 case typeFloat:
2155 case typeDouble:
2156 case typeDate:
2157 case typeTime:
2158 case typeTimeStamp:
2159 case typeVarchar:
2160 case typeString:
2161 {
2162 Date *dt = (Date*) dest;
2163 dt->parseFrom((char*)src);
2164 break;
2165 }
2166 default: ((char*)dest)[0] = '\0';
2167 }
2168 }
2169
2170 void AllDataType::convertToTime( void* dest, void* src, DataType srcType )
2171 {
2172 switch(srcType)
2173 {
2174 case typeInt:
2175 case typeLong:
2176 case typeLongLong:
2177 case typeShort:
2178 case typeByteInt:
2179 case typeFloat:
2180 case typeDouble:
2181 case typeDate:
2182 case typeTime:
2183 case typeTimeStamp:
2184 case typeVarchar:
2185 case typeString:
2186 {
2187 Time *dt = (Time*) dest;
2188 dt->parseFrom((char*)src);
2189 break;
2190 }
2191 default: ((char*)dest)[0] = '\0';
2192 }
2193 }
2194
2195 void AllDataType::convertToTimeStamp( void* dest, void* src, DataType srcType )
2196 {
2197 switch(srcType)
2198 {
2199 case typeInt:
2200 case typeLong:
2201 case typeLongLong:
2202 case typeShort:
2203 case typeByteInt:
2204 case typeFloat:
2205 case typeDouble:
2206 case typeDate:
2207 case typeTime:
2208 case typeTimeStamp:
2209 case typeVarchar:
2210 case typeString:
2211 {
2212 TimeStamp *dt = (TimeStamp*) dest;
2213 dt->parseFrom((char*)src);
2214 break;
2215 }
2216 default: ((char*)dest)[0] = '\0';
2217 }
2218 }
2219
2220 void AllDataType::convertToBinary(void *dest, void *src, DataType srcType, int length)
2221 {
2222 switch(srcType)
2223 {
2224 case typeString:
2225 {
2226 memset ((void *) dest, 0, length);
2227 unsigned char c = 0;
2228 const char *str = (const char *)src;
2229 int i=0;
2230 i = strlen((char*)src)-1;
2231 if( i > (length*2)-1 ){ i = (length*2)-1 ; }
2232 bool evenlegth=false;
2233 if(i%2){ evenlegth=true;}
2234 unsigned char *val = (unsigned char *)dest+(length-1);
2235 while (i >= 0) {
2236 c = str[i];
2237 if (c <= '9') c -= '0';
2238 else if (c >= 'a') c = c - 'a' + 10;
2239 else c = c - 'A' + 10;
2240 if(evenlegth)
2241 {
2242 if ((i+1) % 2) { *val = *val | (c<<4); val--;}
2243 else { *val = c; }
2244 }else{
2245 if (i % 2) { *val = *val | (c<<4); val--;}
2246 else { *val = c; }
2247 }
2248 i--;
2249 }
2250 break;
2251 }
2252 }
2253 }
2254 int AllDataType::printVal(void* src, DataType srcType, int length,int dbFlag )
2255 {
2256 //dbFlag is the database flag 0:mysql (default), 1:postgres
2257 int count = 0;
2258 switch(srcType)
2259 {
2260 case typeInt:
2261 {
2262 count = printf ("%d", *(int *)src);
2263 break;
2264 }
2265 case typeLong:
2266 {
2267 count = printf ("%ld", *(long *)src);
2268 break;
2269 }
2270 case typeLongLong:
2271 {
2272 if(1 == dbFlag){
2273 long long temp = 0;
2274 convertToLongLong((void*)&temp, src,typeString);
2275 count = printf ("%lld", temp );
2276 }
2277 else count = printf ("%lld", *(long long *)src);
2278 break;
2279 }
2280 case typeShort:
2281 {
2282 count = printf("%hd", *(short *)src);
2283 break;
2284 }
2285 case typeByteInt:
2286 {
2287 count = printf("%hhd", *(char *)src);
2288 break;
2289 }
2290
2291 case typeFloat:
2292 {
2293 count = printf("%f", *(float *)src);
2294 break;
2295 }
2296 case typeDouble:
2297 {
2298 if (*(double*)src > 9999999999999999.0F)
2299 count = printf("%g", *(double *)src);
2300 else
2301 count = printf("%lf", *(double *)src);
2302 break;
2303 }
2304
2305 case typeString:
2306 case typeVarchar:
2307 {
2308 count = printf("%s", (char*)src);
2309 break;
2310 }
2311 case typeDate:
2312 {
2313 Date* dt = (Date*)src;
2314 count = printf("%d/%d/%d", dt->year(),
2315 dt->month(), dt->dayOfMonth());
2316 break;
2317 }
2318 case typeTime:
2319 {
2320 Time* tm = (Time*)src;
2321 count = printf("%d:%d:%d.%d", tm->hours(), tm->minutes(), tm->seconds(), 0);
2322 break;
2323 }
2324 case typeTimeStamp:
2325 {
2326 TimeStamp* tm = (TimeStamp*)src;
2327 count = printf("%d/%d/%d %d:%d:%d.%d", tm->year(),
2328 tm->month(), tm->dayOfMonth(), tm->hours(),
2329 tm->minutes(), tm->seconds(), 0 );
2330 break;
2331 }
2332 case typeBinary:
2333 {
2334 unsigned char *c = (unsigned char *) src;
2335 unsigned char p = 0;
2336 int i = 0;
2337 bool isDigitFound=false;
2338 while (i < length) {
2339 p = *c >> 4;
2340 if(('0'+p)!='0'|| isDigitFound){
2341 if (p < 10) printf ("%c", '0' + p);
2342 else printf("%c", 'A' + p - 10);
2343 isDigitFound=true;
2344 }
2345 p = *c & 0xF;
2346 if(('0'+p)!='0' || isDigitFound){
2347 if (p < 10) printf ("%c", '0' + p);
2348 else printf("%c", 'A' + p - 10);
2349 isDigitFound=true;
2350 }
2351 i++; c++;
2352 }
2353 count = length * 2;
2354 break;
2355 }
2356 default: { printf("DataType not supported\n"); break; }
2357 }
2358 return count;
2359 }
Main memory database SQL engine (cvs import)