?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Renamed server directory to storage directory in src
[csql.git] / src / storage / DataType.cxx
blob29807b555ec2b6d9a579986487c14a33d3960cb1
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
583 void AllDataType::divVal(void* dest, int src, DataType type)
584 {
585 switch(type)
586 {
587 case typeInt:
588 *(int*)dest = *(int*)dest / src;
589 break;
590 case typeLong:
591 *(long*)dest = *(long*)dest / src;
592 break;
593 case typeLongLong:
594 *(long long*)dest = *(long long*)dest / src;
595 break;
596 case typeShort:
597 *(short*)dest = *(short*)dest / src;
598 break;
599 case typeByteInt:
600 *(char*)dest = *(char*)dest / src;
601 break;
602 case typeDouble:
603 *(double*)dest = *(double*)dest / src;
604 break;
605 case typeFloat:
606 *(float*)dest = *(float*)dest / src;
607 break;
608 case typeDecimal:
609 //TODO::for porting
610 case typeDate:
611 case typeTime:
612 case typeTimeStamp:
613 case typeBinary:
614 default:
615 break;
616 }
617 return;
618 }
619
620
621
622
623 bool AllDataType::compareVal(void *val1, void *val2, ComparisionOp op,
624 DataType type, long length)
625 {
626 bool result = false;
627 switch(type)
628 {
629 case typeInt:
630 result = AllDataType::compareIntVal(val1, val2, op );
631 break;
632 case typeLong:
633 result = AllDataType::compareLongVal(val1, val2, op);
634 break;
635 case typeLongLong:
636 result = AllDataType::compareLongLongVal(val1, val2, op);
637 break;
638 case typeShort:
639 result = AllDataType::compareShortVal(val1, val2, op);
640 break;
641 case typeByteInt:
642 result = AllDataType::compareByteIntVal(val1, val2, op);
643 break;
644 case typeDouble:
645 result = AllDataType::compareDoubleVal(val1, val2, op);
646 break;
647 case typeFloat:
648 result = AllDataType::compareFloatVal(val1, val2, op);
649 break;
650 case typeDecimal:
651 //TODO::for porting
652 break;
653 case typeDate:
654 result = AllDataType::compareDateVal(val1, val2, op);
655 break;
656 case typeTime:
657 result = AllDataType::compareTimeVal(val1, val2, op);
658 break;
659 case typeTimeStamp:
660 result = AllDataType::compareTimeStampVal(val1, val2, op);
661 break;
662 case typeString:
663 result = AllDataType::compareStringVal(val1, val2, op);
664 break;
665 case typeComposite:
666 case typeBinary:
667 result = AllDataType::compareBinaryVal(val1, val2, op, length);
668 break;
669 }
670 return result;
671 }
672
673 bool AllDataType::compareIntVal(void* src1, void *src2, ComparisionOp op)
674 {
675 if (src1 == NULL) printf("src1 is null\n");
676 if (src2 == NULL) printf("src2 is null\n");
677 bool result = false;
678 switch(op)
679 {
680 case OpEquals:
681 if (*(int*)src1 == *(int*)src2) result = true;
682 else result = false;
683 break;
684 case OpNotEquals:
685 if (*(int*)src1 != *(int*)src2) result = true;
686 else result = false;
687 break;
688 case OpLessThan:
689 if (*(int*)src1 < *(int*)src2) result = true;
690 else result = false;
691 break;
692 case OpLessThanEquals:
693 if (*(int*)src1 <= *(int*)src2) result = true;
694 else result = false;
695 break;
696 case OpGreaterThan:
697 if (*(int*)src1 > *(int*)src2) result = true;
698 else result = false;
699 break;
700 case OpGreaterThanEquals:
701 if (*(int*)src1 >= *(int*)src2) result = true;
702 else result = false;
703 break;
704 }
705 return result;
706 }
707
708 bool AllDataType::compareLongVal(void* src1, void *src2, ComparisionOp op)
709 {
710 bool result = false;
711 switch(op)
712 {
713 case OpEquals:
714 if (*(long*)src1 == *(long*)src2) result = true;
715 else result = false;
716 break;
717 case OpNotEquals:
718 if (*(long*)src1 != *(long*)src2) result = true;
719 else result = false;
720 break;
721 case OpLessThan:
722 if (*(long*)src1 < *(long*)src2) result = true;
723 else result = false;
724 break;
725 case OpLessThanEquals:
726 if (*(long*)src1 <= *(long*)src2) result = true;
727 else result = false;
728 break;
729 case OpGreaterThan:
730 if (*(long*)src1 > *(long*)src2) result = true;
731 else result = false;
732 break;
733 case OpGreaterThanEquals:
734 if (*(long*)src1 >= *(long*)src2) result = true;
735 else result = false;
736 break;
737 }
738 return result;
739 }
740
741 bool AllDataType::compareLongLongVal(void* src1, void *src2,
742 ComparisionOp op)
743 {
744 bool result = false;
745 switch(op)
746 {
747 case OpEquals:
748 if (*(long long*)src1 == *(long long*)src2) result = true;
749 else result = false;
750 break;
751 case OpNotEquals:
752 if (*(long long*)src1 != *(long long*)src2) result = true;
753 else result = false;
754 break;
755 case OpLessThan:
756 if (*(long long*)src1 < *(long long*)src2) result = true;
757 else result = false;
758 break;
759 case OpLessThanEquals:
760 if (*(long long*)src1 <= *(long long*)src2) result = true;
761 else result = false;
762 break;
763 case OpGreaterThan:
764 if (*(long long*)src1 > *(long long*)src2) result = true;
765 else result = false;
766 break;
767 case OpGreaterThanEquals:
768 if (*(long long*)src1 >= *(long long*)src2) result = true;
769 else result = false;
770 break;
771 }
772 return result;
773 }
774
775 bool AllDataType::compareShortVal(void* src1, void *src2, ComparisionOp op)
776 {
777 bool result = false;
778 switch(op)
779 {
780 case OpEquals:
781 if (*(short*)src1 == *(short*)src2) result = true;
782 else result = false;
783 break;
784 case OpNotEquals:
785 if (*(short*)src1 != *(short*)src2) result = true;
786 else result = false;
787 break;
788 case OpLessThan:
789 if (*(short*)src1 < *(short*)src2) result = true;
790 else result = false;
791 break;
792 case OpLessThanEquals:
793 if (*(short*)src1 <= *(short*)src2) result = true;
794 else result = false;
795 break;
796 case OpGreaterThan:
797 if (*(short*)src1 > *(short*)src2) result = true;
798 else result = false;
799 break;
800 case OpGreaterThanEquals:
801 if (*(short*)src1 >= *(short*)src2) result = true;
802 else result = false;
803 break;
804 }
805 return result;
806 }
807
808 bool AllDataType::compareByteIntVal(void* src1, void *src2, ComparisionOp op)
809 {
810 bool result = false;
811 switch(op)
812 {
813 case OpEquals:
814 if (*(ByteInt*)src1 == *(ByteInt*)src2) result = true;
815 else result = false;
816 break;
817 case OpNotEquals:
818 if (*(ByteInt*)src1 != *(ByteInt*)src2) result = true;
819 else result = false;
820 break;
821 case OpLessThan:
822 if (*(ByteInt*)src1 < *(ByteInt*)src2) result = true;
823 else result = false;
824 break;
825 case OpLessThanEquals:
826 if (*(ByteInt*)src1 <= *(ByteInt*)src2) result = true;
827 else result = false;
828 break;
829 case OpGreaterThan:
830 if (*(ByteInt*)src1 > *(ByteInt*)src2) result = true;
831 else result = false;
832 break;
833 case OpGreaterThanEquals:
834 if (*(ByteInt*)src1 >= *(ByteInt*)src2) result = true;
835 else result = false;
836 break;
837 }
838 return result;
839 }
840
841 bool AllDataType::compareDoubleVal(void* src1, void *src2, ComparisionOp op)
842 {
843 bool result = false;
844 switch(op)
845 {
846 case OpEquals:
847 if (*(double*)src1 == *(double*)src2) result = true;
848 else result = false;
849 break;
850 case OpNotEquals:
851 if (*(double*)src1 != *(double*)src2) result = true;
852 else result = false;
853 break;
854 case OpLessThan:
855 if (*(double*)src1 < *(double*)src2) result = true;
856 else result = false;
857 break;
858 case OpLessThanEquals:
859 if (*(double*)src1 <= *(double*)src2) result = true;
860 else result = false;
861 break;
862 case OpGreaterThan:
863 if (*(double*)src1 > *(double*)src2) result = true;
864 else result = false;
865 break;
866 case OpGreaterThanEquals:
867 if (*(double*)src1 >= *(double*)src2) result = true;
868 else result = false;
869 break;
870 }
871 return result;
872 }
873
874 bool AllDataType::compareFloatVal(void* src1, void *src2, ComparisionOp op)
875 {
876 bool result = false;
877 switch(op)
878 {
879 case OpEquals:
880 if (*(float*)src1 == *(float*)src2) result = true;
881 else result = false;
882 break;
883 case OpNotEquals:
884 if (*(float*)src1 != *(float*)src2) result = true;
885 else result = false;
886 break;
887 case OpLessThan:
888 if (*(float*)src1 < *(float*)src2) result = true;
889 else result = false;
890 break;
891 case OpLessThanEquals:
892 if (*(float*)src1 <= *(float*)src2) result = true;
893 else result = false;
894 break;
895 case OpGreaterThan:
896 if (*(float*)src1 > *(float*)src2) result = true;
897 else result = false;
898 break;
899 case OpGreaterThanEquals:
900 if (*(float*)src1 >= *(float*)src2) result = true;
901 else result = false;
902 break;
903 }
904 return result;
905 }
906
907 bool AllDataType::compareDateVal(void* src1, void *src2, ComparisionOp op)
908 {
909 bool result = false;
910 switch(op)
911 {
912 case OpEquals:
913 if (*(Date*)src1 == *(Date*)src2) result = true;
914 else result = false;
915 break;
916 case OpNotEquals:
917 if (*(Date*)src1 != *(Date*)src2) result = true;
918 else result = false;
919 break;
920 case OpLessThan:
921 if (*(Date*)src1 < *(Date*)src2) result = true;
922 else result = false;
923 break;
924 case OpLessThanEquals:
925 if (*(Date*)src1 <= *(Date*)src2) result = true;
926 else result = false;
927 break;
928 case OpGreaterThan:
929 if (*(Date*)src1 > *(Date*)src2) result = true;
930 else result = false;
931 break;
932 case OpGreaterThanEquals:
933 if (*(Date*)src1 >= *(Date*)src2) result = true;
934 else result = false;
935 break;
936 }
937 return result;
938 }
939
940 bool AllDataType::compareTimeVal(void* src1, void *src2, ComparisionOp op)
941 {
942 bool result = false;
943 switch(op)
944 {
945 case OpEquals:
946 if (*(Time*)src1 == *(Time*)src2) result = true;
947 else result = false;
948 break;
949 case OpNotEquals:
950 if (*(Time*)src1 != *(Time*)src2) result = true;
951 else result = false;
952 break;
953 case OpLessThan:
954 if (*(Time*)src1 < *(Time*)src2) result = true;
955 else result = false;
956 break;
957 case OpLessThanEquals:
958 if (*(Time*)src1 <= *(Time*)src2) result = true;
959 else result = false;
960 break;
961 case OpGreaterThan:
962 if (*(Time*)src1 > *(Time*)src2) result = true;
963 else result = false;
964 break;
965 case OpGreaterThanEquals:
966 if (*(Time*)src1 >= *(Time*)src2) result = true;
967 else result = false;
968 break;
969 }
970 return result;
971 }
972
973 bool AllDataType::compareTimeStampVal(void* src1, void *src2, ComparisionOp op)
974 {
975 bool result = false;
976 switch(op)
977 {
978 case OpEquals:
979 if (*(TimeStamp*)src1 == *(TimeStamp*)src2) result = true;
980 else result = false;
981 break;
982 case OpNotEquals:
983 if (*(TimeStamp*)src1 != *(TimeStamp*)src2) result = true;
984 else result = false;
985 break;
986 case OpLessThan:
987 if (*(TimeStamp*)src1 < *(TimeStamp*)src2) result = true;
988 else result = false;
989 break;
990 case OpLessThanEquals:
991 if (*(TimeStamp*)src1 <= *(TimeStamp*)src2) result = true;
992 else result = false;
993 break;
994 case OpGreaterThan:
995 if (*(TimeStamp*)src1 > *(TimeStamp*)src2) result = true;
996 else result = false;
997 break;
998 case OpGreaterThanEquals:
999 if (*(TimeStamp*)src1 >= *(TimeStamp*)src2) result = true;
1000 else result = false;
1001 break;
1002 }
1003 return result;
1004 }
1005
1006 bool AllDataType::compareStringVal(void* src1, void *src2, ComparisionOp op)
1007 {
1008 bool result = false;
1009 int ret = strcmp((char*)src1, (char*)src2);
1010 switch(op)
1011 {
1012 case OpEquals:
1013 if (ret == 0 ) result= true; else result = false;
1014 break;
1015 case OpNotEquals:
1016 if (ret != 0 ) result= true; else result = false;
1017 break;
1018 case OpLessThan:
1019 if (ret < 0 ) result= true; else result = false;
1020 break;
1021 case OpLessThanEquals:
1022 printf("Illegal Operator:Not Supported for String\n");
1023 break;
1024 case OpGreaterThan:
1025 if (ret > 0 ) result= true; else result = false;
1026 break;
1027 case OpGreaterThanEquals:
1028 printf("Illegal Operator:Not Supported for String\n");
1029 break;
1030 }
1031 return result;
1032 }
1033
1034 bool AllDataType::compareBinaryVal(void* src1, void *src2,
1035 ComparisionOp op, int length)
1036 {
1037 bool result = false;
1038 int ret = os::memcmp(src1, src2, length);
1039 switch(op)
1040 {
1041 case OpEquals:
1042 if (ret == 0 ) result= true; else result = false;
1043 break;
1044 case OpNotEquals:
1045 if (ret != 0 ) result= true; else result = false;
1046 break;
1047 case OpLessThan:
1048 if (ret < 0 ) result= true; else result = false;
1049 break;
1050 case OpLessThanEquals:
1051 printf("Illegal Operator:Not Supported for Binary\n");
1052 break;
1053 case OpGreaterThan:
1054 if (ret > 0 ) result= true; else result = false;
1055 break;
1056 case OpGreaterThanEquals:
1057 printf("Illegal Operator:Not Supported for Binary\n");
1058 break;
1059 }
1060 return result;
1061 }
1062
1063
1064
1065 ComparisionOp AllDataType::getComparisionOperator(char *str)
1066 {
1067 ComparisionOp op;
1068 if (strcmp(str, "<=") == 0)
1069 op = OpLessThanEquals;
1070 else if (strcmp(str, ">=") == 0)
1071 op = OpGreaterThanEquals;
1072 else if (strcmp(str, "<") == 0)
1073 op = OpLessThan;
1074 else if (strcmp(str, ">") == 0)
1075 op = OpGreaterThan;
1076 else if (strcmp(str, "=") == 0)
1077 op = OpEquals;
1078 else if (strcmp(str, "!=") == 0 || strcmp(str, "<>") == 0 )
1079 op = OpNotEquals;
1080 else if (strcasecmp(str, "LIKE") == 0 )
1081 op = OpLike;
1082 else
1083 op = OpInvalidComparisionOp;
1084 return op;
1085 }
1086
1087 void* AllDataType::alloc(DataType type, int length)
1088 {
1089 void *dest;
1090 switch(type)
1091 {
1092 case typeInt:
1093 dest = malloc(sizeof(int));
1094 break;
1095 case typeLong:
1096 dest = malloc(sizeof(long));
1097 break;
1098 case typeLongLong:
1099 dest = malloc(sizeof(long long));
1100 break;
1101 case typeShort:
1102 dest = malloc(sizeof(short));
1103 break;
1104 case typeByteInt:
1105 dest = malloc(sizeof(char));
1106 break;
1107 case typeDouble:
1108 dest = malloc(sizeof(double));
1109 break;
1110 case typeFloat:
1111 dest = malloc(sizeof(float));
1112 break;
1113 case typeDecimal:
1114 //TODO::for porting
1115 //fldDef.length_ = sizeof(long double);
1116 break;
1117 case typeString:
1118 if (length == 0 ) return NULL;
1119 dest = malloc(length);
1120 break;
1121 case typeBinary:
1122 if (length == 0 || length > 256 ) return NULL;
1123 dest = malloc(length);
1124 memset(dest, 0, length);
1125 break;
1126 case typeDate:
1127 dest = malloc(sizeof(Date));
1128 break;
1129 case typeTime:
1130 dest = malloc(sizeof(Time));
1131 break;
1132 case typeTimeStamp:
1133 dest = malloc(sizeof(TimeStamp));
1134 break;
1135 }
1136 return dest;
1137 }
1138 DbRetVal AllDataType::strToValue(void* dest, char *src, DataType type, int length)
1139 {
1140 switch(type)
1141 {
1142 case typeInt: {
1143 int val;
1144 sscanf( src, "%d", &val);
1145 *(int*)dest = val;
1146 break; }
1147 case typeLong: {
1148 long val;
1149 sscanf( src, "%ld", &val);
1150 *(long*)dest = val;
1151 break; }
1152 case typeLongLong: {
1153 long long val;
1154 sscanf( src, "%lld", &val);
1155 *(long long*)dest = val;
1156 break; }
1157 case typeShort: {
1158 short val;
1159 sscanf( src, "%hd", &val);
1160 *(short*)dest = val;
1161 break; }
1162 case typeByteInt: {
1163 char val;
1164 sscanf( src, "%c", &val);
1165 *(char*)dest = val;
1166 break; }
1167 case typeDouble: {
1168 double val;
1169 sscanf( src, "%lg", &val);
1170 *(double*)dest = val;
1171 break; }
1172 case typeFloat: {
1173 float val;
1174 sscanf( src, "%f", &val);
1175 *(float*)dest = val;
1176 break; }
1177 case typeDecimal:
1178 //TODO::for porting
1179 case typeString: {
1180 strncpy((char*)dest, (char*)src, length);
1181 char *d =(char*)dest;
1182 d[length-1] = '\0';
1183 break;}
1184 case typeDate: {
1185 int d,m,y,res=0;
1186 res = sscanf( src, "%d-%d-%d", &y, &m, &d );
1187 if( res != 3 )
1188 res = sscanf( src, "%d/%d/%d", &y, &m, &d );
1189 if( res != 3 )
1190 {
1191 fprintf(stderr,"Error reading date. yyyy{-/}mm{-/}dd is the valid format.");
1192 d=m=y=0;
1193 }
1194 Date dateObj(y,m,d);
1195 *(Date*)dest = dateObj;
1196 break; }
1197 case typeTime: {
1198 int h,m,s,res=0;
1199 res = sscanf( src, "%d:%d:%d", &h, &m, &s );
1200 if( res != 3 )
1201 {
1202 fprintf(stderr, "Error reading time, hh:mm:ss is the valid format.");
1203 h=m=s=0;
1204 }
1205 Time timeObj(h,m,s);
1206 *(Time*)dest = timeObj;
1207 break; }
1208 case typeTimeStamp: {
1209 int d,m,y, h,mn,s, res=0;
1210 res = sscanf( src, "%d-%d-%d %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1211 if( res != 6 )
1212 res = sscanf( src, "%d-%d-%d, %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1213 if( res != 6 )
1214 res = sscanf( src, "%d/%d/%d %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1215 if( res != 6 )
1216 res = sscanf( src, "%d/%d/%d, %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1217 if( res != 6 )
1218 {
1219 fprintf(stderr, "Error reading timestamp, yyyy{-/}mm{-/}dd[,] hh:mm:ss is the valid format.");
1220 d=m=y=h=mn=s=0;
1221 }
1222 TimeStamp timeStampObj(y,m,d,h,mn,s);
1223 *(TimeStamp*)dest = timeStampObj;
1224 break; }
1225 case typeBinary: {
1226 memset ((void *) dest, 0, length * 2);
1227 unsigned char c = 0;
1228 const char *str = (const char *)src;
1229 unsigned char *val = (unsigned char *)dest;
1230 int i = 0;
1231 while (i < length * 2) {
1232 c = *str++; i++;
1233 if (c == '\0') { *val = *val | c; break; }
1234 if (!isxdigit((int)c)) {
1235 printError(ErrBadArg, "Invalid hexadecimal value");
1236 return ErrBadArg;
1237 }
1238 if (c <= '9') c -= '0';
1239 else if (c >= 'a') c = c - 'a' + 10;
1240 else c = c - 'A' + 10;
1241 if (i % 2) { *val = c; *val <<= 4; }
1242 else { *val = *val | c; val++; }
1243 }
1244 break;
1245 }
1246 default:
1247 break;
1248 }
1249 return OK;
1250 }
1251
1252
1253 void AllDataType::convert(DataType srcType, void *src,
1254 DataType destType, void *dest, int length)
1255 {
1256 switch ((DataType) destType )
1257 {
1258 case typeInt: convertToInt(dest, src, srcType); break;
1259 case typeLong: convertToLong(dest, src, srcType); break;
1260 case typeLongLong: convertToLongLong(dest, src, srcType); break;
1261 case typeShort: convertToShort(dest, src, srcType); break;
1262 case typeByteInt: convertToByteInt(dest, src, srcType); break;
1263
1264 case typeFloat: convertToFloat(dest, src, srcType); break;
1265 case typeDouble: convertToDouble(dest, src, srcType); break;
1266
1267 //TODO
1268 case typeDecimal: convertToDouble(dest, src, srcType); break;
1269
1270 case typeString: convertToString(dest, src, srcType); break;
1271 case typeBinary: convertToBinary(dest, src, srcType,length); break;
1272 case typeDate: convertToDate(dest, src, srcType); break;
1273 case typeTime: convertToTime(dest, src, srcType); break;
1274 case typeTimeStamp: convertToTimeStamp(dest, src, srcType); break;
1275 default: return;
1276 }
1277 }
1278
1279 void AllDataType::convertToInt( void* dest, void* src, DataType srcType )
1280 {
1281 switch(srcType)
1282 {
1283 case typeInt: *(int *)dest = *(int *)src; break;
1284 case typeLong: *(int *)dest =(int) *(long *)src; break;
1285 case typeLongLong: *(int *)dest =(int) *(long long *)src; break;
1286 case typeShort: *(int *)dest =(int) *(short *)src; break;
1287 case typeByteInt: *(int *)dest =(int) *(char *)src; break;
1288
1289 case typeFloat: *(int *)dest = (int) *(float *)src; break;
1290 case typeDouble: *(int *)dest =(int) *(double *)src; break;
1291
1292 case typeString: sscanf((const char*)src, "%d", (int*) dest); break;
1293
1294 case typeDate:
1295 case typeTime:
1296 case typeTimeStamp:
1297 case typeBinary:
1298 default: *(int *)dest = (int) 0;
1299 }
1300 }
1301
1302 void AllDataType::convertToLong( void* dest, void* src, DataType srcType )
1303 {
1304 switch(srcType)
1305 {
1306 case typeInt: *(long *)dest =(long) *(int *)src; break;
1307 case typeLong: *(long *)dest = *(long *)src; break;
1308 case typeLongLong: *(long *)dest =(long) *(long long *)src; break;
1309 case typeShort: *(long *)dest =(long) *(short *)src; break;
1310 case typeByteInt: *(long *)dest =(long) *(char *)src; break;
1311
1312 case typeFloat: *(long *)dest = (long) *(float *)src; break;
1313 case typeDouble: *(long *)dest =(long) *(double *)src; break;
1314
1315 case typeString: sscanf((const char*)src, "%ld", (long*) dest); break;
1316
1317 case typeDate:
1318 case typeTime:
1319 case typeTimeStamp:
1320 case typeBinary:
1321 default: *(long *)dest = (long) 0;
1322 }
1323 }
1324
1325
1326 void AllDataType::convertToLongLong( void* dest, void* src, DataType srcType )
1327 {
1328 switch(srcType)
1329 {
1330 case typeInt: *(long long *)dest =(long long) *(int *)src; break;
1331 case typeLong: *(long long *)dest = (long long) *(long *)src; break;
1332 case typeLongLong: *(long long *)dest = *(long long *)src; break;
1333 case typeShort: *(long long *)dest =(long long) *(short *)src; break;
1334 case typeByteInt: *(long long *)dest =(long long) *(char *)src; break;
1335
1336 case typeFloat: *(long long *)dest = (long long) *(float *)src; break;
1337 case typeDouble: *(long long *)dest =(long long) *(double *)src; break;
1338
1339 case typeString: sscanf((const char*)src, "%lld", (long long*) dest); break;
1340
1341 case typeDate:
1342 case typeTime:
1343 case typeTimeStamp:
1344 case typeBinary:
1345 default: *(long long *)dest = (long long) 0;
1346 }
1347 }
1348
1349 void AllDataType::convertToShort( void* dest, void* src, DataType srcType )
1350 {
1351 switch(srcType)
1352 {
1353 case typeInt: *(short*)dest =(short) *(int*)src; break;
1354 case typeLong: *(short*)dest = (short) *(long*)src; break;
1355 case typeLongLong: *(short*)dest = (short) *(long long*)src; break;
1356 case typeShort: *(short*)dest = *(short*)src; break;
1357 case typeByteInt: *(short*)dest =(short) *(char *)src; break;
1358
1359 case typeFloat: *(short*)dest = (short) *(float *)src; break;
1360 case typeDouble: *(short*)dest =(short) *(double *)src; break;
1361
1362 case typeString: sscanf((const char*)src, "%hd", (short*) dest); break;
1363
1364 case typeDate:
1365 case typeTime:
1366 case typeTimeStamp:
1367 case typeBinary:
1368 default: *(short*)dest = (short) 0;
1369 }
1370 }
1371
1372 void AllDataType::convertToByteInt( void* dest, void* src, DataType srcType )
1373 {
1374 switch(srcType)
1375 {
1376 case typeInt: *(char*)dest = (char) *(int*)src; break;
1377 case typeLong: *(char*)dest = (char) *(long*)src; break;
1378 case typeLongLong: *(char*)dest = (char) *(long long*)src; break;
1379 case typeShort: *(char*)dest = (char) *(short*)src; break;
1380 case typeByteInt: *(char*)dest = *(char *)src; break;
1381
1382 case typeFloat: *(char*)dest = (char) *(float *)src; break;
1383 case typeDouble: *(char*)dest =(char) *(double *)src; break;
1384
1385 case typeString: sscanf((const char*)src, "%c", (char*) dest); break;
1386
1387 case typeDate:
1388 case typeTime:
1389 case typeTimeStamp:
1390 case typeBinary:
1391 default: *(char*)dest = (char) 0;
1392 }
1393 }
1394
1395 void AllDataType::convertToFloat( void* dest, void* src, DataType srcType )
1396 {
1397 switch(srcType)
1398 {
1399 case typeInt: *(float *)dest =(float) *(int *)src; break;
1400 case typeLong: *(float *)dest =(float) *(long *)src; break;
1401 case typeLongLong: *(float *)dest =(float) *(long long *)src; break;
1402 case typeShort: *(float *)dest =(float) *(short *)src; break;
1403 case typeByteInt: *(float *)dest =(float) *(char *)src; break;
1404
1405 case typeFloat: *(float *)dest = *(float *)src; break;
1406 case typeDouble: *(float *)dest =(float) *(double *)src; break;
1407
1408 case typeString: sscanf((const char*)src, "%f", (float*) dest); break;
1409
1410 case typeDate:
1411 case typeTime:
1412 case typeTimeStamp:
1413 case typeBinary:
1414 default: *(float *)dest = (float) 0;
1415 }
1416 }
1417
1418 void AllDataType::convertToDouble( void* dest, void* src, DataType srcType )
1419 {
1420 switch(srcType)
1421 {
1422 case typeInt: *(double *)dest =(double) *(int *)src; break;
1423 case typeLong: *(double *)dest =(double) *(long *)src; break;
1424 case typeLongLong: *(double *)dest =(double) *(long long *)src; break;
1425 case typeShort: *(double *)dest =(double) *(short *)src; break;
1426 case typeByteInt: *(double *)dest =(double) *(char *)src; break;
1427
1428 case typeFloat: *(double *)dest =(double) *(float *)src; break;
1429 case typeDouble: *(double *)dest = *(double *)src; break;
1430
1431 case typeString: sscanf((const char*)src, "%lf", (double*) dest); break;
1432
1433 case typeDate:
1434 case typeTime:
1435 case typeTimeStamp:
1436 case typeBinary:
1437 default: *(double *)dest = (double) 0;
1438 }
1439 }
1440
1441 void AllDataType::convertToString( void* dest, void* src, DataType srcType, int length )
1442 {
1443 switch(srcType)
1444 {
1445 case typeInt:
1446 {
1447 sprintf ((char *)dest, "%d", *(int *)src);
1448 break;
1449 }
1450 case typeLong:
1451 {
1452 sprintf ((char *)dest, "%ld", *(long *)src);
1453 break;
1454 }
1455 case typeLongLong:
1456 {
1457 sprintf ((char *)dest, "%lld", *(long long *)src);
1458 break;
1459 }
1460 case typeShort:
1461 {
1462 sprintf ((char *)dest, "%hd", *(short *)src);
1463 break;
1464 }
1465 case typeByteInt:
1466 {
1467 sprintf ((char *)dest, "%hd", *(char *)src);
1468 break;
1469 }
1470
1471 case typeFloat:
1472 {
1473 sprintf ((char *)dest, "%f", *(float *)src);
1474 break;
1475 }
1476 case typeDouble:
1477 {
1478 sprintf ((char *) dest, "%lf", *(double *)src);
1479 break;
1480 }
1481
1482 case typeString:
1483 {
1484 strcpy((char*)dest, (char*)src);
1485 break;
1486 }
1487 case typeDate:
1488 {
1489 Date* dt = (Date*)src;
1490 sprintf((char*) dest, "%d/%d/%d", dt->year(),
1491 dt->month(), dt->dayOfMonth());
1492 break;
1493 }
1494 case typeTime:
1495 {
1496 Time* tm = (Time*)src;
1497 sprintf((char*)dest,"%d:%d:%d.%d", tm->hours(), tm->minutes(), tm->seconds(), 0);
1498 break;
1499 }
1500 case typeTimeStamp:
1501 {
1502 TimeStamp* tm = (TimeStamp*)src;
1503 sprintf((char*)dest, "%d/%d/%d %d:%d:%d.%d", tm->year(),
1504 tm->month(), tm->dayOfMonth(), tm->hours(),
1505 tm->minutes(), tm->seconds(), 0 );
1506 break;
1507 }
1508 case typeBinary:
1509 {
1510 unsigned char *c = (unsigned char *) src;
1511 unsigned char *str = (unsigned char *) dest;
1512 unsigned char p = 0;
1513 int i = 0;
1514 while (i < length) {
1515 p = *c >> 4;
1516 if (p < 10) sprintf ((char *)str++, "%c", '0' + p);
1517 else sprintf((char *)str++, "%c", 'A' + p - 10);
1518 p = *c & 0xF;
1519 if (p < 10) sprintf ((char *)str++, "%c", '0' + p);
1520 else sprintf((char *)str++, "%c", 'A' + p - 10);
1521 i++; c++;
1522 }
1523 break;
1524 }
1525
1526 default: ((char*)dest)[0] = '\0';
1527 }
1528
1529 }
1530 void AllDataType::convertToDate( void* dest, void* src, DataType srcType )
1531 {
1532 switch(srcType)
1533 {
1534 case typeInt:
1535 case typeLong:
1536 case typeLongLong:
1537 case typeShort:
1538 case typeByteInt:
1539 case typeFloat:
1540 case typeDouble:
1541 case typeDate:
1542 case typeTime:
1543 case typeTimeStamp:
1544 case typeString:
1545 {
1546 Date *dt = (Date*) dest;
1547 dt->parseFrom((char*)src);
1548 break;
1549 }
1550 default: ((char*)dest)[0] = '\0';
1551 }
1552 }
1553
1554 void AllDataType::convertToTime( void* dest, void* src, DataType srcType )
1555 {
1556 switch(srcType)
1557 {
1558 case typeInt:
1559 case typeLong:
1560 case typeLongLong:
1561 case typeShort:
1562 case typeByteInt:
1563 case typeFloat:
1564 case typeDouble:
1565 case typeDate:
1566 case typeTime:
1567 case typeTimeStamp:
1568 case typeString:
1569 {
1570 Time *dt = (Time*) dest;
1571 dt->parseFrom((char*)src);
1572 break;
1573 }
1574 default: ((char*)dest)[0] = '\0';
1575 }
1576 }
1577
1578 void AllDataType::convertToTimeStamp( void* dest, void* src, DataType srcType )
1579 {
1580 switch(srcType)
1581 {
1582 case typeInt:
1583 case typeLong:
1584 case typeLongLong:
1585 case typeShort:
1586 case typeByteInt:
1587 case typeFloat:
1588 case typeDouble:
1589 case typeDate:
1590 case typeTime:
1591 case typeTimeStamp:
1592 case typeString:
1593 {
1594 TimeStamp *dt = (TimeStamp*) dest;
1595 dt->parseFrom((char*)src);
1596 break;
1597 }
1598 default: ((char*)dest)[0] = '\0';
1599 }
1600 }
1601
1602 void AllDataType::convertToBinary(void *dest, void *src, DataType srcType, int length)
1603 {
1604 switch(srcType)
1605 {
1606 case typeString:
1607 {
1608 unsigned char c = 0;
1609 const char *str = (const char *)src;
1610 unsigned char *val = (unsigned char *)dest;
1611 int i = 0;
1612 while (i < length * 2) {
1613 c = *str++; i++;
1614 if (c == '\0') { *val = *val | c; break; }
1615 if (c <= '9') c -= '0';
1616 else if (c >= 'a') c = c - 'a' + 10;
1617 else c = c - 'A' + 10;
1618 if (i % 2) { *val = c; *val <<= 4; }
1619 else { *val = *val | c; val++; }
1620 }
1621 break;
1622 }
1623 }
1624 }
1625
1626 int AllDataType::printVal(void* src, DataType srcType, int length )
1627 {
1628 int count = 0;
1629 switch(srcType)
1630 {
1631 case typeInt:
1632 {
1633 count = printf ("%d", *(int *)src);
1634 break;
1635 }
1636 case typeLong:
1637 {
1638 count = printf ("%ld", *(long *)src);
1639 break;
1640 }
1641 case typeLongLong:
1642 {
1643 count = printf ("%lld", *(long long *)src);
1644 break;
1645 }
1646 case typeShort:
1647 {
1648 count = printf("%hd", *(short *)src);
1649 break;
1650 }
1651 case typeByteInt:
1652 {
1653 count = printf("%hd", *(char *)src);
1654 break;
1655 }
1656
1657 case typeFloat:
1658 {
1659 count = printf("%f", *(float *)src);
1660 break;
1661 }
1662 case typeDouble:
1663 {
1664 count = printf("%lf", *(double *)src);
1665 break;
1666 }
1667
1668 case typeString:
1669 {
1670 count = printf("%s", (char*)src);
1671 break;
1672 }
1673 case typeDate:
1674 {
1675 Date* dt = (Date*)src;
1676 count = printf("%d/%d/%d", dt->year(),
1677 dt->month(), dt->dayOfMonth());
1678 break;
1679 }
1680 case typeTime:
1681 {
1682 Time* tm = (Time*)src;
1683 count = printf("%d:%d:%d.%d", tm->hours(), tm->minutes(), tm->seconds(), 0);
1684 break;
1685 }
1686 case typeTimeStamp:
1687 {
1688 TimeStamp* tm = (TimeStamp*)src;
1689 count = printf("%d/%d/%d %d:%d:%d.%d", tm->year(),
1690 tm->month(), tm->dayOfMonth(), tm->hours(),
1691 tm->minutes(), tm->seconds(), 0 );
1692 break;
1693 }
1694 case typeBinary:
1695 {
1696 unsigned char *c = (unsigned char *) src;
1697 unsigned char p = 0;
1698 int i = 0;
1699 while (i < length) {
1700 p = *c >> 4;
1701 if (p < 10) printf ("%c", '0' + p);
1702 else printf("%c", 'A' + p - 10);
1703 p = *c & 0xF;
1704 if (p < 10) printf ("%c", '0' + p);
1705 else printf("%c", 'A' + p - 10);
1706 i++; c++;
1707 }
1708 count = length * 2;
1709 break;
1710 }
1711 default: { printf("DataType not supported\n"); break; }
1712 }
1713 return count;
1714 }
1715
1716
1717
Main memory database SQL engine (cvs import)