?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
First version
[csql.git] / src / storage / DataType.cxx
blob98789f43e667b22f8e0ee101b3655494df02a35a
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 void AllDataType::increment(void* dest, void *src, DataType type)
778 {
779 switch(type)
780 {
781 case typeInt:
782 *(int*)dest = *(int*)src + 1;
783 break;
784 case typeLong:
785 *(long*)dest = *(long*)src + 1;
786 break;
787 case typeLongLong:
788 *(long long*)dest = *(long long*)src + 1;
789 break;
790 case typeShort:
791 *(short*)dest = *(short*)src + 1;
792 break;
793 case typeDouble:
794 *(double*)dest = *(double*)src + 1;
795 break;
796 case typeFloat:
797 *(float*)dest = *(float*)src+ 1;
798 break;
799 default:
800 break;
801 }
802 }
803 bool AllDataType::isValueZero(void *src, DataType type)
804 {
805 switch(type)
806 {
807 case typeInt:
808 if (*(int*)src == 0) return true;
809 else return false;
810 case typeLong:
811 if (*(int*)src == 0) return true;
812 else return false;
813 case typeLongLong:
814 if (*(int*)src == 0) return true;
815 else return false;
816 case typeShort:
817 if (*(int*)src == 0) return true;
818 else return false;
819 case typeDouble:
820 if (*(int*)src == 0) return true;
821 else return false;
822 case typeFloat:
823 if (*(int*)src == 0) return true;
824 else return false;
825 default:
826 break;
827 }
828 return false;
829 }
830
831 /*
832 bool AllDataType::compareVal(void *val1, void *val2, ComparisionOp op,
833 DataType type, long length)
834 {
835 //Performance optimization.
836 //do not convert compareXXXVal to virtual functions. it takes more time
837 if (typeInt == type)
838 {
839 //as int is the heavily used type, hardcoding the compare here itself
840 if (OpEquals == op) {
841 if (*(int*)val1 == *(int*)val2) return true;
842 else return false;
843 }else if (OpLessThanEquals == op) {
844 if (*(int*)val1 <= *(int*)val2) return true;
845 else return false;
846 }else if (OpGreaterThanEquals == op) {
847 if (*(int*)val1 >= *(int*)val2) return true;
848 else return false;
849 }else if (OpGreaterThan == op) {
850 if (*(int*)val1 > *(int*)val2) return true;
851 else return false;
852 }else if (OpLessThan == op) {
853 if (*(int*)val1 < *(int*)val2) return true;
854 else return false;
855 }else if (OpNotEquals == op) {
856 if (*(int*)val1 != *(int*)val2) return true;
857 else return false;
858 }
859
860 }else if(typeString == type) {
861 return AllDataType::compareStringVal(val1, val2, op);
862 } else if (typeShort == type) {
863 return AllDataType::compareShortVal(val1, val2, op);
864 } else if (typeDouble == type) {
865 return AllDataType::compareDoubleVal(val1, val2, op);
866 } else if (typeFloat == type) {
867 return AllDataType::compareFloatVal(val1, val2, op);
868 } else if (typeLong == type) {
869 return AllDataType::compareLongVal(val1, val2, op);
870 } else if (typeLongLong == type) {
871 return AllDataType::compareLongLongVal(val1, val2, op);
872 } else if (typeByteInt == type) {
873 return AllDataType::compareByteIntVal(val1, val2, op);
874 } else if (typeTimeStamp == type) {
875 return AllDataType::compareTimeStampVal(val1, val2, op);
876 } else if (typeDate == type) {
877 return AllDataType::compareDateVal(val1, val2, op);
878 } else if (typeTime == type) {
879 return AllDataType::compareTimeVal(val1, val2, op);
880 } else if (typeBinary == type) {
881 return AllDataType::compareBinaryVal(val1, val2, op, length);
882 } else if (typeComposite == type) {
883 return AllDataType::compareBinaryVal(val1, val2, op, length);
884 }
885 }
886 */
887
888 bool AllDataType::compareIntVal(void* src1, void *src2, ComparisionOp op)
889 {
890 printf("This function should never be called by anyone");
891 if (OpEquals == op) {
892 if (*(int*)src1 == *(int*)src2) return true;
893 else return false;
894 }else if (OpGreaterThan == op) {
895 if (*(int*)src1 > *(int*)src2) return true;
896 else return false;
897 }else if (OpLessThan == op) {
898 if (*(int*)src1 < *(int*)src2) return true;
899 else return false;
900 }else if (OpLessThanEquals == op) {
901 if (*(int*)src1 <= *(int*)src2) return true;
902 else return false;
903 }else if (OpGreaterThanEquals == op) {
904 if (*(int*)src1 >= *(int*)src2) return true;
905 else return false;
906 }else if (OpNotEquals == op) {
907 if (*(int*)src1 != *(int*)src2) return true;
908 else return false;
909 }
910 return false;
911 }
912
913 bool AllDataType::compareLongVal(void* src1, void *src2, ComparisionOp op)
914 {
915 bool result = false;
916 switch(op)
917 {
918 case OpEquals:
919 if (*(long*)src1 == *(long*)src2) result = true;
920 else result = false;
921 break;
922 case OpNotEquals:
923 if (*(long*)src1 != *(long*)src2) result = true;
924 else result = false;
925 break;
926 case OpLessThan:
927 if (*(long*)src1 < *(long*)src2) result = true;
928 else result = false;
929 break;
930 case OpLessThanEquals:
931 if (*(long*)src1 <= *(long*)src2) result = true;
932 else result = false;
933 break;
934 case OpGreaterThan:
935 if (*(long*)src1 > *(long*)src2) result = true;
936 else result = false;
937 break;
938 case OpGreaterThanEquals:
939 if (*(long*)src1 >= *(long*)src2) result = true;
940 else result = false;
941 break;
942 }
943 return result;
944 }
945
946 bool AllDataType::compareLongLongVal(void* src1, void *src2,
947 ComparisionOp op)
948 {
949 bool result = false;
950 switch(op)
951 {
952 case OpEquals:
953 if (*(long long*)src1 == *(long long*)src2) result = true;
954 else result = false;
955 break;
956 case OpNotEquals:
957 if (*(long long*)src1 != *(long long*)src2) result = true;
958 else result = false;
959 break;
960 case OpLessThan:
961 if (*(long long*)src1 < *(long long*)src2) result = true;
962 else result = false;
963 break;
964 case OpLessThanEquals:
965 if (*(long long*)src1 <= *(long long*)src2) result = true;
966 else result = false;
967 break;
968 case OpGreaterThan:
969 if (*(long long*)src1 > *(long long*)src2) result = true;
970 else result = false;
971 break;
972 case OpGreaterThanEquals:
973 if (*(long long*)src1 >= *(long long*)src2) result = true;
974 else result = false;
975 break;
976 }
977 return result;
978 }
979
980 bool AllDataType::compareShortVal(void* src1, void *src2, ComparisionOp op)
981 {
982 bool result = false;
983 switch(op)
984 {
985 case OpEquals:
986 if (*(short*)src1 == *(short*)src2) result = true;
987 else result = false;
988 break;
989 case OpNotEquals:
990 if (*(short*)src1 != *(short*)src2) result = true;
991 else result = false;
992 break;
993 case OpLessThan:
994 if (*(short*)src1 < *(short*)src2) result = true;
995 else result = false;
996 break;
997 case OpLessThanEquals:
998 if (*(short*)src1 <= *(short*)src2) result = true;
999 else result = false;
1000 break;
1001 case OpGreaterThan:
1002 if (*(short*)src1 > *(short*)src2) result = true;
1003 else result = false;
1004 break;
1005 case OpGreaterThanEquals:
1006 if (*(short*)src1 >= *(short*)src2) result = true;
1007 else result = false;
1008 break;
1009 }
1010 return result;
1011 }
1012
1013 bool AllDataType::compareByteIntVal(void* src1, void *src2, ComparisionOp op)
1014 {
1015 bool result = false;
1016 switch(op)
1017 {
1018 case OpEquals:
1019 if (*(ByteInt*)src1 == *(ByteInt*)src2) result = true;
1020 else result = false;
1021 break;
1022 case OpNotEquals:
1023 if (*(ByteInt*)src1 != *(ByteInt*)src2) result = true;
1024 else result = false;
1025 break;
1026 case OpLessThan:
1027 if (*(ByteInt*)src1 < *(ByteInt*)src2) result = true;
1028 else result = false;
1029 break;
1030 case OpLessThanEquals:
1031 if (*(ByteInt*)src1 <= *(ByteInt*)src2) result = true;
1032 else result = false;
1033 break;
1034 case OpGreaterThan:
1035 if (*(ByteInt*)src1 > *(ByteInt*)src2) result = true;
1036 else result = false;
1037 break;
1038 case OpGreaterThanEquals:
1039 if (*(ByteInt*)src1 >= *(ByteInt*)src2) result = true;
1040 else result = false;
1041 break;
1042 }
1043 return result;
1044 }
1045
1046 bool AllDataType::compareDoubleVal(void* src1, void *src2, ComparisionOp op)
1047 {
1048 bool result = false;
1049 switch(op)
1050 {
1051 case OpEquals:
1052 if (*(double*)src1 == *(double*)src2) result = true;
1053 else result = false;
1054 break;
1055 case OpNotEquals:
1056 if (*(double*)src1 != *(double*)src2) result = true;
1057 else result = false;
1058 break;
1059 case OpLessThan:
1060 if (*(double*)src1 < *(double*)src2) result = true;
1061 else result = false;
1062 break;
1063 case OpLessThanEquals:
1064 if (*(double*)src1 <= *(double*)src2) result = true;
1065 else result = false;
1066 break;
1067 case OpGreaterThan:
1068 if (*(double*)src1 > *(double*)src2) result = true;
1069 else result = false;
1070 break;
1071 case OpGreaterThanEquals:
1072 if (*(double*)src1 >= *(double*)src2) result = true;
1073 else result = false;
1074 break;
1075 }
1076 return result;
1077 }
1078
1079 bool AllDataType::compareFloatVal(void* src1, void *src2, ComparisionOp op)
1080 {
1081 bool result = false;
1082 switch(op)
1083 {
1084 case OpEquals:
1085 if (*(float*)src1 == *(float*)src2) result = true;
1086 else result = false;
1087 break;
1088 case OpNotEquals:
1089 if (*(float*)src1 != *(float*)src2) result = true;
1090 else result = false;
1091 break;
1092 case OpLessThan:
1093 if (*(float*)src1 < *(float*)src2) result = true;
1094 else result = false;
1095 break;
1096 case OpLessThanEquals:
1097 if (*(float*)src1 <= *(float*)src2) result = true;
1098 else result = false;
1099 break;
1100 case OpGreaterThan:
1101 if (*(float*)src1 > *(float*)src2) result = true;
1102 else result = false;
1103 break;
1104 case OpGreaterThanEquals:
1105 if (*(float*)src1 >= *(float*)src2) result = true;
1106 else result = false;
1107 break;
1108 }
1109 return result;
1110 }
1111
1112 bool AllDataType::compareDateVal(void* src1, void *src2, ComparisionOp op)
1113 {
1114 bool result = false;
1115 switch(op)
1116 {
1117 case OpEquals:
1118 if (*(Date*)src1 == *(Date*)src2) result = true;
1119 else result = false;
1120 break;
1121 case OpNotEquals:
1122 if (*(Date*)src1 != *(Date*)src2) result = true;
1123 else result = false;
1124 break;
1125 case OpLessThan:
1126 if (*(Date*)src1 < *(Date*)src2) result = true;
1127 else result = false;
1128 break;
1129 case OpLessThanEquals:
1130 if (*(Date*)src1 <= *(Date*)src2) result = true;
1131 else result = false;
1132 break;
1133 case OpGreaterThan:
1134 if (*(Date*)src1 > *(Date*)src2) result = true;
1135 else result = false;
1136 break;
1137 case OpGreaterThanEquals:
1138 if (*(Date*)src1 >= *(Date*)src2) result = true;
1139 else result = false;
1140 break;
1141 }
1142 return result;
1143 }
1144
1145 bool AllDataType::compareTimeVal(void* src1, void *src2, ComparisionOp op)
1146 {
1147 bool result = false;
1148 switch(op)
1149 {
1150 case OpEquals:
1151 if (*(Time*)src1 == *(Time*)src2) result = true;
1152 else result = false;
1153 break;
1154 case OpNotEquals:
1155 if (*(Time*)src1 != *(Time*)src2) result = true;
1156 else result = false;
1157 break;
1158 case OpLessThan:
1159 if (*(Time*)src1 < *(Time*)src2) result = true;
1160 else result = false;
1161 break;
1162 case OpLessThanEquals:
1163 if (*(Time*)src1 <= *(Time*)src2) result = true;
1164 else result = false;
1165 break;
1166 case OpGreaterThan:
1167 if (*(Time*)src1 > *(Time*)src2) result = true;
1168 else result = false;
1169 break;
1170 case OpGreaterThanEquals:
1171 if (*(Time*)src1 >= *(Time*)src2) result = true;
1172 else result = false;
1173 break;
1174 }
1175 return result;
1176 }
1177
1178 bool AllDataType::compareTimeStampVal(void* src1, void *src2, ComparisionOp op)
1179 {
1180 bool result = false;
1181 switch(op)
1182 {
1183 case OpEquals:
1184 if (*(TimeStamp*)src1 == *(TimeStamp*)src2) result = true;
1185 else result = false;
1186 break;
1187 case OpNotEquals:
1188 if (*(TimeStamp*)src1 != *(TimeStamp*)src2) result = true;
1189 else result = false;
1190 break;
1191 case OpLessThan:
1192 if (*(TimeStamp*)src1 < *(TimeStamp*)src2) result = true;
1193 else result = false;
1194 break;
1195 case OpLessThanEquals:
1196 if (*(TimeStamp*)src1 <= *(TimeStamp*)src2) result = true;
1197 else result = false;
1198 break;
1199 case OpGreaterThan:
1200 if (*(TimeStamp*)src1 > *(TimeStamp*)src2) result = true;
1201 else result = false;
1202 break;
1203 case OpGreaterThanEquals:
1204 if (*(TimeStamp*)src1 >= *(TimeStamp*)src2) result = true;
1205 else result = false;
1206 break;
1207 }
1208 return result;
1209 }
1210
1211 bool AllDataType::compareStringVal(void* src1, void *src2, ComparisionOp op)
1212 {
1213 if (OpEquals == op) {
1214 if (strcmp((char*)src1, (char*)src2) ==0) return true;
1215 else return false;
1216 }else if (OpGreaterThan == op) {
1217 if (strcmp((char*)src1, (char*)src2) >0) return true;
1218 else return false;
1219 }else if (OpLessThan == op) {
1220 if (strcmp((char*)src1, (char*)src2) <0 ) return true;
1221 else return false;
1222 }else if (OpLessThanEquals == op) {
1223 // printf("Illegal Operator:Not Supported for String\n");
1224 // return false;
1225 if (strcmp((char*)src1, (char*)src2)<= 0) return true;
1226 else return false;
1227 }else if (OpGreaterThanEquals == op) {
1228 // printf("Illegal Operator:Not Supported for String\n");
1229 // return false;
1230 if (strcmp((char*)src1, (char*)src2) >=0) return true;
1231 else return false;
1232 }else if (OpNotEquals == op) {
1233 if (strcmp((char*)src1, (char*)src2) != 0) return true;
1234 else return false;
1235 }else if (OpLike == op) {
1236 return !os::strmatch((char*)src2, (char*)src1);
1237 }
1238 printf("Illegeal Operator:Not supported for String\n");
1239 return false;
1240 }
1241
1242 bool AllDataType::compareBinaryVal(void* src1, void *src2,
1243 ComparisionOp op, int length)
1244 {
1245 bool result = false;
1246 int ret = os::memcmp(src1, src2, length);
1247 switch(op)
1248 {
1249 case OpEquals:
1250 if (ret == 0 ) result= true; else result = false;
1251 break;
1252 case OpNotEquals:
1253 if (ret != 0 ) result= true; else result = false;
1254 break;
1255 case OpLessThan:
1256 if (ret < 0 ) result= true; else result = false;
1257 break;
1258 case OpLessThanEquals:
1259 printf("Illegal Operator:Not Supported for Binary\n");
1260 break;
1261 case OpGreaterThan:
1262 if (ret > 0 ) result= true; else result = false;
1263 break;
1264 case OpGreaterThanEquals:
1265 printf("Illegal Operator:Not Supported for Binary\n");
1266 break;
1267 }
1268 return result;
1269 }
1270 /*
1271 ComparisionOp AllDataType::getComparisionOperator(char *str)
1272 {
1273 ComparisionOp op;
1274 if (strcmp(str, "<=") == 0)
1275 op = OpLessThanEquals;
1276 else if (strcmp(str, ">=") == 0)
1277 op = OpGreaterThanEquals;
1278 else if (strcmp(str, "<") == 0)
1279 op = OpLessThan;
1280 else if (strcmp(str, ">") == 0)
1281 op = OpGreaterThan;
1282 else if (strcmp(str, "=") == 0)
1283 op = OpEquals;
1284 else if (strcmp(str, "!=") == 0 || strcmp(str, "<>") == 0 )
1285 op = OpNotEquals;
1286 else if (strcasecmp(str, "LIKE") == 0 )
1287 op = OpLike;
1288 else
1289 op = OpInvalidComparisionOp;
1290 return op;
1291 }
1292 */
1293
1294 void* AllDataType::alloc(DataType type, int length)
1295 {
1296 void *dest;
1297 switch(type)
1298 {
1299 case typeInt:
1300 dest = malloc(sizeof(int));
1301 break;
1302 case typeLong:
1303 dest = malloc(sizeof(long));
1304 break;
1305 case typeLongLong:
1306 dest = malloc(sizeof(long long));
1307 break;
1308 case typeShort:
1309 dest = malloc(sizeof(short));
1310 break;
1311 case typeByteInt:
1312 dest = malloc(sizeof(char));
1313 break;
1314 case typeDouble:
1315 dest = malloc(sizeof(double));
1316 break;
1317 case typeFloat:
1318 dest = malloc(sizeof(float));
1319 break;
1320 case typeDecimal:
1321 //TODO::for porting
1322 //fldDef.length_ = sizeof(long double);
1323 break;
1324 case typeString:
1325 if (length == 0 ) return NULL;
1326 dest = malloc(length);
1327 break;
1328 case typeBinary:
1329 if (length == 0 || length > 512) return NULL;
1330 dest = malloc(length);
1331 memset(dest, 0, length);
1332 break;
1333 case typeDate:
1334 dest = malloc(sizeof(Date));
1335 break;
1336 case typeTime:
1337 dest = malloc(sizeof(Time));
1338 break;
1339 case typeTimeStamp:
1340 dest = malloc(sizeof(TimeStamp));
1341 break;
1342 }
1343 return dest;
1344 }
1345
1346 void AllDataType::memoryset(void *value,DataType type)
1347 {
1348 switch(type)
1349 {
1350 case typeInt:
1351 value= ::memset(value, 0, sizeof(int));
1352 break;
1353 case typeLong:
1354 value = ::memset(value, 0, sizeof(long));
1355 break;
1356 case typeLongLong:
1357 value =::memset(value, 0, sizeof(long long));
1358 break;
1359 case typeShort:
1360 value = ::memset(value, 0, sizeof(short));
1361 break;
1362 case typeByteInt:
1363 value = ::memset(value, 0, sizeof(char));
1364 break;
1365 case typeDouble:
1366 value = ::memset(value, 0, sizeof(double));
1367 break;
1368 case typeFloat:
1369 value = ::memset(value, 0, sizeof(float));
1370 break;
1371 case typeDecimal:
1372 break;
1373 case typeString:
1374 *(char*)value = '\0';
1375 //if (length == 0 ) return NULL;
1376 //dest = malloc(length);
1377 break;
1378 case typeBinary:
1379 /* if (length == 0 || length > 256 ) return NULL;
1380
1381 memset(dest, 0, length);*/
1382 break;
1383 case typeDate:
1384 value = ::memset(value, 0, sizeof(Date));
1385 break;
1386 case typeTime:
1387 value = ::memset(value, 0, sizeof(Time));
1388 break;
1389 case typeTimeStamp:
1390 value = ::memset(value, 0, sizeof(TimeStamp));
1391 break;
1392 defalut:
1393 break;
1394 }
1395 }
1396
1397
1398 DbRetVal AllDataType::strToValue(void* dest, char *src, DataType type, int length)
1399 {
1400 switch(type)
1401 {
1402 case typeInt: {
1403 int val;
1404 sscanf( src, "%d", &val);
1405 *(int*)dest = val;
1406 break; }
1407 case typeLong: {
1408 long val;
1409 sscanf( src, "%ld", &val);
1410 *(long*)dest = val;
1411 break; }
1412 case typeLongLong: {
1413 long long val;
1414 sscanf( src, "%lld", &val);
1415 *(long long*)dest = val;
1416 break; }
1417 case typeShort: {
1418 short val;
1419 sscanf( src, "%hd", &val);
1420 *(short*)dest = val;
1421 break; }
1422 case typeByteInt: {
1423 int val;
1424 sscanf( src, "%d", &val);
1425 *(char*)dest = *(char *)&val;
1426 break; }
1427 case typeDouble: {
1428 double val;
1429 sscanf( src, "%lg", &val);
1430 *(double*)dest = val;
1431 break; }
1432 case typeFloat: {
1433 float val;
1434 sscanf( src, "%f", &val);
1435 *(float*)dest = val;
1436 break; }
1437 case typeDecimal:
1438 //TODO::for porting
1439 case typeString: {
1440 strncpy((char*)dest, (char*)src, length);
1441 char *d =(char*)dest;
1442 d[length-1] = '\0';
1443 break;}
1444 case typeDate: {
1445 int d,m,y,res=0;
1446 res = sscanf( src, "%d-%d-%d", &y, &m, &d );
1447 if( res != 3 )
1448 res = sscanf( src, "%d/%d/%d", &y, &m, &d );
1449 if( res != 3 )
1450 {
1451 fprintf(stderr,"Error reading date. yyyy{-/}mm{-/}dd is the valid format.");
1452 d=m=y=0;
1453 }
1454 Date dateObj(y,m,d);
1455 *(Date*)dest = dateObj;
1456 break; }
1457 case typeTime: {
1458 int h,m,s,res=0;
1459 res = sscanf( src, "%d:%d:%d", &h, &m, &s );
1460 if( res != 3 )
1461 {
1462 fprintf(stderr, "Error reading time, hh:mm:ss is the valid format.");
1463 h=m=s=0;
1464 }
1465 Time timeObj(h,m,s);
1466 *(Time*)dest = timeObj;
1467 break; }
1468 case typeTimeStamp: {
1469 int d,m,y, h,mn,s, res=0;
1470 res = sscanf( src, "%d-%d-%d %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1471 if( res != 6 )
1472 res = sscanf( src, "%d-%d-%d, %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1473 if( res != 6 )
1474 res = sscanf( src, "%d/%d/%d %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1475 if( res != 6 )
1476 res = sscanf( src, "%d/%d/%d, %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1477 if( res != 6 )
1478 {
1479 fprintf(stderr, "Error reading timestamp, yyyy{-/}mm{-/}dd[,] hh:mm:ss is the valid format.");
1480 d=m=y=h=mn=s=0;
1481 }
1482 TimeStamp timeStampObj(y,m,d,h,mn,s);
1483 *(TimeStamp*)dest = timeStampObj;
1484 break; }
1485 case typeBinary: {
1486 memset ((void *) dest, 0, length);
1487 unsigned char c = 0;
1488 const char *str = (const char *)src;
1489 int i=0;
1490 i = strlen(src)-1;
1491 if( i > (length*2)-1 ){ i = (length*2)-1 ; }
1492 bool evenlegth=false;
1493 if(i%2){ evenlegth=true;}
1494 unsigned char *val = (unsigned char *)dest+(length-1);
1495 while (i >= 0) {
1496 c = str[i];
1497 if (!isxdigit((int)c)) {
1498 printError(ErrBadArg, "Invalid hexadecimal value");
1499 return ErrBadArg;
1500 }
1501 if (c <= '9') c -= '0';
1502 else if (c >= 'a') c = c - 'a' + 10;
1503 else c = c - 'A' + 10;
1504 if(evenlegth)
1505 {
1506 if ((i+1) % 2) { *val = *val | (c<<4); val--;}
1507 else { *val = c; }
1508 }else{
1509 if (i % 2) { *val = *val | (c<<4); val--;}
1510 else { *val = c; }
1511 }
1512 i--;
1513 }
1514 break;
1515 }
1516 default:
1517 break;
1518 }
1519 return OK;
1520 }
1521
1522
1523 void AllDataType::convert(DataType srcType, void *src,
1524 DataType destType, void *dest, int length)
1525 {
1526 switch ((DataType) destType )
1527 {
1528 case typeInt: convertToInt(dest, src, srcType); break;
1529 case typeLong: convertToLong(dest, src, srcType); break;
1530 case typeLongLong: convertToLongLong(dest, src, srcType); break;
1531 case typeShort: convertToShort(dest, src, srcType); break;
1532 case typeByteInt: convertToByteInt(dest, src, srcType); break;
1533
1534 case typeFloat: convertToFloat(dest, src, srcType); break;
1535 case typeDouble: convertToDouble(dest, src, srcType); break;
1536
1537 //TODO
1538 case typeDecimal: convertToDouble(dest, src, srcType); break;
1539
1540 case typeString: convertToString(dest, src, srcType); break;
1541 case typeBinary: convertToBinary(dest, src, srcType,length); break;
1542 case typeDate: convertToDate(dest, src, srcType); break;
1543 case typeTime: convertToTime(dest, src, srcType); break;
1544 case typeTimeStamp: convertToTimeStamp(dest, src, srcType); break;
1545 default: return;
1546 }
1547 }
1548
1549 void AllDataType::convertToInt( void* dest, void* src, DataType srcType )
1550 {
1551 switch(srcType)
1552 {
1553 case typeInt: *(int *)dest = *(int *)src; break;
1554 case typeLong: *(int *)dest =(int) *(long *)src; break;
1555 case typeLongLong: *(int *)dest =(int) *(long long *)src; break;
1556 case typeShort: *(int *)dest =(int) *(short *)src; break;
1557 case typeByteInt: *(int *)dest =(int) *(char *)src; break;
1558
1559 case typeFloat: *(int *)dest = (int) *(float *)src; break;
1560 case typeDouble: *(int *)dest =(int) *(double *)src; break;
1561
1562 case typeString: sscanf((const char*)src, "%d", (int*) dest); break;
1563
1564 case typeDate:
1565 case typeTime:
1566 case typeTimeStamp:
1567 case typeBinary:
1568 default: *(int *)dest = (int) 0;
1569 }
1570 }
1571
1572 void AllDataType::convertToLong( void* dest, void* src, DataType srcType )
1573 {
1574 switch(srcType)
1575 {
1576 case typeInt: *(long *)dest =(long) *(int *)src; break;
1577 case typeLong: *(long *)dest = *(long *)src; break;
1578 case typeLongLong: *(long *)dest =(long) *(long long *)src; break;
1579 case typeShort: *(long *)dest =(long) *(short *)src; break;
1580 case typeByteInt: *(long *)dest =(long) *(char *)src; break;
1581
1582 case typeFloat: *(long *)dest = (long) *(float *)src; break;
1583 case typeDouble: *(long *)dest =(long) *(double *)src; break;
1584
1585 case typeString: sscanf((const char*)src, "%ld", (long*) dest); break;
1586
1587 case typeDate:
1588 case typeTime:
1589 case typeTimeStamp:
1590 case typeBinary:
1591 default: *(long *)dest = (long) 0;
1592 }
1593 }
1594
1595
1596 void AllDataType::convertToLongLong( void* dest, void* src, DataType srcType )
1597 {
1598 switch(srcType)
1599 {
1600 case typeInt: *(long long *)dest =(long long) *(int *)src; break;
1601 case typeLong: *(long long *)dest = (long long) *(long *)src; break;
1602 case typeLongLong: *(long long *)dest = *(long long *)src; break;
1603 case typeShort: *(long long *)dest =(long long) *(short *)src; break;
1604 case typeByteInt: *(long long *)dest =(long long) *(char *)src; break;
1605
1606 case typeFloat: *(long long *)dest = (long long) *(float *)src; break;
1607 case typeDouble: *(long long *)dest =(long long) *(double *)src; break;
1608
1609 case typeString: sscanf((const char*)src, "%lld", (long long*) dest); break;
1610
1611 case typeDate:
1612 case typeTime:
1613 case typeTimeStamp:
1614 case typeBinary:
1615 default: *(long long *)dest = (long long) 0;
1616 }
1617 }
1618
1619 void AllDataType::convertToShort( void* dest, void* src, DataType srcType )
1620 {
1621 switch(srcType)
1622 {
1623 case typeInt: *(short*)dest =(short) *(int*)src; break;
1624 case typeLong: *(short*)dest = (short) *(long*)src; break;
1625 case typeLongLong: *(short*)dest = (short) *(long long*)src; break;
1626 case typeShort: *(short*)dest = *(short*)src; break;
1627 case typeByteInt: *(short*)dest =(short) *(char *)src; break;
1628
1629 case typeFloat: *(short*)dest = (short) *(float *)src; break;
1630 case typeDouble: *(short*)dest =(short) *(double *)src; break;
1631
1632 case typeString: sscanf((const char*)src, "%hd", (short*) dest); break;
1633
1634 case typeDate:
1635 case typeTime:
1636 case typeTimeStamp:
1637 case typeBinary:
1638 default: *(short*)dest = (short) 0;
1639 }
1640 }
1641
1642 void AllDataType::convertToByteInt( void* dest, void* src, DataType srcType )
1643 {
1644 switch(srcType)
1645 {
1646 case typeInt: *(char*)dest = (char) *(int*)src; break;
1647 case typeLong: *(char*)dest = (char) *(long*)src; break;
1648 case typeLongLong: *(char*)dest = (char) *(long long*)src; break;
1649 case typeShort: *(char*)dest = (char) *(short*)src; break;
1650 case typeByteInt: *(char*)dest = *(char *)src; break;
1651
1652 case typeFloat: *(char*)dest = (char) *(float *)src; break;
1653 case typeDouble: *(char*)dest =(char) *(double *)src; break;
1654
1655 case typeString: sscanf((const char*)src, "%c", (char*) dest); break;
1656
1657 case typeDate:
1658 case typeTime:
1659 case typeTimeStamp:
1660 case typeBinary:
1661 default: *(char*)dest = (char) 0;
1662 }
1663 }
1664
1665 void AllDataType::convertToFloat( void* dest, void* src, DataType srcType )
1666 {
1667 switch(srcType)
1668 {
1669 case typeInt: *(float *)dest =(float) *(int *)src; break;
1670 case typeLong: *(float *)dest =(float) *(long *)src; break;
1671 case typeLongLong: *(float *)dest =(float) *(long long *)src; break;
1672 case typeShort: *(float *)dest =(float) *(short *)src; break;
1673 case typeByteInt: *(float *)dest =(float) *(char *)src; break;
1674
1675 case typeFloat: *(float *)dest = *(float *)src; break;
1676 case typeDouble: *(float *)dest =(float) *(double *)src; break;
1677
1678 case typeString: sscanf((const char*)src, "%f", (float*) dest); break;
1679
1680 case typeDate:
1681 case typeTime:
1682 case typeTimeStamp:
1683 case typeBinary:
1684 default: *(float *)dest = (float) 0;
1685 }
1686 }
1687
1688 void AllDataType::convertToDouble( void* dest, void* src, DataType srcType )
1689 {
1690 switch(srcType)
1691 {
1692 case typeInt: *(double *)dest =(double) *(int *)src; break;
1693 case typeLong: *(double *)dest =(double) *(long *)src; break;
1694 case typeLongLong: *(double *)dest =(double) *(long long *)src; break;
1695 case typeShort: *(double *)dest =(double) *(short *)src; break;
1696 case typeByteInt: *(double *)dest =(double) *(char *)src; break;
1697
1698 case typeFloat: *(double *)dest =(double) *(float *)src; break;
1699 case typeDouble: *(double *)dest = *(double *)src; break;
1700
1701 case typeString: sscanf((const char*)src, "%lf", (double*) dest); break;
1702
1703 case typeDate:
1704 case typeTime:
1705 case typeTimeStamp:
1706 case typeBinary:
1707 default: *(double *)dest = (double) 0;
1708 }
1709 }
1710
1711 void AllDataType::convertToString( void* dest, void* src, DataType srcType, int length )
1712 {
1713 switch(srcType)
1714 {
1715 case typeInt:
1716 {
1717 sprintf ((char *)dest, "%d", *(int *)src);
1718 break;
1719 }
1720 case typeLong:
1721 {
1722 sprintf ((char *)dest, "%ld", *(long *)src);
1723 break;
1724 }
1725 case typeLongLong:
1726 {
1727 sprintf ((char *)dest, "%lld", *(long long *)src);
1728 break;
1729 }
1730 case typeShort:
1731 {
1732 sprintf ((char *)dest, "%hd", *(short *)src);
1733 break;
1734 }
1735 case typeByteInt:
1736 {
1737 sprintf ((char *)dest, "%hd", *(char *)src);
1738 break;
1739 }
1740
1741 case typeFloat:
1742 {
1743 sprintf ((char *)dest, "%f", *(float *)src);
1744 break;
1745 }
1746 case typeDouble:
1747 {
1748 sprintf ((char *) dest, "%lf", *(double *)src);
1749 break;
1750 }
1751
1752 case typeString:
1753 {
1754 strcpy((char*)dest, (char*)src);
1755 break;
1756 }
1757 case typeDate:
1758 {
1759 Date* dt = (Date*)src;
1760 sprintf((char*) dest, "%d/%d/%d", dt->year(),
1761 dt->month(), dt->dayOfMonth());
1762 break;
1763 }
1764 case typeTime:
1765 {
1766 Time* tm = (Time*)src;
1767 sprintf((char*)dest,"%d:%d:%d.%d", tm->hours(), tm->minutes(), tm->seconds(), 0);
1768 break;
1769 }
1770 case typeTimeStamp:
1771 {
1772 TimeStamp* tm = (TimeStamp*)src;
1773 sprintf((char*)dest, "%d/%d/%d %d:%d:%d.%d", tm->year(),
1774 tm->month(), tm->dayOfMonth(), tm->hours(),
1775 tm->minutes(), tm->seconds(), 0 );
1776 break;
1777 }
1778 case typeBinary:
1779 {
1780 unsigned char *c = (unsigned char *) src;
1781 unsigned char *str = (unsigned char *) dest;
1782 unsigned char p = 0;
1783 int i = 0;
1784 while (i < length) {
1785 p = *c >> 4;
1786 if (p < 10) sprintf ((char *)str++, "%c", '0' + p);
1787 else sprintf((char *)str++, "%c", 'A' + p - 10);
1788 p = *c & 0xF;
1789 if (p < 10) sprintf ((char *)str++, "%c", '0' + p);
1790 else sprintf((char *)str++, "%c", 'A' + p - 10);
1791 i++; c++;
1792 }
1793 break;
1794 }
1795
1796 default: ((char*)dest)[0] = '\0';
1797 }
1798
1799 }
1800 void AllDataType::convertToDate( void* dest, void* src, DataType srcType )
1801 {
1802 switch(srcType)
1803 {
1804 case typeInt:
1805 case typeLong:
1806 case typeLongLong:
1807 case typeShort:
1808 case typeByteInt:
1809 case typeFloat:
1810 case typeDouble:
1811 case typeDate:
1812 case typeTime:
1813 case typeTimeStamp:
1814 case typeString:
1815 {
1816 Date *dt = (Date*) dest;
1817 dt->parseFrom((char*)src);
1818 break;
1819 }
1820 default: ((char*)dest)[0] = '\0';
1821 }
1822 }
1823
1824 void AllDataType::convertToTime( void* dest, void* src, DataType srcType )
1825 {
1826 switch(srcType)
1827 {
1828 case typeInt:
1829 case typeLong:
1830 case typeLongLong:
1831 case typeShort:
1832 case typeByteInt:
1833 case typeFloat:
1834 case typeDouble:
1835 case typeDate:
1836 case typeTime:
1837 case typeTimeStamp:
1838 case typeString:
1839 {
1840 Time *dt = (Time*) dest;
1841 dt->parseFrom((char*)src);
1842 break;
1843 }
1844 default: ((char*)dest)[0] = '\0';
1845 }
1846 }
1847
1848 void AllDataType::convertToTimeStamp( void* dest, void* src, DataType srcType )
1849 {
1850 switch(srcType)
1851 {
1852 case typeInt:
1853 case typeLong:
1854 case typeLongLong:
1855 case typeShort:
1856 case typeByteInt:
1857 case typeFloat:
1858 case typeDouble:
1859 case typeDate:
1860 case typeTime:
1861 case typeTimeStamp:
1862 case typeString:
1863 {
1864 TimeStamp *dt = (TimeStamp*) dest;
1865 dt->parseFrom((char*)src);
1866 break;
1867 }
1868 default: ((char*)dest)[0] = '\0';
1869 }
1870 }
1871
1872 void AllDataType::convertToBinary(void *dest, void *src, DataType srcType, int length)
1873 {
1874 switch(srcType)
1875 {
1876 case typeString:
1877 {
1878 memset ((void *) dest, 0, length);
1879 unsigned char c = 0;
1880 const char *str = (const char *)src;
1881 int i=0;
1882 i = strlen((char*)src)-1;
1883 if( i > (length*2)-1 ){ i = (length*2)-1 ; }
1884 bool evenlegth=false;
1885 if(i%2){ evenlegth=true;}
1886 unsigned char *val = (unsigned char *)dest+(length-1);
1887 while (i >= 0) {
1888 c = str[i];
1889 if (c <= '9') c -= '0';
1890 else if (c >= 'a') c = c - 'a' + 10;
1891 else c = c - 'A' + 10;
1892 if(evenlegth)
1893 {
1894 if ((i+1) % 2) { *val = *val | (c<<4); val--;}
1895 else { *val = c; }
1896 }else{
1897 if (i % 2) { *val = *val | (c<<4); val--;}
1898 else { *val = c; }
1899 }
1900 i--;
1901 }
1902 break;
1903 }
1904 }
1905 }
1906 int AllDataType::printVal(void* src, DataType srcType, int length )
1907 {
1908 int count = 0;
1909 switch(srcType)
1910 {
1911 case typeInt:
1912 {
1913 count = printf ("%d", *(int *)src);
1914 break;
1915 }
1916 case typeLong:
1917 {
1918 count = printf ("%ld", *(long *)src);
1919 break;
1920 }
1921 case typeLongLong:
1922 {
1923 count = printf ("%lld", *(long long *)src);
1924 break;
1925 }
1926 case typeShort:
1927 {
1928 count = printf("%hd", *(short *)src);
1929 break;
1930 }
1931 case typeByteInt:
1932 {
1933 count = printf("%hd", *(char *)src);
1934 break;
1935 }
1936
1937 case typeFloat:
1938 {
1939 count = printf("%f", *(float *)src);
1940 break;
1941 }
1942 case typeDouble:
1943 {
1944 count = printf("%lf", *(double *)src);
1945 break;
1946 }
1947
1948 case typeString:
1949 {
1950 count = printf("%s", (char*)src);
1951 break;
1952 }
1953 case typeDate:
1954 {
1955 Date* dt = (Date*)src;
1956 count = printf("%d/%d/%d", dt->year(),
1957 dt->month(), dt->dayOfMonth());
1958 break;
1959 }
1960 case typeTime:
1961 {
1962 Time* tm = (Time*)src;
1963 count = printf("%d:%d:%d.%d", tm->hours(), tm->minutes(), tm->seconds(), 0);
1964 break;
1965 }
1966 case typeTimeStamp:
1967 {
1968 TimeStamp* tm = (TimeStamp*)src;
1969 count = printf("%d/%d/%d %d:%d:%d.%d", tm->year(),
1970 tm->month(), tm->dayOfMonth(), tm->hours(),
1971 tm->minutes(), tm->seconds(), 0 );
1972 break;
1973 }
1974 case typeBinary:
1975 {
1976 unsigned char *c = (unsigned char *) src;
1977 unsigned char p = 0;
1978 int i = 0;
1979 bool isDigitFound=false;
1980 while (i < length) {
1981 p = *c >> 4;
1982 if(('0'+p)!='0'|| isDigitFound){
1983 if (p < 10) printf ("%c", '0' + p);
1984 else printf("%c", 'A' + p - 10);
1985 isDigitFound=true;
1986 }
1987 p = *c & 0xF;
1988 if(('0'+p)!='0' || isDigitFound){
1989 if (p < 10) printf ("%c", '0' + p);
1990 else printf("%c", 'A' + p - 10);
1991 isDigitFound=true;
1992 }
1993 i++; c++;
1994 }
1995 count = length * 2;
1996 break;
1997 }
1998 default: { printf("DataType not supported\n"); break; }
1999 }
2000 return count;
2001 }
2002
2003
2004
Main memory database SQL engine (cvs import)