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