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