?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
performance fixes
[csql.git] / src / storage / DataType.cxx
blob60fe56a6f4215aaef7ddb1cd4c8249e7e1bec40a
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 case typeComposite:
372 size = length;
373 break;
374 default:
375 size = 0;
376 break;
377 }
378 return size;
379 }
380 */
381 char* AllDataType::getSQLString(DataType type)
382 {
383 switch(type)
384 {
385 case typeInt: return "INT";
386 case typeLong: return "INT";
387 case typeLongLong: return "BIGINT";
388 case typeShort: return "SMALLINT";
389 case typeByteInt: return "TINYINT";
390 case typeDouble: return "REAL";
391 case typeFloat: return "FLOAT";
392 case typeDate: return "DATE";
393 case typeTime: return "TIME";
394 case typeTimeStamp: return "TIMESTAMP";
395 case typeString: return "CHAR";
396 case typeBinary: return "BINARY";
397 default: return "UNKNOWN";
398 }
399 }
400
401
402 SQLSMALLINT AllDataType::convertToSQLType(DataType type)
403 {
404 switch(type)
405 {
406 case typeInt:
407 return SQL_INTEGER;
408 case typeLong:
409 return SQL_INTEGER;
410 case typeLongLong:
411 //TODO
412 return SQL_INTEGER;
413 case typeShort:
414 return SQL_SMALLINT;
415 case typeByteInt:
416 //TODO
417 return SQL_INTEGER;
418 case typeDouble:
419 return SQL_DOUBLE;
420 case typeFloat:
421 return SQL_REAL;
422 case typeDecimal:
423 //TODO
424 return SQL_INTEGER;
425 case typeDate:
426 return SQL_TYPE_DATE;
427 case typeTime:
428 return SQL_TYPE_TIME;
429 case typeTimeStamp:
430 return SQL_TYPE_TIMESTAMP;
431 case typeString:
432 return SQL_CHAR;
433 case typeBinary:
434 return SQL_BINARY;
435 }
436 return SQL_INTEGER;
437 }
438 SQLSMALLINT AllDataType::convertToSQL_C_Type(DataType type)
439 {
440 switch(type)
441 {
442 case typeInt:
443 return SQL_C_SLONG;
444 case typeLong:
445 return SQL_C_SLONG;
446 case typeLongLong:
447 return SQL_C_SBIGINT;
448 case typeShort:
449 return SQL_C_SSHORT;
450 case typeByteInt:
451 return SQL_C_STINYINT;
452 case typeDouble:
453 return SQL_C_DOUBLE;
454 case typeFloat:
455 return SQL_C_FLOAT;
456 case typeDecimal:
457 //TODO
458 return SQL_INTEGER;
459 case typeDate:
460 return SQL_C_TYPE_DATE;
461 case typeTime:
462 return SQL_C_TYPE_TIME;
463 case typeTimeStamp:
464 return SQL_C_TYPE_TIMESTAMP;
465 case typeString:
466 return SQL_C_CHAR;
467 case typeBinary:
468 return SQL_C_BINARY;
469 }
470 return SQL_C_SLONG;
471 }
472
473 DataType AllDataType::convertFromSQLType(SQLSMALLINT type)
474 {
475 switch(type)
476 {
477 case SQL_INTEGER :
478 return typeInt;
479 case SQL_SMALLINT:
480 return typeShort;
481 case SQL_DOUBLE:
482 return typeDouble;
483 case SQL_FLOAT:
484 case SQL_REAL:
485 return typeFloat;
486 case SQL_TYPE_DATE:
487 return typeDate;
488 case SQL_TYPE_TIME :
489 return typeTime;
490 case SQL_TYPE_TIMESTAMP :
491 return typeTimeStamp;
492 case SQL_CHAR:
493 return typeString;
494 case SQL_VARCHAR:
495 return typeString;
496 case SQL_BINARY:
497 return typeBinary;
498 }
499 return typeInt;
500 }
501 /*
502 void AllDataType::copyVal(void* dest, void *src, DataType type, int length)
503 {
504 //Performance optimization. putting likely case first
505 if (typeInt == type )
506 {
507 *(int*)dest = *(int*)src;
508 return;
509 }else if (typeString == type)
510 {
511 //null is always put at the last byte by insert
512 //so using strcpy is safe
513 strcpy((char*)dest, (char*)src);
514 //strncpy((char*)dest, (char*)src, length);
515 //char *d =(char*)dest;
516 //d[length-1] = '\0';
517 return;
518 }else if (typeShort == type) {
519 *(short*)dest = *(short*)src;
520 }else if (typeDouble == type) {
521 *(double*)dest = *(double*)src;
522 }else if (typeTimeStamp == type) {
523 *(TimeStamp*)dest = *(TimeStamp*)src;
524 }else if (typeDate == type) {
525 *(Date*)dest = *(Date*)src;
526 }else if (typeFloat == type) {
527 *(float*)dest = *(float*)src;
528 }else if (typeTime == type) {
529 *(Time*)dest = *(Time*)src;
530 }else if (typeLong == type) {
531 *(long*)dest = *(long*)src;
532 }else if (typeLongLong == type) {
533 *(long long*)dest = *(long long*)src;
534 }else if (typeByteInt == type) {
535 *(char*)dest = *(char*)src;
536 }else if (typeBinary == type) {
537 os::memcpy(dest, src, length);
538 }else if (typeComposite == type) {
539 os::memcpy(dest, src, length);
540 }
541 return;
542 }
543
544 void AllDataType::addVal(void* dest, void *src, DataType type)
545 {
546 if (type == typeInt)
547 {
548 *(int*)dest = *(int*)dest + *(int*)src;
549 return;
550 }
551 switch(type)
552 {
553 case typeInt:
554 *(int*)dest = *(int*)dest + *(int*)src;
555 break;
556 case typeLong:
557 *(long*)dest = *(long*)dest + *(long*)src;
558 break;
559 case typeLongLong:
560 *(long long*)dest = *(long long*)dest + *(long long*)src;
561 break;
562 case typeShort:
563 *(short*)dest = *(short*)dest + *(short*)src;
564 break;
565 case typeByteInt:
566 *(char*)dest = *(char*)dest + *(char*)src;
567 break;
568 case typeDouble:
569 *(double*)dest = *(double*)dest + *(double*)src;
570 break;
571 case typeFloat:
572 *(float*)dest = *(float*)dest + *(float*)src;
573 break;
574 case typeDecimal:
575 //TODO::for porting
576 case typeDate:
577 case typeTime:
578 case typeTimeStamp:
579 case typeBinary:
580 default:
581 break;
582 }
583 return;
584 }
585 */
586 void AllDataType::subVal(void* dest, void *src, DataType type)
587 {
588 switch(type)
589 {
590 case typeInt:
591 *(int*)dest = *(int*)dest - *(int*)src;
592 break;
593 case typeLong:
594 *(long*)dest = *(long*)dest - *(long*)src;
595 break;
596 case typeLongLong:
597 *(long long*)dest = *(long long*)dest - *(long long*)src;
598 break;
599 case typeShort:
600 *(short*)dest = *(short*)dest - *(short*)src;
601 break;
602 case typeByteInt:
603 *(char*)dest = *(char*)dest - *(char*)src;
604 break;
605 case typeDouble:
606 *(double*)dest = *(double*)dest - *(double*)src;
607 break;
608 case typeFloat:
609 *(float*)dest = *(float*)dest - *(float*)src;
610 break;
611 case typeDecimal:
612 case typeDate:
613 case typeTime:
614 case typeTimeStamp:
615 case typeBinary:
616 default:
617 break;
618 }
619 return;
620 }
621 void AllDataType::mulVal(void* dest, void *src, DataType type)
622 {
623 switch(type)
624 {
625 case typeInt:
626 *(int*)dest = *(int*)dest * (*(int*)src);
627 break;
628 case typeLong:
629 *(long*)dest = *(long*)dest * (*(long*)src);
630 break;
631 case typeLongLong:
632 *(long long*)dest = *(long long*)dest * (*(long long*)src);
633 break;
634 case typeShort:
635 *(short*)dest = *(short*)dest * (*(short*)src);
636 break;
637 case typeByteInt:
638 *(char*)dest = *(char*)dest * (*(char*)src);
639 break;
640 case typeDouble:
641 *(double*)dest = *(double*)dest * (*(double*)src);
642 break;
643 case typeFloat:
644 *(float*)dest = *(float*)dest * (*(float*)src);
645 break;
646 case typeDecimal:
647 case typeDate:
648 case typeTime:
649 case typeTimeStamp:
650 case typeBinary:
651 default:
652 break;
653 }
654 return;
655 }
656 void AllDataType::mudVal(void* dest, void *src, DataType type)
657 {
658 if (type == typeInt)
659 {
660 *(int*)dest = *(int*)dest % (*(int*)src);
661 return;
662 }
663 switch(type)
664 {
665 case typeInt:
666 *(int*)dest = *(int*)dest % (*(int*)src);
667 break;
668 case typeLong:
669 *(long*)dest = *(long*)dest % (*(long*)src);
670 break;
671 case typeLongLong:
672 *(long long*)dest = *(long long*)dest % (*(long long*)src);
673 break;
674 case typeShort:
675 *(short*)dest = *(short*)dest % (*(short*)src);
676 break;
677 case typeByteInt:
678 *(char*)dest = *(char*)dest % (*(char*)src);
679 break;
680 case typeDouble:
681 *(double*)dest = *(long long*)dest % (*(long long*)src);
682 break;
683 case typeFloat:
684 *(float*)dest = *(int*)dest % (*(int*)src);
685 break;
686 case typeDecimal:
687 case typeDate:
688 case typeTime:
689 case typeTimeStamp:
690 case typeBinary:
691 default:
692 break;
693 }
694 return;
695 }
696 void AllDataType::divVal(void* dest, void *src, DataType type)
697 {
698 if (type == typeInt)
699 {
700 *(int*)dest = *(int*)dest / (*(int*)src);
701 return;
702 }
703 switch(type)
704 {
705 case typeInt:
706 *(int*)dest = *(int*)dest / (*(int*)src);
707 break;
708 case typeLong:
709 *(long*)dest = *(long*)dest / (*(long*)src);
710 break;
711 case typeLongLong:
712 *(long long*)dest = *(long long*)dest / (*(long long*)src);
713 break;
714 case typeShort:
715 *(short*)dest = *(short*)dest / (*(short*)src);
716 break;
717 case typeByteInt:
718 *(char*)dest = *(char*)dest / (*(char*)src);
719 break;
720 case typeDouble:
721 *(double*)dest = *(double *)dest / (*(double*)src);
722 break;
723 case typeFloat:
724 *(float*)dest = *(float*)dest / (*(float*)src);
725 break;
726 case typeDecimal:
727 case typeDate:
728 case typeTime:
729 case typeTimeStamp:
730 case typeBinary:
731 default:
732 break;
733 }
734 return;
735 }
736 void AllDataType::divVal(void* dest, int src, DataType type)
737 {
738 if(type == typeInt)
739 {
740 *(int*)dest = *(int*)dest / src;
741 return;
742 }
743 switch(type)
744 {
745 case typeInt:
746 *(int*)dest = *(int*)dest / src;
747 break;
748 case typeLong:
749 *(long*)dest = *(long*)dest / src;
750 break;
751 case typeLongLong:
752 *(long long*)dest = *(long long*)dest / src;
753 break;
754 case typeShort:
755 *(short*)dest = *(short*)dest / src;
756 break;
757 case typeByteInt:
758 *(char*)dest = *(char*)dest / src;
759 break;
760 case typeDouble:
761 *(double*)dest = *(double*)dest / src;
762 break;
763 case typeFloat:
764 *(float*)dest = *(float*)dest / src;
765 break;
766 case typeDecimal:
767 //TODO::for porting
768 case typeDate:
769 case typeTime:
770 case typeTimeStamp:
771 case typeBinary:
772 default:
773 break;
774 }
775 return;
776 }
777 /*
778 bool AllDataType::compareVal(void *val1, void *val2, ComparisionOp op,
779 DataType type, long length)
780 {
781 //Performance optimization.
782 //do not convert compareXXXVal to virtual functions. it takes more time
783 if (typeInt == type)
784 {
785 //as int is the heavily used type, hardcoding the compare here itself
786 if (OpEquals == op) {
787 if (*(int*)val1 == *(int*)val2) return true;
788 else return false;
789 }else if (OpLessThanEquals == op) {
790 if (*(int*)val1 <= *(int*)val2) return true;
791 else return false;
792 }else if (OpGreaterThanEquals == op) {
793 if (*(int*)val1 >= *(int*)val2) return true;
794 else return false;
795 }else if (OpGreaterThan == op) {
796 if (*(int*)val1 > *(int*)val2) return true;
797 else return false;
798 }else if (OpLessThan == op) {
799 if (*(int*)val1 < *(int*)val2) return true;
800 else return false;
801 }else if (OpNotEquals == op) {
802 if (*(int*)val1 != *(int*)val2) return true;
803 else return false;
804 }
805
806 }else if(typeString == type) {
807 return AllDataType::compareStringVal(val1, val2, op);
808 } else if (typeShort == type) {
809 return AllDataType::compareShortVal(val1, val2, op);
810 } else if (typeDouble == type) {
811 return AllDataType::compareDoubleVal(val1, val2, op);
812 } else if (typeFloat == type) {
813 return AllDataType::compareFloatVal(val1, val2, op);
814 } else if (typeLong == type) {
815 return AllDataType::compareLongVal(val1, val2, op);
816 } else if (typeLongLong == type) {
817 return AllDataType::compareLongLongVal(val1, val2, op);
818 } else if (typeByteInt == type) {
819 return AllDataType::compareByteIntVal(val1, val2, op);
820 } else if (typeTimeStamp == type) {
821 return AllDataType::compareTimeStampVal(val1, val2, op);
822 } else if (typeDate == type) {
823 return AllDataType::compareDateVal(val1, val2, op);
824 } else if (typeTime == type) {
825 return AllDataType::compareTimeVal(val1, val2, op);
826 } else if (typeBinary == type) {
827 return AllDataType::compareBinaryVal(val1, val2, op, length);
828 } else if (typeComposite == type) {
829 return AllDataType::compareBinaryVal(val1, val2, op, length);
830 }
831 }
832 */
833
834 bool AllDataType::compareIntVal(void* src1, void *src2, ComparisionOp op)
835 {
836 printf("This function should never be called by anyone");
837 if (OpEquals == op) {
838 if (*(int*)src1 == *(int*)src2) return true;
839 else return false;
840 }else if (OpGreaterThan == op) {
841 if (*(int*)src1 > *(int*)src2) return true;
842 else return false;
843 }else if (OpLessThan == op) {
844 if (*(int*)src1 < *(int*)src2) return true;
845 else return false;
846 }else if (OpLessThanEquals == op) {
847 if (*(int*)src1 <= *(int*)src2) return true;
848 else return false;
849 }else if (OpGreaterThanEquals == op) {
850 if (*(int*)src1 >= *(int*)src2) return true;
851 else return false;
852 }else if (OpNotEquals == op) {
853 if (*(int*)src1 != *(int*)src2) return true;
854 else return false;
855 }
856 return false;
857 }
858
859 bool AllDataType::compareLongVal(void* src1, void *src2, ComparisionOp op)
860 {
861 bool result = false;
862 switch(op)
863 {
864 case OpEquals:
865 if (*(long*)src1 == *(long*)src2) result = true;
866 else result = false;
867 break;
868 case OpNotEquals:
869 if (*(long*)src1 != *(long*)src2) result = true;
870 else result = false;
871 break;
872 case OpLessThan:
873 if (*(long*)src1 < *(long*)src2) result = true;
874 else result = false;
875 break;
876 case OpLessThanEquals:
877 if (*(long*)src1 <= *(long*)src2) result = true;
878 else result = false;
879 break;
880 case OpGreaterThan:
881 if (*(long*)src1 > *(long*)src2) result = true;
882 else result = false;
883 break;
884 case OpGreaterThanEquals:
885 if (*(long*)src1 >= *(long*)src2) result = true;
886 else result = false;
887 break;
888 }
889 return result;
890 }
891
892 bool AllDataType::compareLongLongVal(void* src1, void *src2,
893 ComparisionOp op)
894 {
895 bool result = false;
896 switch(op)
897 {
898 case OpEquals:
899 if (*(long long*)src1 == *(long long*)src2) result = true;
900 else result = false;
901 break;
902 case OpNotEquals:
903 if (*(long long*)src1 != *(long long*)src2) result = true;
904 else result = false;
905 break;
906 case OpLessThan:
907 if (*(long long*)src1 < *(long long*)src2) result = true;
908 else result = false;
909 break;
910 case OpLessThanEquals:
911 if (*(long long*)src1 <= *(long long*)src2) result = true;
912 else result = false;
913 break;
914 case OpGreaterThan:
915 if (*(long long*)src1 > *(long long*)src2) result = true;
916 else result = false;
917 break;
918 case OpGreaterThanEquals:
919 if (*(long long*)src1 >= *(long long*)src2) result = true;
920 else result = false;
921 break;
922 }
923 return result;
924 }
925
926 bool AllDataType::compareShortVal(void* src1, void *src2, ComparisionOp op)
927 {
928 bool result = false;
929 switch(op)
930 {
931 case OpEquals:
932 if (*(short*)src1 == *(short*)src2) result = true;
933 else result = false;
934 break;
935 case OpNotEquals:
936 if (*(short*)src1 != *(short*)src2) result = true;
937 else result = false;
938 break;
939 case OpLessThan:
940 if (*(short*)src1 < *(short*)src2) result = true;
941 else result = false;
942 break;
943 case OpLessThanEquals:
944 if (*(short*)src1 <= *(short*)src2) result = true;
945 else result = false;
946 break;
947 case OpGreaterThan:
948 if (*(short*)src1 > *(short*)src2) result = true;
949 else result = false;
950 break;
951 case OpGreaterThanEquals:
952 if (*(short*)src1 >= *(short*)src2) result = true;
953 else result = false;
954 break;
955 }
956 return result;
957 }
958
959 bool AllDataType::compareByteIntVal(void* src1, void *src2, ComparisionOp op)
960 {
961 bool result = false;
962 switch(op)
963 {
964 case OpEquals:
965 if (*(ByteInt*)src1 == *(ByteInt*)src2) result = true;
966 else result = false;
967 break;
968 case OpNotEquals:
969 if (*(ByteInt*)src1 != *(ByteInt*)src2) result = true;
970 else result = false;
971 break;
972 case OpLessThan:
973 if (*(ByteInt*)src1 < *(ByteInt*)src2) result = true;
974 else result = false;
975 break;
976 case OpLessThanEquals:
977 if (*(ByteInt*)src1 <= *(ByteInt*)src2) result = true;
978 else result = false;
979 break;
980 case OpGreaterThan:
981 if (*(ByteInt*)src1 > *(ByteInt*)src2) result = true;
982 else result = false;
983 break;
984 case OpGreaterThanEquals:
985 if (*(ByteInt*)src1 >= *(ByteInt*)src2) result = true;
986 else result = false;
987 break;
988 }
989 return result;
990 }
991
992 bool AllDataType::compareDoubleVal(void* src1, void *src2, ComparisionOp op)
993 {
994 bool result = false;
995 switch(op)
996 {
997 case OpEquals:
998 if (*(double*)src1 == *(double*)src2) result = true;
999 else result = false;
1000 break;
1001 case OpNotEquals:
1002 if (*(double*)src1 != *(double*)src2) result = true;
1003 else result = false;
1004 break;
1005 case OpLessThan:
1006 if (*(double*)src1 < *(double*)src2) result = true;
1007 else result = false;
1008 break;
1009 case OpLessThanEquals:
1010 if (*(double*)src1 <= *(double*)src2) result = true;
1011 else result = false;
1012 break;
1013 case OpGreaterThan:
1014 if (*(double*)src1 > *(double*)src2) result = true;
1015 else result = false;
1016 break;
1017 case OpGreaterThanEquals:
1018 if (*(double*)src1 >= *(double*)src2) result = true;
1019 else result = false;
1020 break;
1021 }
1022 return result;
1023 }
1024
1025 bool AllDataType::compareFloatVal(void* src1, void *src2, ComparisionOp op)
1026 {
1027 bool result = false;
1028 switch(op)
1029 {
1030 case OpEquals:
1031 if (*(float*)src1 == *(float*)src2) result = true;
1032 else result = false;
1033 break;
1034 case OpNotEquals:
1035 if (*(float*)src1 != *(float*)src2) result = true;
1036 else result = false;
1037 break;
1038 case OpLessThan:
1039 if (*(float*)src1 < *(float*)src2) result = true;
1040 else result = false;
1041 break;
1042 case OpLessThanEquals:
1043 if (*(float*)src1 <= *(float*)src2) result = true;
1044 else result = false;
1045 break;
1046 case OpGreaterThan:
1047 if (*(float*)src1 > *(float*)src2) result = true;
1048 else result = false;
1049 break;
1050 case OpGreaterThanEquals:
1051 if (*(float*)src1 >= *(float*)src2) result = true;
1052 else result = false;
1053 break;
1054 }
1055 return result;
1056 }
1057
1058 bool AllDataType::compareDateVal(void* src1, void *src2, ComparisionOp op)
1059 {
1060 bool result = false;
1061 switch(op)
1062 {
1063 case OpEquals:
1064 if (*(Date*)src1 == *(Date*)src2) result = true;
1065 else result = false;
1066 break;
1067 case OpNotEquals:
1068 if (*(Date*)src1 != *(Date*)src2) result = true;
1069 else result = false;
1070 break;
1071 case OpLessThan:
1072 if (*(Date*)src1 < *(Date*)src2) result = true;
1073 else result = false;
1074 break;
1075 case OpLessThanEquals:
1076 if (*(Date*)src1 <= *(Date*)src2) result = true;
1077 else result = false;
1078 break;
1079 case OpGreaterThan:
1080 if (*(Date*)src1 > *(Date*)src2) result = true;
1081 else result = false;
1082 break;
1083 case OpGreaterThanEquals:
1084 if (*(Date*)src1 >= *(Date*)src2) result = true;
1085 else result = false;
1086 break;
1087 }
1088 return result;
1089 }
1090
1091 bool AllDataType::compareTimeVal(void* src1, void *src2, ComparisionOp op)
1092 {
1093 bool result = false;
1094 switch(op)
1095 {
1096 case OpEquals:
1097 if (*(Time*)src1 == *(Time*)src2) result = true;
1098 else result = false;
1099 break;
1100 case OpNotEquals:
1101 if (*(Time*)src1 != *(Time*)src2) result = true;
1102 else result = false;
1103 break;
1104 case OpLessThan:
1105 if (*(Time*)src1 < *(Time*)src2) result = true;
1106 else result = false;
1107 break;
1108 case OpLessThanEquals:
1109 if (*(Time*)src1 <= *(Time*)src2) result = true;
1110 else result = false;
1111 break;
1112 case OpGreaterThan:
1113 if (*(Time*)src1 > *(Time*)src2) result = true;
1114 else result = false;
1115 break;
1116 case OpGreaterThanEquals:
1117 if (*(Time*)src1 >= *(Time*)src2) result = true;
1118 else result = false;
1119 break;
1120 }
1121 return result;
1122 }
1123
1124 bool AllDataType::compareTimeStampVal(void* src1, void *src2, ComparisionOp op)
1125 {
1126 bool result = false;
1127 switch(op)
1128 {
1129 case OpEquals:
1130 if (*(TimeStamp*)src1 == *(TimeStamp*)src2) result = true;
1131 else result = false;
1132 break;
1133 case OpNotEquals:
1134 if (*(TimeStamp*)src1 != *(TimeStamp*)src2) result = true;
1135 else result = false;
1136 break;
1137 case OpLessThan:
1138 if (*(TimeStamp*)src1 < *(TimeStamp*)src2) result = true;
1139 else result = false;
1140 break;
1141 case OpLessThanEquals:
1142 if (*(TimeStamp*)src1 <= *(TimeStamp*)src2) result = true;
1143 else result = false;
1144 break;
1145 case OpGreaterThan:
1146 if (*(TimeStamp*)src1 > *(TimeStamp*)src2) result = true;
1147 else result = false;
1148 break;
1149 case OpGreaterThanEquals:
1150 if (*(TimeStamp*)src1 >= *(TimeStamp*)src2) result = true;
1151 else result = false;
1152 break;
1153 }
1154 return result;
1155 }
1156
1157 bool AllDataType::compareStringVal(void* src1, void *src2, ComparisionOp op)
1158 {
1159 if (OpEquals == op) {
1160 if (strcmp((char*)src1, (char*)src2) ==0) return true;
1161 else return false;
1162 }else if (OpGreaterThan == op) {
1163 if (strcmp((char*)src1, (char*)src2) >0) return true;
1164 else return false;
1165 }else if (OpLessThan == op) {
1166 if (strcmp((char*)src1, (char*)src2) <0 ) return true;
1167 else return false;
1168 }else if (OpLessThanEquals == op) {
1169 // printf("Illegal Operator:Not Supported for String\n");
1170 // return false;
1171 if (strcmp((char*)src1, (char*)src2)<= 0) return true;
1172 else return false;
1173 }else if (OpGreaterThanEquals == op) {
1174 // printf("Illegal Operator:Not Supported for String\n");
1175 // return false;
1176 if (strcmp((char*)src1, (char*)src2) >=0) return true;
1177 else return false;
1178 }else if (OpNotEquals == op) {
1179 if (strcmp((char*)src1, (char*)src2) != 0) return true;
1180 else return false;
1181 }else if (OpLike == op) {
1182 return !os::strmatch((char*)src2, (char*)src1);
1183 }
1184 printf("Illegeal Operator:Not supported for String\n");
1185 return false;
1186 }
1187
1188 bool AllDataType::compareBinaryVal(void* src1, void *src2,
1189 ComparisionOp op, int length)
1190 {
1191 bool result = false;
1192 int ret = os::memcmp(src1, src2, length);
1193 switch(op)
1194 {
1195 case OpEquals:
1196 if (ret == 0 ) result= true; else result = false;
1197 break;
1198 case OpNotEquals:
1199 if (ret != 0 ) result= true; else result = false;
1200 break;
1201 case OpLessThan:
1202 if (ret < 0 ) result= true; else result = false;
1203 break;
1204 case OpLessThanEquals:
1205 printf("Illegal Operator:Not Supported for Binary\n");
1206 break;
1207 case OpGreaterThan:
1208 if (ret > 0 ) result= true; else result = false;
1209 break;
1210 case OpGreaterThanEquals:
1211 printf("Illegal Operator:Not Supported for Binary\n");
1212 break;
1213 }
1214 return result;
1215 }
1216 /*
1217 ComparisionOp AllDataType::getComparisionOperator(char *str)
1218 {
1219 ComparisionOp op;
1220 if (strcmp(str, "<=") == 0)
1221 op = OpLessThanEquals;
1222 else if (strcmp(str, ">=") == 0)
1223 op = OpGreaterThanEquals;
1224 else if (strcmp(str, "<") == 0)
1225 op = OpLessThan;
1226 else if (strcmp(str, ">") == 0)
1227 op = OpGreaterThan;
1228 else if (strcmp(str, "=") == 0)
1229 op = OpEquals;
1230 else if (strcmp(str, "!=") == 0 || strcmp(str, "<>") == 0 )
1231 op = OpNotEquals;
1232 else if (strcasecmp(str, "LIKE") == 0 )
1233 op = OpLike;
1234 else
1235 op = OpInvalidComparisionOp;
1236 return op;
1237 }
1238 */
1239
1240 void* AllDataType::alloc(DataType type, int length)
1241 {
1242 void *dest;
1243 switch(type)
1244 {
1245 case typeInt:
1246 dest = malloc(sizeof(int));
1247 break;
1248 case typeLong:
1249 dest = malloc(sizeof(long));
1250 break;
1251 case typeLongLong:
1252 dest = malloc(sizeof(long long));
1253 break;
1254 case typeShort:
1255 dest = malloc(sizeof(short));
1256 break;
1257 case typeByteInt:
1258 dest = malloc(sizeof(char));
1259 break;
1260 case typeDouble:
1261 dest = malloc(sizeof(double));
1262 break;
1263 case typeFloat:
1264 dest = malloc(sizeof(float));
1265 break;
1266 case typeDecimal:
1267 //TODO::for porting
1268 //fldDef.length_ = sizeof(long double);
1269 break;
1270 case typeString:
1271 if (length == 0 ) return NULL;
1272 dest = malloc(length);
1273 break;
1274 case typeBinary:
1275 if (length == 0 || length > 512) return NULL;
1276 dest = malloc(length);
1277 memset(dest, 0, length);
1278 break;
1279 case typeDate:
1280 dest = malloc(sizeof(Date));
1281 break;
1282 case typeTime:
1283 dest = malloc(sizeof(Time));
1284 break;
1285 case typeTimeStamp:
1286 dest = malloc(sizeof(TimeStamp));
1287 break;
1288 }
1289 return dest;
1290 }
1291
1292 void AllDataType::memoryset(void *value,DataType type)
1293 {
1294 switch(type)
1295 {
1296 case typeInt:
1297 value= ::memset(value, 0, sizeof(int));
1298 break;
1299 case typeLong:
1300 value = ::memset(value, 0, sizeof(long));
1301 break;
1302 case typeLongLong:
1303 value =::memset(value, 0, sizeof(long long));
1304 break;
1305 case typeShort:
1306 value = ::memset(value, 0, sizeof(short));
1307 break;
1308 case typeByteInt:
1309 value = ::memset(value, 0, sizeof(char));
1310 break;
1311 case typeDouble:
1312 value = ::memset(value, 0, sizeof(double));
1313 break;
1314 case typeFloat:
1315 value = ::memset(value, 0, sizeof(float));
1316 break;
1317 case typeDecimal:
1318 break;
1319 case typeString:
1320 *(char*)value = '\0';
1321 //if (length == 0 ) return NULL;
1322 //dest = malloc(length);
1323 break;
1324 case typeBinary:
1325 /* if (length == 0 || length > 256 ) return NULL;
1326
1327 memset(dest, 0, length);*/
1328 break;
1329 case typeDate:
1330 value = ::memset(value, 0, sizeof(Date));
1331 break;
1332 case typeTime:
1333 value = ::memset(value, 0, sizeof(Time));
1334 break;
1335 case typeTimeStamp:
1336 value = ::memset(value, 0, sizeof(TimeStamp));
1337 break;
1338 defalut:
1339 break;
1340 }
1341 }
1342
1343
1344 DbRetVal AllDataType::strToValue(void* dest, char *src, DataType type, int length)
1345 {
1346 switch(type)
1347 {
1348 case typeInt: {
1349 int val;
1350 sscanf( src, "%d", &val);
1351 *(int*)dest = val;
1352 break; }
1353 case typeLong: {
1354 long val;
1355 sscanf( src, "%ld", &val);
1356 *(long*)dest = val;
1357 break; }
1358 case typeLongLong: {
1359 long long val;
1360 sscanf( src, "%lld", &val);
1361 *(long long*)dest = val;
1362 break; }
1363 case typeShort: {
1364 short val;
1365 sscanf( src, "%hd", &val);
1366 *(short*)dest = val;
1367 break; }
1368 case typeByteInt: {
1369 int val;
1370 sscanf( src, "%d", &val);
1371 *(char*)dest = *(char *)&val;
1372 break; }
1373 case typeDouble: {
1374 double val;
1375 sscanf( src, "%lg", &val);
1376 *(double*)dest = val;
1377 break; }
1378 case typeFloat: {
1379 float val;
1380 sscanf( src, "%f", &val);
1381 *(float*)dest = val;
1382 break; }
1383 case typeDecimal:
1384 //TODO::for porting
1385 case typeString: {
1386 strncpy((char*)dest, (char*)src, length);
1387 char *d =(char*)dest;
1388 d[length-1] = '\0';
1389 break;}
1390 case typeDate: {
1391 int d,m,y,res=0;
1392 res = sscanf( src, "%d-%d-%d", &y, &m, &d );
1393 if( res != 3 )
1394 res = sscanf( src, "%d/%d/%d", &y, &m, &d );
1395 if( res != 3 )
1396 {
1397 fprintf(stderr,"Error reading date. yyyy{-/}mm{-/}dd is the valid format.");
1398 d=m=y=0;
1399 }
1400 Date dateObj(y,m,d);
1401 *(Date*)dest = dateObj;
1402 break; }
1403 case typeTime: {
1404 int h,m,s,res=0;
1405 res = sscanf( src, "%d:%d:%d", &h, &m, &s );
1406 if( res != 3 )
1407 {
1408 fprintf(stderr, "Error reading time, hh:mm:ss is the valid format.");
1409 h=m=s=0;
1410 }
1411 Time timeObj(h,m,s);
1412 *(Time*)dest = timeObj;
1413 break; }
1414 case typeTimeStamp: {
1415 int d,m,y, h,mn,s, res=0;
1416 res = sscanf( src, "%d-%d-%d %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1417 if( res != 6 )
1418 res = sscanf( src, "%d-%d-%d, %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1419 if( res != 6 )
1420 res = sscanf( src, "%d/%d/%d %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1421 if( res != 6 )
1422 res = sscanf( src, "%d/%d/%d, %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1423 if( res != 6 )
1424 {
1425 fprintf(stderr, "Error reading timestamp, yyyy{-/}mm{-/}dd[,] hh:mm:ss is the valid format.");
1426 d=m=y=h=mn=s=0;
1427 }
1428 TimeStamp timeStampObj(y,m,d,h,mn,s);
1429 *(TimeStamp*)dest = timeStampObj;
1430 break; }
1431 case typeBinary: {
1432 memset ((void *) dest, 0, length);
1433 unsigned char c = 0;
1434 const char *str = (const char *)src;
1435 int i=0;
1436 i = strlen(src)-1;
1437 bool evenlegth=false;
1438 if(i%2){ evenlegth=true;}
1439 unsigned char *val = (unsigned char *)dest+(length-1);
1440 while (i >= 0) {
1441 c = str[i];
1442 if (!isxdigit((int)c)) {
1443 printError(ErrBadArg, "Invalid hexadecimal value");
1444 return ErrBadArg;
1445 }
1446 if (c <= '9') c -= '0';
1447 else if (c >= 'a') c = c - 'a' + 10;
1448 else c = c - 'A' + 10;
1449 if(evenlegth)
1450 {
1451 if ((i+1) % 2) { *val = *val | (c<<4); val--;}
1452 else { *val = c; }
1453 }else{
1454 if (i % 2) { *val = *val | (c<<4); val--;}
1455 else { *val = c; }
1456 }
1457 i--;
1458 }
1459 break;
1460 }
1461 default:
1462 break;
1463 }
1464 return OK;
1465 }
1466
1467
1468 void AllDataType::convert(DataType srcType, void *src,
1469 DataType destType, void *dest, int length)
1470 {
1471 switch ((DataType) destType )
1472 {
1473 case typeInt: convertToInt(dest, src, srcType); break;
1474 case typeLong: convertToLong(dest, src, srcType); break;
1475 case typeLongLong: convertToLongLong(dest, src, srcType); break;
1476 case typeShort: convertToShort(dest, src, srcType); break;
1477 case typeByteInt: convertToByteInt(dest, src, srcType); break;
1478
1479 case typeFloat: convertToFloat(dest, src, srcType); break;
1480 case typeDouble: convertToDouble(dest, src, srcType); break;
1481
1482 //TODO
1483 case typeDecimal: convertToDouble(dest, src, srcType); break;
1484
1485 case typeString: convertToString(dest, src, srcType); break;
1486 case typeBinary: convertToBinary(dest, src, srcType,length); break;
1487 case typeDate: convertToDate(dest, src, srcType); break;
1488 case typeTime: convertToTime(dest, src, srcType); break;
1489 case typeTimeStamp: convertToTimeStamp(dest, src, srcType); break;
1490 default: return;
1491 }
1492 }
1493
1494 void AllDataType::convertToInt( void* dest, void* src, DataType srcType )
1495 {
1496 switch(srcType)
1497 {
1498 case typeInt: *(int *)dest = *(int *)src; break;
1499 case typeLong: *(int *)dest =(int) *(long *)src; break;
1500 case typeLongLong: *(int *)dest =(int) *(long long *)src; break;
1501 case typeShort: *(int *)dest =(int) *(short *)src; break;
1502 case typeByteInt: *(int *)dest =(int) *(char *)src; break;
1503
1504 case typeFloat: *(int *)dest = (int) *(float *)src; break;
1505 case typeDouble: *(int *)dest =(int) *(double *)src; break;
1506
1507 case typeString: sscanf((const char*)src, "%d", (int*) dest); break;
1508
1509 case typeDate:
1510 case typeTime:
1511 case typeTimeStamp:
1512 case typeBinary:
1513 default: *(int *)dest = (int) 0;
1514 }
1515 }
1516
1517 void AllDataType::convertToLong( void* dest, void* src, DataType srcType )
1518 {
1519 switch(srcType)
1520 {
1521 case typeInt: *(long *)dest =(long) *(int *)src; break;
1522 case typeLong: *(long *)dest = *(long *)src; break;
1523 case typeLongLong: *(long *)dest =(long) *(long long *)src; break;
1524 case typeShort: *(long *)dest =(long) *(short *)src; break;
1525 case typeByteInt: *(long *)dest =(long) *(char *)src; break;
1526
1527 case typeFloat: *(long *)dest = (long) *(float *)src; break;
1528 case typeDouble: *(long *)dest =(long) *(double *)src; break;
1529
1530 case typeString: sscanf((const char*)src, "%ld", (long*) dest); break;
1531
1532 case typeDate:
1533 case typeTime:
1534 case typeTimeStamp:
1535 case typeBinary:
1536 default: *(long *)dest = (long) 0;
1537 }
1538 }
1539
1540
1541 void AllDataType::convertToLongLong( void* dest, void* src, DataType srcType )
1542 {
1543 switch(srcType)
1544 {
1545 case typeInt: *(long long *)dest =(long long) *(int *)src; break;
1546 case typeLong: *(long long *)dest = (long long) *(long *)src; break;
1547 case typeLongLong: *(long long *)dest = *(long long *)src; break;
1548 case typeShort: *(long long *)dest =(long long) *(short *)src; break;
1549 case typeByteInt: *(long long *)dest =(long long) *(char *)src; break;
1550
1551 case typeFloat: *(long long *)dest = (long long) *(float *)src; break;
1552 case typeDouble: *(long long *)dest =(long long) *(double *)src; break;
1553
1554 case typeString: sscanf((const char*)src, "%lld", (long long*) dest); break;
1555
1556 case typeDate:
1557 case typeTime:
1558 case typeTimeStamp:
1559 case typeBinary:
1560 default: *(long long *)dest = (long long) 0;
1561 }
1562 }
1563
1564 void AllDataType::convertToShort( void* dest, void* src, DataType srcType )
1565 {
1566 switch(srcType)
1567 {
1568 case typeInt: *(short*)dest =(short) *(int*)src; break;
1569 case typeLong: *(short*)dest = (short) *(long*)src; break;
1570 case typeLongLong: *(short*)dest = (short) *(long long*)src; break;
1571 case typeShort: *(short*)dest = *(short*)src; break;
1572 case typeByteInt: *(short*)dest =(short) *(char *)src; break;
1573
1574 case typeFloat: *(short*)dest = (short) *(float *)src; break;
1575 case typeDouble: *(short*)dest =(short) *(double *)src; break;
1576
1577 case typeString: sscanf((const char*)src, "%hd", (short*) dest); break;
1578
1579 case typeDate:
1580 case typeTime:
1581 case typeTimeStamp:
1582 case typeBinary:
1583 default: *(short*)dest = (short) 0;
1584 }
1585 }
1586
1587 void AllDataType::convertToByteInt( void* dest, void* src, DataType srcType )
1588 {
1589 switch(srcType)
1590 {
1591 case typeInt: *(char*)dest = (char) *(int*)src; break;
1592 case typeLong: *(char*)dest = (char) *(long*)src; break;
1593 case typeLongLong: *(char*)dest = (char) *(long long*)src; break;
1594 case typeShort: *(char*)dest = (char) *(short*)src; break;
1595 case typeByteInt: *(char*)dest = *(char *)src; break;
1596
1597 case typeFloat: *(char*)dest = (char) *(float *)src; break;
1598 case typeDouble: *(char*)dest =(char) *(double *)src; break;
1599
1600 case typeString: sscanf((const char*)src, "%c", (char*) dest); break;
1601
1602 case typeDate:
1603 case typeTime:
1604 case typeTimeStamp:
1605 case typeBinary:
1606 default: *(char*)dest = (char) 0;
1607 }
1608 }
1609
1610 void AllDataType::convertToFloat( void* dest, void* src, DataType srcType )
1611 {
1612 switch(srcType)
1613 {
1614 case typeInt: *(float *)dest =(float) *(int *)src; break;
1615 case typeLong: *(float *)dest =(float) *(long *)src; break;
1616 case typeLongLong: *(float *)dest =(float) *(long long *)src; break;
1617 case typeShort: *(float *)dest =(float) *(short *)src; break;
1618 case typeByteInt: *(float *)dest =(float) *(char *)src; break;
1619
1620 case typeFloat: *(float *)dest = *(float *)src; break;
1621 case typeDouble: *(float *)dest =(float) *(double *)src; break;
1622
1623 case typeString: sscanf((const char*)src, "%f", (float*) dest); break;
1624
1625 case typeDate:
1626 case typeTime:
1627 case typeTimeStamp:
1628 case typeBinary:
1629 default: *(float *)dest = (float) 0;
1630 }
1631 }
1632
1633 void AllDataType::convertToDouble( void* dest, void* src, DataType srcType )
1634 {
1635 switch(srcType)
1636 {
1637 case typeInt: *(double *)dest =(double) *(int *)src; break;
1638 case typeLong: *(double *)dest =(double) *(long *)src; break;
1639 case typeLongLong: *(double *)dest =(double) *(long long *)src; break;
1640 case typeShort: *(double *)dest =(double) *(short *)src; break;
1641 case typeByteInt: *(double *)dest =(double) *(char *)src; break;
1642
1643 case typeFloat: *(double *)dest =(double) *(float *)src; break;
1644 case typeDouble: *(double *)dest = *(double *)src; break;
1645
1646 case typeString: sscanf((const char*)src, "%lf", (double*) dest); break;
1647
1648 case typeDate:
1649 case typeTime:
1650 case typeTimeStamp:
1651 case typeBinary:
1652 default: *(double *)dest = (double) 0;
1653 }
1654 }
1655
1656 void AllDataType::convertToString( void* dest, void* src, DataType srcType, int length )
1657 {
1658 switch(srcType)
1659 {
1660 case typeInt:
1661 {
1662 sprintf ((char *)dest, "%d", *(int *)src);
1663 break;
1664 }
1665 case typeLong:
1666 {
1667 sprintf ((char *)dest, "%ld", *(long *)src);
1668 break;
1669 }
1670 case typeLongLong:
1671 {
1672 sprintf ((char *)dest, "%lld", *(long long *)src);
1673 break;
1674 }
1675 case typeShort:
1676 {
1677 sprintf ((char *)dest, "%hd", *(short *)src);
1678 break;
1679 }
1680 case typeByteInt:
1681 {
1682 sprintf ((char *)dest, "%hd", *(char *)src);
1683 break;
1684 }
1685
1686 case typeFloat:
1687 {
1688 sprintf ((char *)dest, "%f", *(float *)src);
1689 break;
1690 }
1691 case typeDouble:
1692 {
1693 sprintf ((char *) dest, "%lf", *(double *)src);
1694 break;
1695 }
1696
1697 case typeString:
1698 {
1699 strcpy((char*)dest, (char*)src);
1700 break;
1701 }
1702 case typeDate:
1703 {
1704 Date* dt = (Date*)src;
1705 sprintf((char*) dest, "%d/%d/%d", dt->year(),
1706 dt->month(), dt->dayOfMonth());
1707 break;
1708 }
1709 case typeTime:
1710 {
1711 Time* tm = (Time*)src;
1712 sprintf((char*)dest,"%d:%d:%d.%d", tm->hours(), tm->minutes(), tm->seconds(), 0);
1713 break;
1714 }
1715 case typeTimeStamp:
1716 {
1717 TimeStamp* tm = (TimeStamp*)src;
1718 sprintf((char*)dest, "%d/%d/%d %d:%d:%d.%d", tm->year(),
1719 tm->month(), tm->dayOfMonth(), tm->hours(),
1720 tm->minutes(), tm->seconds(), 0 );
1721 break;
1722 }
1723 case typeBinary:
1724 {
1725 unsigned char *c = (unsigned char *) src;
1726 unsigned char *str = (unsigned char *) dest;
1727 unsigned char p = 0;
1728 int i = 0;
1729 while (i < length) {
1730 p = *c >> 4;
1731 if (p < 10) sprintf ((char *)str++, "%c", '0' + p);
1732 else sprintf((char *)str++, "%c", 'A' + p - 10);
1733 p = *c & 0xF;
1734 if (p < 10) sprintf ((char *)str++, "%c", '0' + p);
1735 else sprintf((char *)str++, "%c", 'A' + p - 10);
1736 i++; c++;
1737 }
1738 break;
1739 }
1740
1741 default: ((char*)dest)[0] = '\0';
1742 }
1743
1744 }
1745 void AllDataType::convertToDate( void* dest, void* src, DataType srcType )
1746 {
1747 switch(srcType)
1748 {
1749 case typeInt:
1750 case typeLong:
1751 case typeLongLong:
1752 case typeShort:
1753 case typeByteInt:
1754 case typeFloat:
1755 case typeDouble:
1756 case typeDate:
1757 case typeTime:
1758 case typeTimeStamp:
1759 case typeString:
1760 {
1761 Date *dt = (Date*) dest;
1762 dt->parseFrom((char*)src);
1763 break;
1764 }
1765 default: ((char*)dest)[0] = '\0';
1766 }
1767 }
1768
1769 void AllDataType::convertToTime( void* dest, void* src, DataType srcType )
1770 {
1771 switch(srcType)
1772 {
1773 case typeInt:
1774 case typeLong:
1775 case typeLongLong:
1776 case typeShort:
1777 case typeByteInt:
1778 case typeFloat:
1779 case typeDouble:
1780 case typeDate:
1781 case typeTime:
1782 case typeTimeStamp:
1783 case typeString:
1784 {
1785 Time *dt = (Time*) dest;
1786 dt->parseFrom((char*)src);
1787 break;
1788 }
1789 default: ((char*)dest)[0] = '\0';
1790 }
1791 }
1792
1793 void AllDataType::convertToTimeStamp( void* dest, void* src, DataType srcType )
1794 {
1795 switch(srcType)
1796 {
1797 case typeInt:
1798 case typeLong:
1799 case typeLongLong:
1800 case typeShort:
1801 case typeByteInt:
1802 case typeFloat:
1803 case typeDouble:
1804 case typeDate:
1805 case typeTime:
1806 case typeTimeStamp:
1807 case typeString:
1808 {
1809 TimeStamp *dt = (TimeStamp*) dest;
1810 dt->parseFrom((char*)src);
1811 break;
1812 }
1813 default: ((char*)dest)[0] = '\0';
1814 }
1815 }
1816
1817 void AllDataType::convertToBinary(void *dest, void *src, DataType srcType, int length)
1818 {
1819 switch(srcType)
1820 {
1821 case typeString:
1822 {
1823 memset ((void *) dest, 0, length);
1824 unsigned char c = 0;
1825 const char *str = (const char *)src;
1826 int i=0;
1827 i = strlen((char*)src)-1;
1828 bool evenlegth=false;
1829 if(i%2){ evenlegth=true;}
1830 unsigned char *val = (unsigned char *)dest+(length-1);
1831 while (i >= 0) {
1832 c = str[i];
1833 if (c <= '9') c -= '0';
1834 else if (c >= 'a') c = c - 'a' + 10;
1835 else c = c - 'A' + 10;
1836 if(evenlegth)
1837 {
1838 if ((i+1) % 2) { *val = *val | (c<<4); val--;}
1839 else { *val = c; }
1840 }else{
1841 if (i % 2) { *val = *val | (c<<4); val--;}
1842 else { *val = c; }
1843 }
1844 i--;
1845 }
1846 break;
1847 }
1848 }
1849 }
1850 int AllDataType::printVal(void* src, DataType srcType, int length )
1851 {
1852 int count = 0;
1853 switch(srcType)
1854 {
1855 case typeInt:
1856 {
1857 count = printf ("%d", *(int *)src);
1858 break;
1859 }
1860 case typeLong:
1861 {
1862 count = printf ("%ld", *(long *)src);
1863 break;
1864 }
1865 case typeLongLong:
1866 {
1867 count = printf ("%lld", *(long long *)src);
1868 break;
1869 }
1870 case typeShort:
1871 {
1872 count = printf("%hd", *(short *)src);
1873 break;
1874 }
1875 case typeByteInt:
1876 {
1877 count = printf("%hd", *(char *)src);
1878 break;
1879 }
1880
1881 case typeFloat:
1882 {
1883 count = printf("%f", *(float *)src);
1884 break;
1885 }
1886 case typeDouble:
1887 {
1888 count = printf("%lf", *(double *)src);
1889 break;
1890 }
1891
1892 case typeString:
1893 {
1894 count = printf("%s", (char*)src);
1895 break;
1896 }
1897 case typeDate:
1898 {
1899 Date* dt = (Date*)src;
1900 count = printf("%d/%d/%d", dt->year(),
1901 dt->month(), dt->dayOfMonth());
1902 break;
1903 }
1904 case typeTime:
1905 {
1906 Time* tm = (Time*)src;
1907 count = printf("%d:%d:%d.%d", tm->hours(), tm->minutes(), tm->seconds(), 0);
1908 break;
1909 }
1910 case typeTimeStamp:
1911 {
1912 TimeStamp* tm = (TimeStamp*)src;
1913 count = printf("%d/%d/%d %d:%d:%d.%d", tm->year(),
1914 tm->month(), tm->dayOfMonth(), tm->hours(),
1915 tm->minutes(), tm->seconds(), 0 );
1916 break;
1917 }
1918 case typeBinary:
1919 {
1920 unsigned char *c = (unsigned char *) src;
1921 unsigned char p = 0;
1922 int i = 0;
1923 bool isDigitFound=false;
1924 while (i < length) {
1925 p = *c >> 4;
1926 if(('0'+p)!='0'|| isDigitFound){
1927 if (p < 10) printf ("%c", '0' + p);
1928 else printf("%c", 'A' + p - 10);
1929 isDigitFound=true;
1930 }
1931 p = *c & 0xF;
1932 if(('0'+p)!='0' || isDigitFound){
1933 if (p < 10) printf ("%c", '0' + p);
1934 else printf("%c", 'A' + p - 10);
1935 isDigitFound=true;
1936 }
1937 i++; c++;
1938 }
1939 count = length * 2;
1940 break;
1941 }
1942 default: { printf("DataType not supported\n"); break; }
1943 }
1944 return count;
1945 }
1946
1947
1948
Main memory database SQL engine (cvs import)