?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
performance fixes for JDBC wisc benchmark
[csql.git] / src / storage / DataType.cxx
blob1f43aca905146dd97db15e6bf85ba5b25afa8d3e
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
20 #define SmallestValJulDate (1721426)
21
22 Date::Date(int year, int month, int day)
23 { YMDToJulian(year, month, day, julianDate); }
24 int Date::set(int year, int month, int day)
25 { return YMDToJulian(year,month,day,julianDate); }
26 int Date::get(int &year, int &month, int &day) const
27 { return julianToYMD(julianDate,year,month,day); }
28
29 int Date::parseFrom(const char *s) {
30 int month,day,year;
31 int count;
32 count = sscanf(s,"%d/%d/%d",&year,&month,&day);
33 if (count < 3) return -1;
34
35 if (year < 100) year += 1900;
36
37 if (!isValidDate(year, month, day))
38 return -1;
39 return set(year,month,day);
40 }
41
42 int Date::dayOfMonth() const {
43 int year, month, day;
44 get(year,month,day);
45 return day;
46 }
47 int Date::month() const {
48 int year, month, day;
49 get(year,month,day);
50 return month;
51 }
52 int Date::year() const {
53 int year, month, day;
54 get(year,month,day);
55 return year;
56 }
57
58 int Date::dayOfWeek() const { return dayOfWeek(julianDate); }
59
60 const char *Date::dayOfWeekName() const
61 { return dayOfWeekName(dayOfWeek(julianDate)); }
62
63 const char *Date::dayOfWeekAbbr() const
64 { return dayOfWeekAbbr(dayOfWeek(julianDate)); }
65
66 static const char *day_names[] = {
67 "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
68 };
69 static const char *day_abbrs[] = {
70 "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
71 };
72
73 static const char *month_names[] = {
74 "January", "February", "March", "April", "May", "June",
75 "July", "August", "September", "October", "November", "December"
76 };
77 static const char *month_abbrs[] = {
78 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
79 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
80 };
81
82
83 static int daysBeforeMonth[] = {
84 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365
85 };
86 static int days_per_month[] = {
87 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
88 };
89
90 const char * Date::dayOfWeekName(int day)
91 { return (day < 1 || day > 7) ? 0 : day_names[day-1]; }
92
93 const char * Date::dayOfWeekAbbr(int day)
94 { return (day < 1 || day > 7) ? 0 : day_abbrs[day-1]; }
95
96 const char * Date::monthName() const { return monthName(month()); }
97 const char * Date::monthAbbr() const { return monthAbbr(month()); }
98 const char * Date::monthName(int month)
99 { return (month < 1 || month > 12) ? 0 : month_names[month-1]; }
100 const char * Date::monthAbbr(int month)
101 { return (month < 1 || month > 12) ? 0 : month_abbrs[month-1]; }
102 Date operator+(const Date &d1, int days)
103 { return Date(d1.julianDate + days); }
104 Date operator+(int days, const Date &d1)
105 { return Date(d1.julianDate + days); }
106 Date operator-(const Date &d1, int days)
107 { return Date(d1.julianDate - days); }
108
109 int operator-(const Date &d1, const Date& d2)
110 { return d1.julianDate - d2.julianDate; }
111
112 int operator<(const Date &d1 ,const Date &d2 )
113 { return d1.julianDate < d2.julianDate; }
114 int operator>(const Date &d1 ,const Date &d2 )
115 { return d1.julianDate > d2.julianDate; }
116 int operator<=(const Date &d1 ,const Date &d2 )
117 { return d1.julianDate <= d2.julianDate; }
118 int operator>=(const Date &d1 ,const Date &d2 )
119 { return d1.julianDate >= d2.julianDate; }
120 int operator==(const Date &d1 ,const Date &d2 )
121 { return d1.julianDate == d2.julianDate; }
122 int operator!=(const Date &d1 ,const Date &d2 )
123 { return d1.julianDate != d2.julianDate; }
124
125 bool Date::isValid() const
126 { return julianDate >= SmallestValJulDate; }
127
128 bool Date::isLeapYear(int year)
129 {
130 return (year % 400 == 0) || ((year % 4 == 0) && !(year % 100 == 0));
131 }
132
133 int Date::dayOfYear() const {
134 int year,month,day;
135 get(year,month,day);
136 int tmp = daysBeforeMonth[month-1];
137 if (month >= 3 && isLeapYear(year))
138 tmp++;
139 return tmp + day;
140 }
141
142 int Date::daysInMonth(int month, int year) {
143 --month;
144 int tmp = days_per_month[month];
145 if (month == 1 && isLeapYear(year)) tmp++;
146 return tmp;
147 }
148
149 bool Date::isValidDate(int year, int month, int day) {
150 if (year < 1 || year > 10000) return false;
151 if (month < 1 || month > 12) return false;
152 return (day >= 1) && (day <= daysInMonth(month,year));
153 }
154
155 // Algorithm Author: Robert G. Tantzen
156 int Date::YMDToJulian(int year, int mon, int day, JulianRep &jul) {
157 if (!isValidDate(year, mon, day))
158 { jul = (JulianRep)0; return -1; }
159
160 // year, month, day are assumed to be valid
161 int m = mon, d = day, y = year;
162 int c, ya, j;
163
164 if (m > 2) m -= 3;
165 else { m += 9; --y; }
166 c = y/100;
167 ya = y - (100 * c);
168 j = (146097*c)/4 + (1461*ya)/4 + (153*m+2)/5 + d + 1721119;
169 jul = (JulianRep)j;
170 return 0;
171 }
172
173 // Julian date converter. Takes a julian date (the number of days since some
174 // distant epoch or other), and returns month, day of month, and year in
175 // integer references.
176 // Algorithm Author: Robert G. Tantzen
177 int Date::dayOfWeek(JulianRep jul) {
178 return (int)((jul+1)%7+1);
179 }
180
181 int Date::julianToYMD(JulianRep jul, int &year, int &month, int &day) {
182 int j = jul;
183 int d, m, y;
184
185 if (j < SmallestValJulDate)
186 { year = month = day = 0; return -1; }
187
188 j -= 1721119;
189 y = (4 * j - 1)/146097;
190 j = 4 * j - 1 - 146097 * y;
191 d = j/4;
192 j = (4 * d + 3)/1461;
193 d = 4 * d + 3 - 1461 * j;
194 d = (d + 4)/4;
195 m = (5 * d - 3)/153;
196 d = 5 * d - 3 - 153 * m;
197 d = (d + 5) / 5;
198 y = 100 * y + j;
199 if (m < 10) m += 3;
200 else { m -= 9; ++y; }
201 month = m;
202 day = d;
203 year = y;
204 return 0;
205 }
206
207 #define MAX_VALID_SECONDS (60 * 60 * 24 -1)
208 Time::Time(int hours, int mins, int secs, int usec)
209 { set(hours,mins,secs, usec); }
210
211 int Time::set(int hours, int mins, int secs, int usec) {
212 if((hours | mins | secs | usec) < 0) { timeVal = -1; return -1; }
213 if(hours >= 24 | mins >= 60 | secs >= 62)
214 { timeVal = -1; return -1; }
215 timeVal = secs + mins * 60 + hours * 3600;
216 timeVal *= 10000;
217 if(usec) timeVal += usec/100;
218 return 0;
219 }
220
221 int Time::get(int &hours, int &mins, int &secs) const {
222 if (timeVal < 0) return -1;
223 int s = timeVal/10000;
224 secs = s % 60;
225 s /= 60;
226 mins = s % 60;
227 s /= 60;
228 hours = s;
229 return 0;
230 }
231
232 int Time::seconds() const { return (timeVal/10000) % 60; }
233 int Time::minutes() const { return (timeVal /(60*10000)) % 60; }
234 int Time::hours() const { return timeVal / (3600*10000); }
235 int Time::msec() const { return (timeVal % 10000) / 10; }
236 int Time::usec() const { return (timeVal % 10000) * 100; }
237
238 int Time::setMsec(int ms) {
239 if(ms < 0 || ms >= 1000) return -1;
240 timeVal = timeVal+(10*ms);
241 return 0;
242 }
243 int Time::setUsec(int us) {
244 if(us < 0 || us >= 1000000) return -1;
245 timeVal = timeVal +us/100;
246 return 0;
247 }
248
249 bool Time::isValid() const
250 { return timeVal >= 0 && timeVal <= (10000*(MAX_VALID_SECONDS+1)-1); }
251
252 bool Time::isValidTime(int hours, int mins, int secs) {
253 return (hours >= 0 && hours < 24) &&
254 (mins >= 0 && mins < 60) &&
255 (secs >= 0 && secs < 60);
256 }
257
258 Time operator+(const Time &t1, int seconds)
259 { return Time(t1.timeVal + seconds*10000); }
260 Time operator+(int seconds, const Time &t1)
261 { return Time(t1.timeVal + seconds*10000); }
262 Time operator-(const Time &t1, int seconds)
263 { return Time(t1.timeVal - seconds*10000); }
264
265 int operator-(const Time &t1, const Time& t2)
266 { return (t1.timeVal - t2.timeVal)/10000; }
267
268 int operator<(const Time &t1 ,const Time &t2 )
269 { return t1.timeVal < t2.timeVal; }
270 int operator>(const Time &t1 ,const Time &t2 )
271 { return t1.timeVal > t2.timeVal; }
272 int operator<=(const Time &t1 ,const Time &t2 )
273 { return t1.timeVal <= t2.timeVal; }
274 int operator>=(const Time &t1 ,const Time &t2 )
275 { return t1.timeVal >= t2.timeVal; }
276 int operator==(const Time &t1 ,const Time &t2 )
277 { return t1.timeVal == t2.timeVal; }
278 int operator!=(const Time &t1 ,const Time &t2 )
279 { return t1.timeVal != t2.timeVal; }
280
281 int Time::parseFrom(const char *s) {
282 int hours,mins,secs;
283 int count;
284 count = sscanf(s,"%d:%d:%d",&hours,&mins,&secs);
285 if (count < 2) return -1;
286 if (count == 2) secs = 0;
287
288 if (!isValidTime(hours,mins,secs))
289 return -1;
290 return set(hours,mins,secs);
291 }
292 int TimeStamp::parseFrom(const char *s) {
293 int hours,mins,secs;
294 int month,day,year;
295 int count;
296 count = sscanf(s,"%d/%d/%d %d:%d:%d",&year,&month,&day, &hours, &mins, &secs);
297 if (count < 5) return -1;
298 if (count == 5) secs = 0;
299
300 if (year < 100) year += 1900;
301
302 if (!date.isValidDate(year, month, day))
303 return -1;
304
305 setDate(year,month,day);
306
307
308 if (!time.isValidTime(hours,mins,secs))
309 return -1;
310 return setTime(hours,mins,secs);
311 }
312
313 int operator< (const TimeStamp &d1, const TimeStamp &d2)
314 { return (d1.date != d2.date) ? d1.date < d2.date : d1.time < d2.time; }
315 int operator> (const TimeStamp &d1, const TimeStamp &d2)
316 { return (d1.date != d2.date) ? d1.date > d2.date : d1.time > d2.time; }
317 int operator<=(const TimeStamp &d1, const TimeStamp &d2)
318 { return (d1.date != d2.date) ? d1.date < d2.date : d1.time <= d2.time; }
319 int operator>=(const TimeStamp &d1, const TimeStamp &d2)
320 { return (d1.date != d2.date) ? d1.date > d2.date : d1.time >= d2.time; }
321 int operator==(const TimeStamp &d1, const TimeStamp &d2)
322 { return d1.date == d2.date && d1.time == d2.time; }
323 int operator!=(const TimeStamp &d1, const TimeStamp &d2)
324 { return d1.date != d2.date && d1.time != d2.time; }
325
326
327 long AllDataType::size(DataType type, int length )
328 {
329 if (type == typeInt) return sizeof(int);
330 else if (type == typeString) return length;
331
332 long size = 0;
333 switch(type)
334 {
335 case typeInt:
336 size = sizeof(int);
337 break;
338 case typeLong:
339 size = sizeof(long);
340 break;
341 case typeLongLong:
342 size = sizeof(long long);
343 break;
344 case typeShort:
345 size = sizeof(short);
346 break;
347 case typeByteInt:
348 size = sizeof(char);
349 break;
350 case typeDouble:
351 size = sizeof(double);
352 break;
353 case typeFloat:
354 size = sizeof(float);
355 break;
356 case typeDecimal:
357 //TODO::for porting
358 //fldDef.length_ = sizeof(long double);
359 break;
360 case typeDate:
361 size = sizeof(Date);
362 break;
363 case typeTime:
364 size = sizeof(Time);
365 break;
366 case typeTimeStamp:
367 size = sizeof(TimeStamp);
368 break;
369 case typeString:
370 case typeBinary:
371 size = length;
372 break;
373 default:
374 size = 0;
375 break;
376 }
377 return size;
378 }
379 char* AllDataType::getSQLString(DataType type)
380 {
381 switch(type)
382 {
383 case typeInt: return "INT";
384 case typeLong: return "INT";
385 case typeLongLong: return "BIGINT";
386 case typeShort: return "SMALLINT";
387 case typeByteInt: return "TINYINT";
388 case typeDouble: return "REAL";
389 case typeFloat: return "FLOAT";
390 case typeDate: return "DATE";
391 case typeTime: return "TIME";
392 case typeTimeStamp: return "TIMESTAMP";
393 case typeString: return "CHAR";
394 case typeBinary: return "BINARY";
395 default: return "UNKNOWN";
396 }
397 }
398
399
400 SQLSMALLINT AllDataType::convertToSQLType(DataType type)
401 {
402 switch(type)
403 {
404 case typeInt:
405 return SQL_INTEGER;
406 case typeLong:
407 return SQL_INTEGER;
408 case typeLongLong:
409 //TODO
410 return SQL_INTEGER;
411 case typeShort:
412 return SQL_SMALLINT;
413 case typeByteInt:
414 //TODO
415 return SQL_INTEGER;
416 case typeDouble:
417 return SQL_DOUBLE;
418 case typeFloat:
419 return SQL_REAL;
420 case typeDecimal:
421 //TODO
422 return SQL_INTEGER;
423 case typeDate:
424 return SQL_TYPE_DATE;
425 case typeTime:
426 return SQL_TYPE_TIME;
427 case typeTimeStamp:
428 return SQL_TYPE_TIMESTAMP;
429 case typeString:
430 return SQL_CHAR;
431 case typeBinary:
432 return SQL_BINARY;
433 }
434 return SQL_INTEGER;
435 }
436 SQLSMALLINT AllDataType::convertToSQL_C_Type(DataType type)
437 {
438 switch(type)
439 {
440 case typeInt:
441 return SQL_C_SLONG;
442 case typeLong:
443 return SQL_C_SLONG;
444 case typeLongLong:
445 return SQL_C_SBIGINT;
446 case typeShort:
447 return SQL_C_SSHORT;
448 case typeByteInt:
449 return SQL_C_STINYINT;
450 case typeDouble:
451 return SQL_C_DOUBLE;
452 case typeFloat:
453 return SQL_C_FLOAT;
454 case typeDecimal:
455 //TODO
456 return SQL_INTEGER;
457 case typeDate:
458 return SQL_C_TYPE_DATE;
459 case typeTime:
460 return SQL_C_TYPE_TIME;
461 case typeTimeStamp:
462 return SQL_C_TYPE_TIMESTAMP;
463 case typeString:
464 return SQL_C_CHAR;
465 case typeBinary:
466 return SQL_C_BINARY;
467 }
468 return SQL_C_SLONG;
469 }
470
471 DataType AllDataType::convertFromSQLType(SQLSMALLINT type)
472 {
473 switch(type)
474 {
475 case SQL_INTEGER :
476 return typeInt;
477 case SQL_SMALLINT:
478 return typeShort;
479 case SQL_DOUBLE:
480 return typeDouble;
481 case SQL_FLOAT:
482 case SQL_REAL:
483 return typeFloat;
484 case SQL_TYPE_DATE:
485 return typeDate;
486 case SQL_TYPE_TIME :
487 return typeTime;
488 case SQL_TYPE_TIMESTAMP :
489 return typeTimeStamp;
490 case SQL_CHAR:
491 return typeString;
492 case SQL_VARCHAR:
493 return typeString;
494 case SQL_BINARY:
495 return typeBinary;
496 }
497 return typeInt;
498 }
499 void AllDataType::copyVal(void* dest, void *src, DataType type, int length)
500 {
501 //Performance optimization. putting likely case first
502 if (typeInt == type )
503 {
504 *(int*)dest = *(int*)src;
505 return;
506 }else if (typeString == type)
507 {
508 //null is always put at the last byte by insert
509 //so using strcpy is safe
510 //strcpy((char*)dest, (char*)src);
511 strncpy((char*)dest, (char*)src, length);
512 char *d =(char*)dest;
513 d[length-1] = '\0';
514 return;
515 }else if (typeShort == type) {
516 *(short*)dest = *(short*)src;
517 }else if (typeDouble == type) {
518 *(double*)dest = *(double*)src;
519 }else if (typeTimeStamp == type) {
520 *(TimeStamp*)dest = *(TimeStamp*)src;
521 }else if (typeDate == type) {
522 *(Date*)dest = *(Date*)src;
523 }else if (typeFloat == type) {
524 *(float*)dest = *(float*)src;
525 }else if (typeTime == type) {
526 *(Time*)dest = *(Time*)src;
527 }else if (typeLong == type) {
528 *(long*)dest = *(long*)src;
529 }else if (typeLongLong == type) {
530 *(long long*)dest = *(long long*)src;
531 }else if (typeByteInt == type) {
532 *(char*)dest = *(char*)src;
533 }else if (typeBinary == type) {
534 os::memcpy(dest, src, length);
535 }else if (typeComposite == type) {
536 os::memcpy(dest, src, length);
537 }
538 return;
539 }
540 void AllDataType::addVal(void* dest, void *src, DataType type)
541 {
542 if (type == typeInt)
543 {
544 *(int*)dest = *(int*)dest + *(int*)src;
545 return;
546 }
547 switch(type)
548 {
549 case typeInt:
550 *(int*)dest = *(int*)dest + *(int*)src;
551 break;
552 case typeLong:
553 *(long*)dest = *(long*)dest + *(long*)src;
554 break;
555 case typeLongLong:
556 *(long long*)dest = *(long long*)dest + *(long long*)src;
557 break;
558 case typeShort:
559 *(short*)dest = *(short*)dest + *(short*)src;
560 break;
561 case typeByteInt:
562 *(char*)dest = *(char*)dest + *(char*)src;
563 break;
564 case typeDouble:
565 *(double*)dest = *(double*)dest + *(double*)src;
566 break;
567 case typeFloat:
568 *(float*)dest = *(float*)dest + *(float*)src;
569 break;
570 case typeDecimal:
571 //TODO::for porting
572 case typeDate:
573 case typeTime:
574 case typeTimeStamp:
575 case typeBinary:
576 default:
577 break;
578 }
579 return;
580 }
581 void AllDataType::subVal(void* dest, void *src, DataType type)
582 {
583 switch(type)
584 {
585 case typeInt:
586 *(int*)dest = *(int*)dest - *(int*)src;
587 break;
588 case typeLong:
589 *(long*)dest = *(long*)dest - *(long*)src;
590 break;
591 case typeLongLong:
592 *(long long*)dest = *(long long*)dest - *(long long*)src;
593 break;
594 case typeShort:
595 *(short*)dest = *(short*)dest - *(short*)src;
596 break;
597 case typeByteInt:
598 *(char*)dest = *(char*)dest - *(char*)src;
599 break;
600 case typeDouble:
601 *(double*)dest = *(double*)dest - *(double*)src;
602 break;
603 case typeFloat:
604 *(float*)dest = *(float*)dest - *(float*)src;
605 break;
606 case typeDecimal:
607 case typeDate:
608 case typeTime:
609 case typeTimeStamp:
610 case typeBinary:
611 default:
612 break;
613 }
614 return;
615 }
616 void AllDataType::mulVal(void* dest, void *src, DataType type)
617 {
618 switch(type)
619 {
620 case typeInt:
621 *(int*)dest = *(int*)dest * (*(int*)src);
622 break;
623 case typeLong:
624 *(long*)dest = *(long*)dest * (*(long*)src);
625 break;
626 case typeLongLong:
627 *(long long*)dest = *(long long*)dest * (*(long long*)src);
628 break;
629 case typeShort:
630 *(short*)dest = *(short*)dest * (*(short*)src);
631 break;
632 case typeByteInt:
633 *(char*)dest = *(char*)dest * (*(char*)src);
634 break;
635 case typeDouble:
636 *(double*)dest = *(double*)dest * (*(double*)src);
637 break;
638 case typeFloat:
639 *(float*)dest = *(float*)dest * (*(float*)src);
640 break;
641 case typeDecimal:
642 case typeDate:
643 case typeTime:
644 case typeTimeStamp:
645 case typeBinary:
646 default:
647 break;
648 }
649 return;
650 }
651 void AllDataType::mudVal(void* dest, void *src, DataType type)
652 {
653 if (type == typeInt)
654 {
655 *(int*)dest = *(int*)dest % (*(int*)src);
656 return;
657 }
658 switch(type)
659 {
660 case typeInt:
661 *(int*)dest = *(int*)dest % (*(int*)src);
662 break;
663 case typeLong:
664 *(long*)dest = *(long*)dest % (*(long*)src);
665 break;
666 case typeLongLong:
667 *(long long*)dest = *(long long*)dest % (*(long long*)src);
668 break;
669 case typeShort:
670 *(short*)dest = *(short*)dest % (*(short*)src);
671 break;
672 case typeByteInt:
673 *(char*)dest = *(char*)dest % (*(char*)src);
674 break;
675 case typeDouble:
676 *(double*)dest = *(long long*)dest % (*(long long*)src);
677 break;
678 case typeFloat:
679 *(float*)dest = *(int*)dest % (*(int*)src);
680 break;
681 case typeDecimal:
682 case typeDate:
683 case typeTime:
684 case typeTimeStamp:
685 case typeBinary:
686 default:
687 break;
688 }
689 return;
690 }
691 void AllDataType::divVal(void* dest, void *src, DataType type)
692 {
693 if (type == typeInt)
694 {
695 *(int*)dest = *(int*)dest / (*(int*)src);
696 return;
697 }
698 switch(type)
699 {
700 case typeInt:
701 *(int*)dest = *(int*)dest / (*(int*)src);
702 break;
703 case typeLong:
704 *(long*)dest = *(long*)dest / (*(long*)src);
705 break;
706 case typeLongLong:
707 *(long long*)dest = *(long long*)dest / (*(long long*)src);
708 break;
709 case typeShort:
710 *(short*)dest = *(short*)dest / (*(short*)src);
711 break;
712 case typeByteInt:
713 *(char*)dest = *(char*)dest / (*(char*)src);
714 break;
715 case typeDouble:
716 *(double*)dest = *(double *)dest / (*(double*)src);
717 break;
718 case typeFloat:
719 *(float*)dest = *(float*)dest / (*(float*)src);
720 break;
721 case typeDecimal:
722 case typeDate:
723 case typeTime:
724 case typeTimeStamp:
725 case typeBinary:
726 default:
727 break;
728 }
729 return;
730 }
731 void AllDataType::divVal(void* dest, int src, DataType type)
732 {
733 if(type == typeInt)
734 {
735 *(int*)dest = *(int*)dest / src;
736 return;
737 }
738 switch(type)
739 {
740 case typeInt:
741 *(int*)dest = *(int*)dest / src;
742 break;
743 case typeLong:
744 *(long*)dest = *(long*)dest / src;
745 break;
746 case typeLongLong:
747 *(long long*)dest = *(long long*)dest / src;
748 break;
749 case typeShort:
750 *(short*)dest = *(short*)dest / src;
751 break;
752 case typeByteInt:
753 *(char*)dest = *(char*)dest / src;
754 break;
755 case typeDouble:
756 *(double*)dest = *(double*)dest / src;
757 break;
758 case typeFloat:
759 *(float*)dest = *(float*)dest / src;
760 break;
761 case typeDecimal:
762 //TODO::for porting
763 case typeDate:
764 case typeTime:
765 case typeTimeStamp:
766 case typeBinary:
767 default:
768 break;
769 }
770 return;
771 }
772
773 bool AllDataType::compareVal(void *val1, void *val2, ComparisionOp op,
774 DataType type, long length)
775 {
776 //Performance optimization.
777 //do not convert compareXXXVal to virtual functions. it takes more time
778 if (typeInt == type)
779 {
780 //as int is the heavily used type, hardcoding the compare here itself
781 if (OpEquals == op) {
782 if (*(int*)val1 == *(int*)val2) return true;
783 else return false;
784 }else if (OpGreaterThanEquals == op) {
785 if (*(int*)val1 >= *(int*)val2) return true;
786 else return false;
787 }else if (OpLessThanEquals == op) {
788 if (*(int*)val1 <= *(int*)val2) return true;
789 else return false;
790 }else if (OpGreaterThan == op) {
791 if (*(int*)val1 > *(int*)val2) return true;
792 else return false;
793 }else if (OpLessThan == op) {
794 if (*(int*)val1 < *(int*)val2) return true;
795 else return false;
796 }else if (OpNotEquals == op) {
797 if (*(int*)val1 != *(int*)val2) return true;
798 else return false;
799 }
800
801 }else if(typeString == type) {
802 return AllDataType::compareStringVal(val1, val2, op);
803 } else if (typeShort == type) {
804 return AllDataType::compareShortVal(val1, val2, op);
805 } else if (typeDouble == type) {
806 return AllDataType::compareDoubleVal(val1, val2, op);
807 } else if (typeFloat == type) {
808 return AllDataType::compareFloatVal(val1, val2, op);
809 } else if (typeLong == type) {
810 return AllDataType::compareLongVal(val1, val2, op);
811 } else if (typeLongLong == type) {
812 return AllDataType::compareLongLongVal(val1, val2, op);
813 } else if (typeByteInt == type) {
814 return AllDataType::compareByteIntVal(val1, val2, op);
815 } else if (typeTimeStamp == type) {
816 return AllDataType::compareTimeStampVal(val1, val2, op);
817 } else if (typeDate == type) {
818 return AllDataType::compareDateVal(val1, val2, op);
819 } else if (typeTime == type) {
820 return AllDataType::compareTimeVal(val1, val2, op);
821 } else if (typeBinary == type) {
822 return AllDataType::compareBinaryVal(val1, val2, op, length);
823 } else if (typeComposite == type) {
824 return AllDataType::compareBinaryVal(val1, val2, op, length);
825 }
826 }
827
828 bool AllDataType::compareIntVal(void* src1, void *src2, ComparisionOp op)
829 {
830 printf("This function should never be called by anyone");
831 if (OpEquals == op) {
832 if (*(int*)src1 == *(int*)src2) return true;
833 else return false;
834 }else if (OpGreaterThan == op) {
835 if (*(int*)src1 > *(int*)src2) return true;
836 else return false;
837 }else if (OpLessThan == op) {
838 if (*(int*)src1 < *(int*)src2) return true;
839 else return false;
840 }else if (OpLessThanEquals == op) {
841 if (*(int*)src1 <= *(int*)src2) return true;
842 else return false;
843 }else if (OpGreaterThanEquals == op) {
844 if (*(int*)src1 >= *(int*)src2) return true;
845 else return false;
846 }else if (OpNotEquals == op) {
847 if (*(int*)src1 != *(int*)src2) return true;
848 else return false;
849 }
850 return false;
851 }
852
853 bool AllDataType::compareLongVal(void* src1, void *src2, ComparisionOp op)
854 {
855 bool result = false;
856 switch(op)
857 {
858 case OpEquals:
859 if (*(long*)src1 == *(long*)src2) result = true;
860 else result = false;
861 break;
862 case OpNotEquals:
863 if (*(long*)src1 != *(long*)src2) result = true;
864 else result = false;
865 break;
866 case OpLessThan:
867 if (*(long*)src1 < *(long*)src2) result = true;
868 else result = false;
869 break;
870 case OpLessThanEquals:
871 if (*(long*)src1 <= *(long*)src2) result = true;
872 else result = false;
873 break;
874 case OpGreaterThan:
875 if (*(long*)src1 > *(long*)src2) result = true;
876 else result = false;
877 break;
878 case OpGreaterThanEquals:
879 if (*(long*)src1 >= *(long*)src2) result = true;
880 else result = false;
881 break;
882 }
883 return result;
884 }
885
886 bool AllDataType::compareLongLongVal(void* src1, void *src2,
887 ComparisionOp op)
888 {
889 bool result = false;
890 switch(op)
891 {
892 case OpEquals:
893 if (*(long long*)src1 == *(long long*)src2) result = true;
894 else result = false;
895 break;
896 case OpNotEquals:
897 if (*(long long*)src1 != *(long long*)src2) result = true;
898 else result = false;
899 break;
900 case OpLessThan:
901 if (*(long long*)src1 < *(long long*)src2) result = true;
902 else result = false;
903 break;
904 case OpLessThanEquals:
905 if (*(long long*)src1 <= *(long long*)src2) result = true;
906 else result = false;
907 break;
908 case OpGreaterThan:
909 if (*(long long*)src1 > *(long long*)src2) result = true;
910 else result = false;
911 break;
912 case OpGreaterThanEquals:
913 if (*(long long*)src1 >= *(long long*)src2) result = true;
914 else result = false;
915 break;
916 }
917 return result;
918 }
919
920 bool AllDataType::compareShortVal(void* src1, void *src2, ComparisionOp op)
921 {
922 bool result = false;
923 switch(op)
924 {
925 case OpEquals:
926 if (*(short*)src1 == *(short*)src2) result = true;
927 else result = false;
928 break;
929 case OpNotEquals:
930 if (*(short*)src1 != *(short*)src2) result = true;
931 else result = false;
932 break;
933 case OpLessThan:
934 if (*(short*)src1 < *(short*)src2) result = true;
935 else result = false;
936 break;
937 case OpLessThanEquals:
938 if (*(short*)src1 <= *(short*)src2) result = true;
939 else result = false;
940 break;
941 case OpGreaterThan:
942 if (*(short*)src1 > *(short*)src2) result = true;
943 else result = false;
944 break;
945 case OpGreaterThanEquals:
946 if (*(short*)src1 >= *(short*)src2) result = true;
947 else result = false;
948 break;
949 }
950 return result;
951 }
952
953 bool AllDataType::compareByteIntVal(void* src1, void *src2, ComparisionOp op)
954 {
955 bool result = false;
956 switch(op)
957 {
958 case OpEquals:
959 if (*(ByteInt*)src1 == *(ByteInt*)src2) result = true;
960 else result = false;
961 break;
962 case OpNotEquals:
963 if (*(ByteInt*)src1 != *(ByteInt*)src2) result = true;
964 else result = false;
965 break;
966 case OpLessThan:
967 if (*(ByteInt*)src1 < *(ByteInt*)src2) result = true;
968 else result = false;
969 break;
970 case OpLessThanEquals:
971 if (*(ByteInt*)src1 <= *(ByteInt*)src2) result = true;
972 else result = false;
973 break;
974 case OpGreaterThan:
975 if (*(ByteInt*)src1 > *(ByteInt*)src2) result = true;
976 else result = false;
977 break;
978 case OpGreaterThanEquals:
979 if (*(ByteInt*)src1 >= *(ByteInt*)src2) result = true;
980 else result = false;
981 break;
982 }
983 return result;
984 }
985
986 bool AllDataType::compareDoubleVal(void* src1, void *src2, ComparisionOp op)
987 {
988 bool result = false;
989 switch(op)
990 {
991 case OpEquals:
992 if (*(double*)src1 == *(double*)src2) result = true;
993 else result = false;
994 break;
995 case OpNotEquals:
996 if (*(double*)src1 != *(double*)src2) result = true;
997 else result = false;
998 break;
999 case OpLessThan:
1000 if (*(double*)src1 < *(double*)src2) result = true;
1001 else result = false;
1002 break;
1003 case OpLessThanEquals:
1004 if (*(double*)src1 <= *(double*)src2) result = true;
1005 else result = false;
1006 break;
1007 case OpGreaterThan:
1008 if (*(double*)src1 > *(double*)src2) result = true;
1009 else result = false;
1010 break;
1011 case OpGreaterThanEquals:
1012 if (*(double*)src1 >= *(double*)src2) result = true;
1013 else result = false;
1014 break;
1015 }
1016 return result;
1017 }
1018
1019 bool AllDataType::compareFloatVal(void* src1, void *src2, ComparisionOp op)
1020 {
1021 bool result = false;
1022 switch(op)
1023 {
1024 case OpEquals:
1025 if (*(float*)src1 == *(float*)src2) result = true;
1026 else result = false;
1027 break;
1028 case OpNotEquals:
1029 if (*(float*)src1 != *(float*)src2) result = true;
1030 else result = false;
1031 break;
1032 case OpLessThan:
1033 if (*(float*)src1 < *(float*)src2) result = true;
1034 else result = false;
1035 break;
1036 case OpLessThanEquals:
1037 if (*(float*)src1 <= *(float*)src2) result = true;
1038 else result = false;
1039 break;
1040 case OpGreaterThan:
1041 if (*(float*)src1 > *(float*)src2) result = true;
1042 else result = false;
1043 break;
1044 case OpGreaterThanEquals:
1045 if (*(float*)src1 >= *(float*)src2) result = true;
1046 else result = false;
1047 break;
1048 }
1049 return result;
1050 }
1051
1052 bool AllDataType::compareDateVal(void* src1, void *src2, ComparisionOp op)
1053 {
1054 bool result = false;
1055 switch(op)
1056 {
1057 case OpEquals:
1058 if (*(Date*)src1 == *(Date*)src2) result = true;
1059 else result = false;
1060 break;
1061 case OpNotEquals:
1062 if (*(Date*)src1 != *(Date*)src2) result = true;
1063 else result = false;
1064 break;
1065 case OpLessThan:
1066 if (*(Date*)src1 < *(Date*)src2) result = true;
1067 else result = false;
1068 break;
1069 case OpLessThanEquals:
1070 if (*(Date*)src1 <= *(Date*)src2) result = true;
1071 else result = false;
1072 break;
1073 case OpGreaterThan:
1074 if (*(Date*)src1 > *(Date*)src2) result = true;
1075 else result = false;
1076 break;
1077 case OpGreaterThanEquals:
1078 if (*(Date*)src1 >= *(Date*)src2) result = true;
1079 else result = false;
1080 break;
1081 }
1082 return result;
1083 }
1084
1085 bool AllDataType::compareTimeVal(void* src1, void *src2, ComparisionOp op)
1086 {
1087 bool result = false;
1088 switch(op)
1089 {
1090 case OpEquals:
1091 if (*(Time*)src1 == *(Time*)src2) result = true;
1092 else result = false;
1093 break;
1094 case OpNotEquals:
1095 if (*(Time*)src1 != *(Time*)src2) result = true;
1096 else result = false;
1097 break;
1098 case OpLessThan:
1099 if (*(Time*)src1 < *(Time*)src2) result = true;
1100 else result = false;
1101 break;
1102 case OpLessThanEquals:
1103 if (*(Time*)src1 <= *(Time*)src2) result = true;
1104 else result = false;
1105 break;
1106 case OpGreaterThan:
1107 if (*(Time*)src1 > *(Time*)src2) result = true;
1108 else result = false;
1109 break;
1110 case OpGreaterThanEquals:
1111 if (*(Time*)src1 >= *(Time*)src2) result = true;
1112 else result = false;
1113 break;
1114 }
1115 return result;
1116 }
1117
1118 bool AllDataType::compareTimeStampVal(void* src1, void *src2, ComparisionOp op)
1119 {
1120 bool result = false;
1121 switch(op)
1122 {
1123 case OpEquals:
1124 if (*(TimeStamp*)src1 == *(TimeStamp*)src2) result = true;
1125 else result = false;
1126 break;
1127 case OpNotEquals:
1128 if (*(TimeStamp*)src1 != *(TimeStamp*)src2) result = true;
1129 else result = false;
1130 break;
1131 case OpLessThan:
1132 if (*(TimeStamp*)src1 < *(TimeStamp*)src2) result = true;
1133 else result = false;
1134 break;
1135 case OpLessThanEquals:
1136 if (*(TimeStamp*)src1 <= *(TimeStamp*)src2) result = true;
1137 else result = false;
1138 break;
1139 case OpGreaterThan:
1140 if (*(TimeStamp*)src1 > *(TimeStamp*)src2) result = true;
1141 else result = false;
1142 break;
1143 case OpGreaterThanEquals:
1144 if (*(TimeStamp*)src1 >= *(TimeStamp*)src2) result = true;
1145 else result = false;
1146 break;
1147 }
1148 return result;
1149 }
1150
1151 bool AllDataType::compareStringVal(void* src1, void *src2, ComparisionOp op)
1152 {
1153 if (OpEquals == op) {
1154 if (strcmp((char*)src1, (char*)src2) ==0) return true;
1155 else return false;
1156 }else if (OpGreaterThan == op) {
1157 if (strcmp((char*)src1, (char*)src2) >0) return true;
1158 else return false;
1159 }else if (OpLessThan == op) {
1160 if (strcmp((char*)src1, (char*)src2) <0 ) return true;
1161 else return false;
1162 }else if (OpLessThanEquals == op) {
1163 printf("Illegal Operator:Not Supported for String\n");
1164 return false;
1165 //if (strcmp((char*)src1, (char*)src2)<= 0) return true;
1166 //else return false;
1167 }else if (OpGreaterThanEquals == op) {
1168 printf("Illegal Operator:Not Supported for String\n");
1169 return false;
1170 //if (strcmp((char*)src1, (char*)src2) >=0) return true;
1171 //else return false;
1172 }else if (OpNotEquals == op) {
1173 if (strcmp((char*)src1, (char*)src2) != 0) return true;
1174 else return false;
1175 }else if (OpLike == op) {
1176 return !os::strmatch((char*)src2, (char*)src1);
1177 }
1178 printf("Illegeal Operator:Not supported for String\n");
1179 return false;
1180 }
1181
1182 bool AllDataType::compareBinaryVal(void* src1, void *src2,
1183 ComparisionOp op, int length)
1184 {
1185 bool result = false;
1186 int ret = os::memcmp(src1, src2, length);
1187 switch(op)
1188 {
1189 case OpEquals:
1190 if (ret == 0 ) result= true; else result = false;
1191 break;
1192 case OpNotEquals:
1193 if (ret != 0 ) result= true; else result = false;
1194 break;
1195 case OpLessThan:
1196 if (ret < 0 ) result= true; else result = false;
1197 break;
1198 case OpLessThanEquals:
1199 printf("Illegal Operator:Not Supported for Binary\n");
1200 break;
1201 case OpGreaterThan:
1202 if (ret > 0 ) result= true; else result = false;
1203 break;
1204 case OpGreaterThanEquals:
1205 printf("Illegal Operator:Not Supported for Binary\n");
1206 break;
1207 }
1208 return result;
1209 }
1210
1211
1212
1213 ComparisionOp AllDataType::getComparisionOperator(char *str)
1214 {
1215 ComparisionOp op;
1216 if (strcmp(str, "<=") == 0)
1217 op = OpLessThanEquals;
1218 else if (strcmp(str, ">=") == 0)
1219 op = OpGreaterThanEquals;
1220 else if (strcmp(str, "<") == 0)
1221 op = OpLessThan;
1222 else if (strcmp(str, ">") == 0)
1223 op = OpGreaterThan;
1224 else if (strcmp(str, "=") == 0)
1225 op = OpEquals;
1226 else if (strcmp(str, "!=") == 0 || strcmp(str, "<>") == 0 )
1227 op = OpNotEquals;
1228 else if (strcasecmp(str, "LIKE") == 0 )
1229 op = OpLike;
1230 else
1231 op = OpInvalidComparisionOp;
1232 return op;
1233 }
1234
1235 void* AllDataType::alloc(DataType type, int length)
1236 {
1237 void *dest;
1238 switch(type)
1239 {
1240 case typeInt:
1241 dest = malloc(sizeof(int));
1242 break;
1243 case typeLong:
1244 dest = malloc(sizeof(long));
1245 break;
1246 case typeLongLong:
1247 dest = malloc(sizeof(long long));
1248 break;
1249 case typeShort:
1250 dest = malloc(sizeof(short));
1251 break;
1252 case typeByteInt:
1253 dest = malloc(sizeof(char));
1254 break;
1255 case typeDouble:
1256 dest = malloc(sizeof(double));
1257 break;
1258 case typeFloat:
1259 dest = malloc(sizeof(float));
1260 break;
1261 case typeDecimal:
1262 //TODO::for porting
1263 //fldDef.length_ = sizeof(long double);
1264 break;
1265 case typeString:
1266 if (length == 0 ) return NULL;
1267 dest = malloc(length);
1268 break;
1269 case typeBinary:
1270 if (length == 0 || length > 512) return NULL;
1271 dest = malloc(length);
1272 memset(dest, 0, length);
1273 break;
1274 case typeDate:
1275 dest = malloc(sizeof(Date));
1276 break;
1277 case typeTime:
1278 dest = malloc(sizeof(Time));
1279 break;
1280 case typeTimeStamp:
1281 dest = malloc(sizeof(TimeStamp));
1282 break;
1283 }
1284 return dest;
1285 }
1286
1287 void AllDataType::memoryset(void *value,DataType type)
1288 {
1289 switch(type)
1290 {
1291 case typeInt:
1292 value=os::memset(value, 0, sizeof(int));
1293 break;
1294 case typeLong:
1295 value = os::memset(value, 0, sizeof(long));
1296 break;
1297 case typeLongLong:
1298 value =os::memset(value, 0, sizeof(long long));
1299 break;
1300 case typeShort:
1301 value = os::memset(value, 0, sizeof(short));
1302 break;
1303 case typeByteInt:
1304 value = os::memset(value, 0, sizeof(char));
1305 break;
1306 case typeDouble:
1307 value = os::memset(value, 0, sizeof(double));
1308 break;
1309 case typeFloat:
1310 value = os::memset(value, 0, sizeof(float));
1311 break;
1312 case typeDecimal:
1313 break;
1314 case typeString:
1315 *(char*)value = '\0';
1316 //if (length == 0 ) return NULL;
1317 //dest = malloc(length);
1318 break;
1319 case typeBinary:
1320 /* if (length == 0 || length > 256 ) return NULL;
1321
1322 memset(dest, 0, length);*/
1323 break;
1324 case typeDate:
1325 value = os::memset(value, 0, sizeof(Date));
1326 break;
1327 case typeTime:
1328 value = os::memset(value, 0, sizeof(Time));
1329 break;
1330 case typeTimeStamp:
1331 value = os::memset(value, 0, sizeof(TimeStamp));
1332 break;
1333 defalut:
1334 break;
1335 }
1336 }
1337
1338
1339 DbRetVal AllDataType::strToValue(void* dest, char *src, DataType type, int length)
1340 {
1341 switch(type)
1342 {
1343 case typeInt: {
1344 int val;
1345 sscanf( src, "%d", &val);
1346 *(int*)dest = val;
1347 break; }
1348 case typeLong: {
1349 long val;
1350 sscanf( src, "%ld", &val);
1351 *(long*)dest = val;
1352 break; }
1353 case typeLongLong: {
1354 long long val;
1355 sscanf( src, "%lld", &val);
1356 *(long long*)dest = val;
1357 break; }
1358 case typeShort: {
1359 short val;
1360 sscanf( src, "%hd", &val);
1361 *(short*)dest = val;
1362 break; }
1363 case typeByteInt: {
1364 int val;
1365 sscanf( src, "%d", &val);
1366 *(char*)dest = *(char *)&val;
1367 break; }
1368 case typeDouble: {
1369 double val;
1370 sscanf( src, "%lg", &val);
1371 *(double*)dest = val;
1372 break; }
1373 case typeFloat: {
1374 float val;
1375 sscanf( src, "%f", &val);
1376 *(float*)dest = val;
1377 break; }
1378 case typeDecimal:
1379 //TODO::for porting
1380 case typeString: {
1381 strncpy((char*)dest, (char*)src, length);
1382 char *d =(char*)dest;
1383 d[length-1] = '\0';
1384 break;}
1385 case typeDate: {
1386 int d,m,y,res=0;
1387 res = sscanf( src, "%d-%d-%d", &y, &m, &d );
1388 if( res != 3 )
1389 res = sscanf( src, "%d/%d/%d", &y, &m, &d );
1390 if( res != 3 )
1391 {
1392 fprintf(stderr,"Error reading date. yyyy{-/}mm{-/}dd is the valid format.");
1393 d=m=y=0;
1394 }
1395 Date dateObj(y,m,d);
1396 *(Date*)dest = dateObj;
1397 break; }
1398 case typeTime: {
1399 int h,m,s,res=0;
1400 res = sscanf( src, "%d:%d:%d", &h, &m, &s );
1401 if( res != 3 )
1402 {
1403 fprintf(stderr, "Error reading time, hh:mm:ss is the valid format.");
1404 h=m=s=0;
1405 }
1406 Time timeObj(h,m,s);
1407 *(Time*)dest = timeObj;
1408 break; }
1409 case typeTimeStamp: {
1410 int d,m,y, h,mn,s, res=0;
1411 res = sscanf( src, "%d-%d-%d %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1412 if( res != 6 )
1413 res = sscanf( src, "%d-%d-%d, %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1414 if( res != 6 )
1415 res = sscanf( src, "%d/%d/%d %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1416 if( res != 6 )
1417 res = sscanf( src, "%d/%d/%d, %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1418 if( res != 6 )
1419 {
1420 fprintf(stderr, "Error reading timestamp, yyyy{-/}mm{-/}dd[,] hh:mm:ss is the valid format.");
1421 d=m=y=h=mn=s=0;
1422 }
1423 TimeStamp timeStampObj(y,m,d,h,mn,s);
1424 *(TimeStamp*)dest = timeStampObj;
1425 break; }
1426 case typeBinary: {
1427 memset ((void *) dest, 0, length);
1428 unsigned char c = 0;
1429 const char *str = (const char *)src;
1430 int i=0;
1431 i = strlen(src)-1;
1432 bool evenlegth=false;
1433 if(i%2){ evenlegth=true;}
1434 unsigned char *val = (unsigned char *)dest+(length-1);
1435 while (i >= 0) {
1436 c = str[i];
1437 if (!isxdigit((int)c)) {
1438 printError(ErrBadArg, "Invalid hexadecimal value");
1439 return ErrBadArg;
1440 }
1441 if (c <= '9') c -= '0';
1442 else if (c >= 'a') c = c - 'a' + 10;
1443 else c = c - 'A' + 10;
1444 if(evenlegth)
1445 {
1446 if ((i+1) % 2) { *val = *val | (c<<4); val--;}
1447 else { *val = c; }
1448 }else{
1449 if (i % 2) { *val = *val | (c<<4); val--;}
1450 else { *val = c; }
1451 }
1452 i--;
1453 }
1454 break;
1455 }
1456 default:
1457 break;
1458 }
1459 return OK;
1460 }
1461
1462
1463 void AllDataType::convert(DataType srcType, void *src,
1464 DataType destType, void *dest, int length)
1465 {
1466 switch ((DataType) destType )
1467 {
1468 case typeInt: convertToInt(dest, src, srcType); break;
1469 case typeLong: convertToLong(dest, src, srcType); break;
1470 case typeLongLong: convertToLongLong(dest, src, srcType); break;
1471 case typeShort: convertToShort(dest, src, srcType); break;
1472 case typeByteInt: convertToByteInt(dest, src, srcType); break;
1473
1474 case typeFloat: convertToFloat(dest, src, srcType); break;
1475 case typeDouble: convertToDouble(dest, src, srcType); break;
1476
1477 //TODO
1478 case typeDecimal: convertToDouble(dest, src, srcType); break;
1479
1480 case typeString: convertToString(dest, src, srcType); break;
1481 case typeBinary: convertToBinary(dest, src, srcType,length); break;
1482 case typeDate: convertToDate(dest, src, srcType); break;
1483 case typeTime: convertToTime(dest, src, srcType); break;
1484 case typeTimeStamp: convertToTimeStamp(dest, src, srcType); break;
1485 default: return;
1486 }
1487 }
1488
1489 void AllDataType::convertToInt( void* dest, void* src, DataType srcType )
1490 {
1491 switch(srcType)
1492 {
1493 case typeInt: *(int *)dest = *(int *)src; break;
1494 case typeLong: *(int *)dest =(int) *(long *)src; break;
1495 case typeLongLong: *(int *)dest =(int) *(long long *)src; break;
1496 case typeShort: *(int *)dest =(int) *(short *)src; break;
1497 case typeByteInt: *(int *)dest =(int) *(char *)src; break;
1498
1499 case typeFloat: *(int *)dest = (int) *(float *)src; break;
1500 case typeDouble: *(int *)dest =(int) *(double *)src; break;
1501
1502 case typeString: sscanf((const char*)src, "%d", (int*) dest); break;
1503
1504 case typeDate:
1505 case typeTime:
1506 case typeTimeStamp:
1507 case typeBinary:
1508 default: *(int *)dest = (int) 0;
1509 }
1510 }
1511
1512 void AllDataType::convertToLong( void* dest, void* src, DataType srcType )
1513 {
1514 switch(srcType)
1515 {
1516 case typeInt: *(long *)dest =(long) *(int *)src; break;
1517 case typeLong: *(long *)dest = *(long *)src; break;
1518 case typeLongLong: *(long *)dest =(long) *(long long *)src; break;
1519 case typeShort: *(long *)dest =(long) *(short *)src; break;
1520 case typeByteInt: *(long *)dest =(long) *(char *)src; break;
1521
1522 case typeFloat: *(long *)dest = (long) *(float *)src; break;
1523 case typeDouble: *(long *)dest =(long) *(double *)src; break;
1524
1525 case typeString: sscanf((const char*)src, "%ld", (long*) dest); break;
1526
1527 case typeDate:
1528 case typeTime:
1529 case typeTimeStamp:
1530 case typeBinary:
1531 default: *(long *)dest = (long) 0;
1532 }
1533 }
1534
1535
1536 void AllDataType::convertToLongLong( void* dest, void* src, DataType srcType )
1537 {
1538 switch(srcType)
1539 {
1540 case typeInt: *(long long *)dest =(long long) *(int *)src; break;
1541 case typeLong: *(long long *)dest = (long long) *(long *)src; break;
1542 case typeLongLong: *(long long *)dest = *(long long *)src; break;
1543 case typeShort: *(long long *)dest =(long long) *(short *)src; break;
1544 case typeByteInt: *(long long *)dest =(long long) *(char *)src; break;
1545
1546 case typeFloat: *(long long *)dest = (long long) *(float *)src; break;
1547 case typeDouble: *(long long *)dest =(long long) *(double *)src; break;
1548
1549 case typeString: sscanf((const char*)src, "%lld", (long long*) dest); break;
1550
1551 case typeDate:
1552 case typeTime:
1553 case typeTimeStamp:
1554 case typeBinary:
1555 default: *(long long *)dest = (long long) 0;
1556 }
1557 }
1558
1559 void AllDataType::convertToShort( void* dest, void* src, DataType srcType )
1560 {
1561 switch(srcType)
1562 {
1563 case typeInt: *(short*)dest =(short) *(int*)src; break;
1564 case typeLong: *(short*)dest = (short) *(long*)src; break;
1565 case typeLongLong: *(short*)dest = (short) *(long long*)src; break;
1566 case typeShort: *(short*)dest = *(short*)src; break;
1567 case typeByteInt: *(short*)dest =(short) *(char *)src; break;
1568
1569 case typeFloat: *(short*)dest = (short) *(float *)src; break;
1570 case typeDouble: *(short*)dest =(short) *(double *)src; break;
1571
1572 case typeString: sscanf((const char*)src, "%hd", (short*) dest); break;
1573
1574 case typeDate:
1575 case typeTime:
1576 case typeTimeStamp:
1577 case typeBinary:
1578 default: *(short*)dest = (short) 0;
1579 }
1580 }
1581
1582 void AllDataType::convertToByteInt( void* dest, void* src, DataType srcType )
1583 {
1584 switch(srcType)
1585 {
1586 case typeInt: *(char*)dest = (char) *(int*)src; break;
1587 case typeLong: *(char*)dest = (char) *(long*)src; break;
1588 case typeLongLong: *(char*)dest = (char) *(long long*)src; break;
1589 case typeShort: *(char*)dest = (char) *(short*)src; break;
1590 case typeByteInt: *(char*)dest = *(char *)src; break;
1591
1592 case typeFloat: *(char*)dest = (char) *(float *)src; break;
1593 case typeDouble: *(char*)dest =(char) *(double *)src; break;
1594
1595 case typeString: sscanf((const char*)src, "%c", (char*) dest); break;
1596
1597 case typeDate:
1598 case typeTime:
1599 case typeTimeStamp:
1600 case typeBinary:
1601 default: *(char*)dest = (char) 0;
1602 }
1603 }
1604
1605 void AllDataType::convertToFloat( void* dest, void* src, DataType srcType )
1606 {
1607 switch(srcType)
1608 {
1609 case typeInt: *(float *)dest =(float) *(int *)src; break;
1610 case typeLong: *(float *)dest =(float) *(long *)src; break;
1611 case typeLongLong: *(float *)dest =(float) *(long long *)src; break;
1612 case typeShort: *(float *)dest =(float) *(short *)src; break;
1613 case typeByteInt: *(float *)dest =(float) *(char *)src; break;
1614
1615 case typeFloat: *(float *)dest = *(float *)src; break;
1616 case typeDouble: *(float *)dest =(float) *(double *)src; break;
1617
1618 case typeString: sscanf((const char*)src, "%f", (float*) dest); break;
1619
1620 case typeDate:
1621 case typeTime:
1622 case typeTimeStamp:
1623 case typeBinary:
1624 default: *(float *)dest = (float) 0;
1625 }
1626 }
1627
1628 void AllDataType::convertToDouble( void* dest, void* src, DataType srcType )
1629 {
1630 switch(srcType)
1631 {
1632 case typeInt: *(double *)dest =(double) *(int *)src; break;
1633 case typeLong: *(double *)dest =(double) *(long *)src; break;
1634 case typeLongLong: *(double *)dest =(double) *(long long *)src; break;
1635 case typeShort: *(double *)dest =(double) *(short *)src; break;
1636 case typeByteInt: *(double *)dest =(double) *(char *)src; break;
1637
1638 case typeFloat: *(double *)dest =(double) *(float *)src; break;
1639 case typeDouble: *(double *)dest = *(double *)src; break;
1640
1641 case typeString: sscanf((const char*)src, "%lf", (double*) dest); break;
1642
1643 case typeDate:
1644 case typeTime:
1645 case typeTimeStamp:
1646 case typeBinary:
1647 default: *(double *)dest = (double) 0;
1648 }
1649 }
1650
1651 void AllDataType::convertToString( void* dest, void* src, DataType srcType, int length )
1652 {
1653 switch(srcType)
1654 {
1655 case typeInt:
1656 {
1657 sprintf ((char *)dest, "%d", *(int *)src);
1658 break;
1659 }
1660 case typeLong:
1661 {
1662 sprintf ((char *)dest, "%ld", *(long *)src);
1663 break;
1664 }
1665 case typeLongLong:
1666 {
1667 sprintf ((char *)dest, "%lld", *(long long *)src);
1668 break;
1669 }
1670 case typeShort:
1671 {
1672 sprintf ((char *)dest, "%hd", *(short *)src);
1673 break;
1674 }
1675 case typeByteInt:
1676 {
1677 sprintf ((char *)dest, "%hd", *(char *)src);
1678 break;
1679 }
1680
1681 case typeFloat:
1682 {
1683 sprintf ((char *)dest, "%f", *(float *)src);
1684 break;
1685 }
1686 case typeDouble:
1687 {
1688 sprintf ((char *) dest, "%lf", *(double *)src);
1689 break;
1690 }
1691
1692 case typeString:
1693 {
1694 strcpy((char*)dest, (char*)src);
1695 break;
1696 }
1697 case typeDate:
1698 {
1699 Date* dt = (Date*)src;
1700 sprintf((char*) dest, "%d/%d/%d", dt->year(),
1701 dt->month(), dt->dayOfMonth());
1702 break;
1703 }
1704 case typeTime:
1705 {
1706 Time* tm = (Time*)src;
1707 sprintf((char*)dest,"%d:%d:%d.%d", tm->hours(), tm->minutes(), tm->seconds(), 0);
1708 break;
1709 }
1710 case typeTimeStamp:
1711 {
1712 TimeStamp* tm = (TimeStamp*)src;
1713 sprintf((char*)dest, "%d/%d/%d %d:%d:%d.%d", tm->year(),
1714 tm->month(), tm->dayOfMonth(), tm->hours(),
1715 tm->minutes(), tm->seconds(), 0 );
1716 break;
1717 }
1718 case typeBinary:
1719 {
1720 unsigned char *c = (unsigned char *) src;
1721 unsigned char *str = (unsigned char *) dest;
1722 unsigned char p = 0;
1723 int i = 0;
1724 while (i < length) {
1725 p = *c >> 4;
1726 if (p < 10) sprintf ((char *)str++, "%c", '0' + p);
1727 else sprintf((char *)str++, "%c", 'A' + p - 10);
1728 p = *c & 0xF;
1729 if (p < 10) sprintf ((char *)str++, "%c", '0' + p);
1730 else sprintf((char *)str++, "%c", 'A' + p - 10);
1731 i++; c++;
1732 }
1733 break;
1734 }
1735
1736 default: ((char*)dest)[0] = '\0';
1737 }
1738
1739 }
1740 void AllDataType::convertToDate( void* dest, void* src, DataType srcType )
1741 {
1742 switch(srcType)
1743 {
1744 case typeInt:
1745 case typeLong:
1746 case typeLongLong:
1747 case typeShort:
1748 case typeByteInt:
1749 case typeFloat:
1750 case typeDouble:
1751 case typeDate:
1752 case typeTime:
1753 case typeTimeStamp:
1754 case typeString:
1755 {
1756 Date *dt = (Date*) dest;
1757 dt->parseFrom((char*)src);
1758 break;
1759 }
1760 default: ((char*)dest)[0] = '\0';
1761 }
1762 }
1763
1764 void AllDataType::convertToTime( void* dest, void* src, DataType srcType )
1765 {
1766 switch(srcType)
1767 {
1768 case typeInt:
1769 case typeLong:
1770 case typeLongLong:
1771 case typeShort:
1772 case typeByteInt:
1773 case typeFloat:
1774 case typeDouble:
1775 case typeDate:
1776 case typeTime:
1777 case typeTimeStamp:
1778 case typeString:
1779 {
1780 Time *dt = (Time*) dest;
1781 dt->parseFrom((char*)src);
1782 break;
1783 }
1784 default: ((char*)dest)[0] = '\0';
1785 }
1786 }
1787
1788 void AllDataType::convertToTimeStamp( void* dest, void* src, DataType srcType )
1789 {
1790 switch(srcType)
1791 {
1792 case typeInt:
1793 case typeLong:
1794 case typeLongLong:
1795 case typeShort:
1796 case typeByteInt:
1797 case typeFloat:
1798 case typeDouble:
1799 case typeDate:
1800 case typeTime:
1801 case typeTimeStamp:
1802 case typeString:
1803 {
1804 TimeStamp *dt = (TimeStamp*) dest;
1805 dt->parseFrom((char*)src);
1806 break;
1807 }
1808 default: ((char*)dest)[0] = '\0';
1809 }
1810 }
1811
1812 void AllDataType::convertToBinary(void *dest, void *src, DataType srcType, int length)
1813 {
1814 switch(srcType)
1815 {
1816 case typeString:
1817 {
1818 memset ((void *) dest, 0, length);
1819 unsigned char c = 0;
1820 const char *str = (const char *)src;
1821 int i=0;
1822 i = strlen((char*)src)-1;
1823 bool evenlegth=false;
1824 if(i%2){ evenlegth=true;}
1825 unsigned char *val = (unsigned char *)dest+(length-1);
1826 while (i >= 0) {
1827 c = str[i];
1828 if (c <= '9') c -= '0';
1829 else if (c >= 'a') c = c - 'a' + 10;
1830 else c = c - 'A' + 10;
1831 if(evenlegth)
1832 {
1833 if ((i+1) % 2) { *val = *val | (c<<4); val--;}
1834 else { *val = c; }
1835 }else{
1836 if (i % 2) { *val = *val | (c<<4); val--;}
1837 else { *val = c; }
1838 }
1839 i--;
1840 }
1841 break;
1842 }
1843 }
1844 }
1845 int AllDataType::printVal(void* src, DataType srcType, int length )
1846 {
1847 int count = 0;
1848 switch(srcType)
1849 {
1850 case typeInt:
1851 {
1852 count = printf ("%d", *(int *)src);
1853 break;
1854 }
1855 case typeLong:
1856 {
1857 count = printf ("%ld", *(long *)src);
1858 break;
1859 }
1860 case typeLongLong:
1861 {
1862 count = printf ("%lld", *(long long *)src);
1863 break;
1864 }
1865 case typeShort:
1866 {
1867 count = printf("%hd", *(short *)src);
1868 break;
1869 }
1870 case typeByteInt:
1871 {
1872 count = printf("%hd", *(char *)src);
1873 break;
1874 }
1875
1876 case typeFloat:
1877 {
1878 count = printf("%f", *(float *)src);
1879 break;
1880 }
1881 case typeDouble:
1882 {
1883 count = printf("%lf", *(double *)src);
1884 break;
1885 }
1886
1887 case typeString:
1888 {
1889 count = printf("%s", (char*)src);
1890 break;
1891 }
1892 case typeDate:
1893 {
1894 Date* dt = (Date*)src;
1895 count = printf("%d/%d/%d", dt->year(),
1896 dt->month(), dt->dayOfMonth());
1897 break;
1898 }
1899 case typeTime:
1900 {
1901 Time* tm = (Time*)src;
1902 count = printf("%d:%d:%d.%d", tm->hours(), tm->minutes(), tm->seconds(), 0);
1903 break;
1904 }
1905 case typeTimeStamp:
1906 {
1907 TimeStamp* tm = (TimeStamp*)src;
1908 count = printf("%d/%d/%d %d:%d:%d.%d", tm->year(),
1909 tm->month(), tm->dayOfMonth(), tm->hours(),
1910 tm->minutes(), tm->seconds(), 0 );
1911 break;
1912 }
1913 case typeBinary:
1914 {
1915 unsigned char *c = (unsigned char *) src;
1916 unsigned char p = 0;
1917 int i = 0;
1918 bool isDigitFound=false;
1919 while (i < length) {
1920 p = *c >> 4;
1921 if(('0'+p)!='0'|| isDigitFound){
1922 if (p < 10) printf ("%c", '0' + p);
1923 else printf("%c", 'A' + p - 10);
1924 isDigitFound=true;
1925 }
1926 p = *c & 0xF;
1927 if(('0'+p)!='0' || isDigitFound){
1928 if (p < 10) printf ("%c", '0' + p);
1929 else printf("%c", 'A' + p - 10);
1930 isDigitFound=true;
1931 }
1932 i++; c++;
1933 }
1934 count = length * 2;
1935 break;
1936 }
1937 default: { printf("DataType not supported\n"); break; }
1938 }
1939 return count;
1940 }
1941
1942
1943
Main memory database SQL engine (cvs import)