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