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