?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Adding new tool cacheverify to the build system
[csql.git] / src / server / DataType.cxx
blobece12408959065928e07cac08eb26cb3d84b051d
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
19 #define SmallestValJulDate (1721426)
20
21 Date::Date(int year, int month, int day)
22 { YMDToJulian(year, month, day, julianDate); }
23 int Date::set(int year, int month, int day)
24 { return YMDToJulian(year,month,day,julianDate); }
25 int Date::get(int &year, int &month, int &day) const
26 { return julianToYMD(julianDate,year,month,day); }
27
28 int Date::parseFrom(const char *s) {
29 int month,day,year;
30 int count;
31 count = sscanf(s,"%d/%d/%d",&year,&month,&day);
32 if (count < 3) return -1;
33
34 if (year < 100) year += 1900;
35
36 if (!isValidDate(year, month, day))
37 return -1;
38 return set(year,month,day);
39 }
40
41 int Date::dayOfMonth() const {
42 int year, month, day;
43 get(year,month,day);
44 return day;
45 }
46 int Date::month() const {
47 int year, month, day;
48 get(year,month,day);
49 return month;
50 }
51 int Date::year() const {
52 int year, month, day;
53 get(year,month,day);
54 return year;
55 }
56
57 int Date::dayOfWeek() const { return dayOfWeek(julianDate); }
58
59 const char *Date::dayOfWeekName() const
60 { return dayOfWeekName(dayOfWeek(julianDate)); }
61
62 const char *Date::dayOfWeekAbbr() const
63 { return dayOfWeekAbbr(dayOfWeek(julianDate)); }
64
65 static const char *day_names[] = {
66 "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
67 };
68 static const char *day_abbrs[] = {
69 "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
70 };
71
72 static const char *month_names[] = {
73 "January", "February", "March", "April", "May", "June",
74 "July", "August", "September", "October", "November", "December"
75 };
76 static const char *month_abbrs[] = {
77 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
78 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
79 };
80
81
82 static int daysBeforeMonth[] = {
83 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365
84 };
85 static int days_per_month[] = {
86 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
87 };
88
89 const char * Date::dayOfWeekName(int day)
90 { return (day < 1 || day > 7) ? 0 : day_names[day-1]; }
91
92 const char * Date::dayOfWeekAbbr(int day)
93 { return (day < 1 || day > 7) ? 0 : day_abbrs[day-1]; }
94
95 const char * Date::monthName() const { return monthName(month()); }
96 const char * Date::monthAbbr() const { return monthAbbr(month()); }
97 const char * Date::monthName(int month)
98 { return (month < 1 || month > 12) ? 0 : month_names[month-1]; }
99 const char * Date::monthAbbr(int month)
100 { return (month < 1 || month > 12) ? 0 : month_abbrs[month-1]; }
101 Date operator+(const Date &d1, int days)
102 { return Date(d1.julianDate + days); }
103 Date operator+(int days, const Date &d1)
104 { return Date(d1.julianDate + days); }
105 Date operator-(const Date &d1, int days)
106 { return Date(d1.julianDate - days); }
107
108 int operator-(const Date &d1, const Date& d2)
109 { return d1.julianDate - d2.julianDate; }
110
111 int operator<(const Date &d1 ,const Date &d2 )
112 { return d1.julianDate < d2.julianDate; }
113 int operator>(const Date &d1 ,const Date &d2 )
114 { return d1.julianDate > d2.julianDate; }
115 int operator<=(const Date &d1 ,const Date &d2 )
116 { return d1.julianDate <= d2.julianDate; }
117 int operator>=(const Date &d1 ,const Date &d2 )
118 { return d1.julianDate >= d2.julianDate; }
119 int operator==(const Date &d1 ,const Date &d2 )
120 { return d1.julianDate == d2.julianDate; }
121 int operator!=(const Date &d1 ,const Date &d2 )
122 { return d1.julianDate != d2.julianDate; }
123
124 bool Date::isValid() const
125 { return julianDate >= SmallestValJulDate; }
126
127 bool Date::isLeapYear(int year)
128 {
129 return (year % 400 == 0) || ((year % 4 == 0) && !(year % 100 == 0));
130 }
131
132 int Date::dayOfYear() const {
133 int year,month,day;
134 get(year,month,day);
135 int tmp = daysBeforeMonth[month-1];
136 if (month >= 3 && isLeapYear(year))
137 tmp++;
138 return tmp + day;
139 }
140
141 int Date::daysInMonth(int month, int year) {
142 --month;
143 int tmp = days_per_month[month];
144 if (month == 1 && isLeapYear(year)) tmp++;
145 return tmp;
146 }
147
148 bool Date::isValidDate(int year, int month, int day) {
149 if (year < 1 || year > 10000) return false;
150 if (month < 1 || month > 12) return false;
151 return (day >= 1) && (day <= daysInMonth(month,year));
152 }
153
154 // Algorithm Author: Robert G. Tantzen
155 int Date::YMDToJulian(int year, int mon, int day, JulianRep &jul) {
156 if (!isValidDate(year, mon, day))
157 { jul = (JulianRep)0; return -1; }
158
159 // year, month, day are assumed to be valid
160 int m = mon, d = day, y = year;
161 int c, ya, j;
162
163 if (m > 2) m -= 3;
164 else { m += 9; --y; }
165 c = y/100;
166 ya = y - (100 * c);
167 j = (146097*c)/4 + (1461*ya)/4 + (153*m+2)/5 + d + 1721119;
168 jul = (JulianRep)j;
169 return 0;
170 }
171
172 // Julian date converter. Takes a julian date (the number of days since some
173 // distant epoch or other), and returns month, day of month, and year in
174 // integer references.
175 // Algorithm Author: Robert G. Tantzen
176 int Date::dayOfWeek(JulianRep jul) {
177 return (int)((jul+1)%7+1);
178 }
179
180 int Date::julianToYMD(JulianRep jul, int &year, int &month, int &day) {
181 int j = jul;
182 int d, m, y;
183
184 if (j < SmallestValJulDate)
185 { year = month = day = 0; return -1; }
186
187 j -= 1721119;
188 y = (4 * j - 1)/146097;
189 j = 4 * j - 1 - 146097 * y;
190 d = j/4;
191 j = (4 * d + 3)/1461;
192 d = 4 * d + 3 - 1461 * j;
193 d = (d + 4)/4;
194 m = (5 * d - 3)/153;
195 d = 5 * d - 3 - 153 * m;
196 d = (d + 5) / 5;
197 y = 100 * y + j;
198 if (m < 10) m += 3;
199 else { m -= 9; ++y; }
200 month = m;
201 day = d;
202 year = y;
203 return 0;
204 }
205
206 #define MAX_VALID_SECONDS (60 * 60 * 24 -1)
207 Time::Time(int hours, int mins, int secs, int usec)
208 { set(hours,mins,secs, usec); }
209
210 int Time::set(int hours, int mins, int secs, int usec) {
211 if((hours | mins | secs | usec) < 0) { timeVal = -1; return -1; }
212 if(hours >= 24 | mins >= 60 | secs >= 62)
213 { timeVal = -1; return -1; }
214 timeVal = secs + mins * 60 + hours * 3600;
215 timeVal *= 10000;
216 if(usec) timeVal += usec/100;
217 return 0;
218 }
219
220 int Time::get(int &hours, int &mins, int &secs) const {
221 if (timeVal < 0) return -1;
222 int s = timeVal/10000;
223 secs = s % 60;
224 s /= 60;
225 mins = s % 60;
226 s /= 60;
227 hours = s;
228 return 0;
229 }
230
231 int Time::seconds() const { return (timeVal/10000) % 60; }
232 int Time::minutes() const { return (timeVal /(60*10000)) % 60; }
233 int Time::hours() const { return timeVal / (3600*10000); }
234 int Time::msec() const { return (timeVal % 10000) / 10; }
235 int Time::usec() const { return (timeVal % 10000) * 100; }
236
237 int Time::setMsec(int ms) {
238 if(ms < 0 || ms >= 1000) return -1;
239 timeVal = timeVal+(10*ms);
240 return 0;
241 }
242 int Time::setUsec(int us) {
243 if(us < 0 || us >= 1000000) return -1;
244 timeVal = timeVal +us/100;
245 return 0;
246 }
247
248 bool Time::isValid() const
249 { return timeVal >= 0 && timeVal <= (10000*(MAX_VALID_SECONDS+1)-1); }
250
251 bool Time::isValidTime(int hours, int mins, int secs) {
252 return (hours >= 0 && hours < 24) &&
253 (mins >= 0 && mins < 60) &&
254 (secs >= 0 && secs < 60);
255 }
256
257 Time operator+(const Time &t1, int seconds)
258 { return Time(t1.timeVal + seconds*10000); }
259 Time operator+(int seconds, const Time &t1)
260 { return Time(t1.timeVal + seconds*10000); }
261 Time operator-(const Time &t1, int seconds)
262 { return Time(t1.timeVal - seconds*10000); }
263
264 int operator-(const Time &t1, const Time& t2)
265 { return (t1.timeVal - t2.timeVal)/10000; }
266
267 int operator<(const Time &t1 ,const Time &t2 )
268 { return t1.timeVal < t2.timeVal; }
269 int operator>(const Time &t1 ,const Time &t2 )
270 { return t1.timeVal > t2.timeVal; }
271 int operator<=(const Time &t1 ,const Time &t2 )
272 { return t1.timeVal <= t2.timeVal; }
273 int operator>=(const Time &t1 ,const Time &t2 )
274 { return t1.timeVal >= t2.timeVal; }
275 int operator==(const Time &t1 ,const Time &t2 )
276 { return t1.timeVal == t2.timeVal; }
277 int operator!=(const Time &t1 ,const Time &t2 )
278 { return t1.timeVal != t2.timeVal; }
279
280 int Time::parseFrom(const char *s) {
281 int hours,mins,secs;
282 int count;
283 count = sscanf(s,"%d:%d:%d",&hours,&mins,&secs);
284 if (count < 2) return -1;
285 if (count == 2) secs = 0;
286
287 if (!isValidTime(hours,mins,secs))
288 return -1;
289 return set(hours,mins,secs);
290 }
291 int TimeStamp::parseFrom(const char *s) {
292 int hours,mins,secs;
293 int month,day,year;
294 int count;
295 count = sscanf(s,"%d/%d/%d %d:%d:%d",&year,&month,&day, &hours, &mins, &secs);
296 if (count < 5) return -1;
297 if (count == 5) secs = 0;
298
299 if (year < 100) year += 1900;
300
301 if (!date.isValidDate(year, month, day))
302 return -1;
303
304 setDate(year,month,day);
305
306
307 if (!time.isValidTime(hours,mins,secs))
308 return -1;
309 return setTime(hours,mins,secs);
310 }
311
312 int operator< (const TimeStamp &d1, const TimeStamp &d2)
313 { return (d1.date != d2.date) ? d1.date < d2.date : d1.time < d2.time; }
314 int operator> (const TimeStamp &d1, const TimeStamp &d2)
315 { return (d1.date != d2.date) ? d1.date > d2.date : d1.time > d2.time; }
316 int operator<=(const TimeStamp &d1, const TimeStamp &d2)
317 { return (d1.date != d2.date) ? d1.date < d2.date : d1.time <= d2.time; }
318 int operator>=(const TimeStamp &d1, const TimeStamp &d2)
319 { return (d1.date != d2.date) ? d1.date > d2.date : d1.time >= d2.time; }
320 int operator==(const TimeStamp &d1, const TimeStamp &d2)
321 { return d1.date == d2.date && d1.time == d2.time; }
322 int operator!=(const TimeStamp &d1, const TimeStamp &d2)
323 { return d1.date != d2.date && d1.time != d2.time; }
324
325
326 long AllDataType::size(DataType type, int length )
327 {
328 long size = 0;
329 switch(type)
330 {
331 case typeInt:
332 size = sizeof(int);
333 break;
334 case typeLong:
335 size = sizeof(long);
336 break;
337 case typeLongLong:
338 size = sizeof(long long);
339 break;
340 case typeShort:
341 size = sizeof(short);
342 break;
343 case typeByteInt:
344 size = sizeof(char);
345 break;
346 case typeDouble:
347 size = sizeof(double);
348 break;
349 case typeFloat:
350 size = sizeof(float);
351 break;
352 case typeDecimal:
353 //TODO::for porting
354 //fldDef.length_ = sizeof(long double);
355 break;
356 case typeDate:
357 size = sizeof(Date);
358 break;
359 case typeTime:
360 size = sizeof(Time);
361 break;
362 case typeTimeStamp:
363 size = sizeof(TimeStamp);
364 break;
365 case typeString:
366 size = length;
367 break;
368 default:
369 size = 0;
370 break;
371 }
372 return size;
373 }
374 char* AllDataType::getSQLString(DataType type)
375 {
376 switch(type)
377 {
378 case typeInt: return "INT";
379 case typeLong: return "INT";
380 case typeLongLong: return "BIGINT";
381 case typeShort: return "SMALLINT";
382 case typeByteInt: return "TINYINT";
383 case typeDouble: return "REAL";
384 case typeFloat: return "FLOAT";
385 case typeDate: return "DATE";
386 case typeTime: return "TIME";
387 case typeTimeStamp: return "TIMESTAMP";
388 case typeString: return "CHAR";
389 default: return "UNKNOWN";
390 }
391 }
392
393
394 SQLSMALLINT AllDataType::convertToSQLType(DataType type)
395 {
396 switch(type)
397 {
398 case typeInt:
399 return SQL_INTEGER;
400 case typeLong:
401 return SQL_INTEGER;
402 case typeLongLong:
403 //TODO
404 return SQL_INTEGER;
405 case typeShort:
406 return SQL_SMALLINT;
407 case typeByteInt:
408 //TODO
409 return SQL_INTEGER;
410 case typeDouble:
411 return SQL_DOUBLE;
412 case typeFloat:
413 return SQL_REAL;
414 case typeDecimal:
415 //TODO
416 return SQL_INTEGER;
417 case typeDate:
418 return SQL_TYPE_DATE;
419 case typeTime:
420 return SQL_TYPE_TIME;
421 case typeTimeStamp:
422 return SQL_TYPE_TIMESTAMP;
423 case typeString:
424 return SQL_CHAR;
425 }
426 return SQL_INTEGER;
427 }
428 SQLSMALLINT AllDataType::convertToSQL_C_Type(DataType type)
429 {
430 switch(type)
431 {
432 case typeInt:
433 return SQL_C_SLONG;
434 case typeLong:
435 return SQL_C_SLONG;
436 case typeLongLong:
437 return SQL_C_SBIGINT;
438 case typeShort:
439 return SQL_C_SSHORT;
440 case typeByteInt:
441 return SQL_C_STINYINT;
442 case typeDouble:
443 return SQL_C_DOUBLE;
444 case typeFloat:
445 return SQL_C_FLOAT;
446 case typeDecimal:
447 //TODO
448 return SQL_INTEGER;
449 case typeDate:
450 return SQL_C_TYPE_DATE;
451 case typeTime:
452 return SQL_C_TYPE_TIME;
453 case typeTimeStamp:
454 return SQL_C_TYPE_TIMESTAMP;
455 case typeString:
456 return SQL_C_CHAR;
457 }
458 return SQL_C_SLONG;
459 }
460
461 DataType AllDataType::convertFromSQLType(SQLSMALLINT type)
462 {
463 switch(type)
464 {
465 case SQL_INTEGER :
466 return typeInt;
467 case SQL_SMALLINT:
468 return typeShort;
469 case SQL_DOUBLE:
470 return typeDouble;
471 case SQL_FLOAT:
472 case SQL_REAL:
473 return typeFloat;
474 case SQL_TYPE_DATE:
475 return typeDate;
476 case SQL_TYPE_TIME :
477 return typeTime;
478 case SQL_TYPE_TIMESTAMP :
479 return typeTimeStamp;
480 case SQL_CHAR:
481 return typeString;
482 case SQL_VARCHAR:
483 return typeString;
484 }
485 return typeInt;
486 }
487 void AllDataType::copyVal(void* dest, void *src, DataType type, int length)
488 {
489 switch(type)
490 {
491 case typeInt:
492 *(int*)dest = *(int*)src;
493 break;
494 case typeLong:
495 *(long*)dest = *(long*)src;
496 break;
497 case typeLongLong:
498 *(long long*)dest = *(long long*)src;
499 break;
500 case typeShort:
501 *(short*)dest = *(short*)src;
502 break;
503 case typeByteInt:
504 *(char*)dest = *(char*)src;
505 break;
506 case typeDouble:
507 *(double*)dest = *(double*)src;
508 break;
509 case typeFloat:
510 *(float*)dest = *(float*)src;
511 break;
512 case typeDecimal:
513 //TODO::for porting
514 case typeDate:
515 *(Date*)dest = *(Date*)src;
516 break;
517 case typeTime:
518 *(Time*)dest = *(Time*)src;
519 break;
520 case typeTimeStamp:
521 *(TimeStamp*)dest = *(TimeStamp*)src;
522 break;
523 case typeString:
524 {
525 strncpy((char*)dest, (char*)src, length);
526 char *d =(char*)dest;
527 d[length-1] = '\0';
528 break;
529 }
530 case typeBinary:
531 os::memcpy((char*)dest, (char*)src, length);
532 break;
533 default:
534 break;
535 }
536 }
537
538 bool AllDataType::compareVal(void *val1, void *val2, ComparisionOp op,
539 DataType type, long length)
540 {
541 bool result = false;
542 switch(type)
543 {
544 case typeInt:
545 result = AllDataType::compareIntVal(val1, val2, op );
546 break;
547 case typeLong:
548 result = AllDataType::compareLongVal(val1, val2, op);
549 break;
550 case typeLongLong:
551 result = AllDataType::compareLongLongVal(val1, val2, op);
552 break;
553 case typeShort:
554 result = AllDataType::compareShortVal(val1, val2, op);
555 break;
556 case typeByteInt:
557 result = AllDataType::compareByteIntVal(val1, val2, op);
558 break;
559 case typeDouble:
560 result = AllDataType::compareDoubleVal(val1, val2, op);
561 break;
562 case typeFloat:
563 result = AllDataType::compareFloatVal(val1, val2, op);
564 break;
565 case typeDecimal:
566 //TODO::for porting
567 break;
568 case typeDate:
569 result = AllDataType::compareDateVal(val1, val2, op);
570 break;
571 case typeTime:
572 result = AllDataType::compareTimeVal(val1, val2, op);
573 break;
574 case typeTimeStamp:
575 result = AllDataType::compareTimeStampVal(val1, val2, op);
576 break;
577 case typeString:
578 result = AllDataType::compareStringVal(val1, val2, op);
579 break;
580 case typeBinary:
581 result = AllDataType::compareBinaryVal(val1, val2, op, length);
582 break;
583 }
584 return result;
585 }
586
587 bool AllDataType::compareIntVal(void* src1, void *src2, ComparisionOp op)
588 {
589 if (src1 == NULL) printf("src1 is null\n");
590 if (src2 == NULL) printf("src2 is null\n");
591 bool result = false;
592 switch(op)
593 {
594 case OpEquals:
595 if (*(int*)src1 == *(int*)src2) result = true;
596 else result = false;
597 break;
598 case OpNotEquals:
599 if (*(int*)src1 != *(int*)src2) result = true;
600 else result = false;
601 break;
602 case OpLessThan:
603 if (*(int*)src1 < *(int*)src2) result = true;
604 else result = false;
605 break;
606 case OpLessThanEquals:
607 if (*(int*)src1 <= *(int*)src2) result = true;
608 else result = false;
609 break;
610 case OpGreaterThan:
611 if (*(int*)src1 > *(int*)src2) result = true;
612 else result = false;
613 break;
614 case OpGreaterThanEquals:
615 if (*(int*)src1 >= *(int*)src2) result = true;
616 else result = false;
617 break;
618 }
619 return result;
620 }
621
622 bool AllDataType::compareLongVal(void* src1, void *src2, ComparisionOp op)
623 {
624 bool result = false;
625 switch(op)
626 {
627 case OpEquals:
628 if (*(long*)src1 == *(long*)src2) result = true;
629 else result = false;
630 break;
631 case OpNotEquals:
632 if (*(long*)src1 != *(long*)src2) result = true;
633 else result = false;
634 break;
635 case OpLessThan:
636 if (*(long*)src1 < *(long*)src2) result = true;
637 else result = false;
638 break;
639 case OpLessThanEquals:
640 if (*(long*)src1 <= *(long*)src2) result = true;
641 else result = false;
642 break;
643 case OpGreaterThan:
644 if (*(long*)src1 > *(long*)src2) result = true;
645 else result = false;
646 break;
647 case OpGreaterThanEquals:
648 if (*(long*)src1 >= *(long*)src2) result = true;
649 else result = false;
650 break;
651 }
652 return result;
653 }
654
655 bool AllDataType::compareLongLongVal(void* src1, void *src2,
656 ComparisionOp op)
657 {
658 bool result = false;
659 switch(op)
660 {
661 case OpEquals:
662 if (*(long long*)src1 == *(long long*)src2) result = true;
663 else result = false;
664 break;
665 case OpNotEquals:
666 if (*(long long*)src1 != *(long long*)src2) result = true;
667 else result = false;
668 break;
669 case OpLessThan:
670 if (*(long long*)src1 < *(long long*)src2) result = true;
671 else result = false;
672 break;
673 case OpLessThanEquals:
674 if (*(long long*)src1 <= *(long long*)src2) result = true;
675 else result = false;
676 break;
677 case OpGreaterThan:
678 if (*(long long*)src1 > *(long long*)src2) result = true;
679 else result = false;
680 break;
681 case OpGreaterThanEquals:
682 if (*(long long*)src1 >= *(long long*)src2) result = true;
683 else result = false;
684 break;
685 }
686 return result;
687 }
688
689 bool AllDataType::compareShortVal(void* src1, void *src2, ComparisionOp op)
690 {
691 bool result = false;
692 switch(op)
693 {
694 case OpEquals:
695 if (*(short*)src1 == *(short*)src2) result = true;
696 else result = false;
697 break;
698 case OpNotEquals:
699 if (*(short*)src1 != *(short*)src2) result = true;
700 else result = false;
701 break;
702 case OpLessThan:
703 if (*(short*)src1 < *(short*)src2) result = true;
704 else result = false;
705 break;
706 case OpLessThanEquals:
707 if (*(short*)src1 <= *(short*)src2) result = true;
708 else result = false;
709 break;
710 case OpGreaterThan:
711 if (*(short*)src1 > *(short*)src2) result = true;
712 else result = false;
713 break;
714 case OpGreaterThanEquals:
715 if (*(short*)src1 >= *(short*)src2) result = true;
716 else result = false;
717 break;
718 }
719 return result;
720 }
721
722 bool AllDataType::compareByteIntVal(void* src1, void *src2, ComparisionOp op)
723 {
724 bool result = false;
725 switch(op)
726 {
727 case OpEquals:
728 if (*(ByteInt*)src1 == *(ByteInt*)src2) result = true;
729 else result = false;
730 break;
731 case OpNotEquals:
732 if (*(ByteInt*)src1 != *(ByteInt*)src2) result = true;
733 else result = false;
734 break;
735 case OpLessThan:
736 if (*(ByteInt*)src1 < *(ByteInt*)src2) result = true;
737 else result = false;
738 break;
739 case OpLessThanEquals:
740 if (*(ByteInt*)src1 <= *(ByteInt*)src2) result = true;
741 else result = false;
742 break;
743 case OpGreaterThan:
744 if (*(ByteInt*)src1 > *(ByteInt*)src2) result = true;
745 else result = false;
746 break;
747 case OpGreaterThanEquals:
748 if (*(ByteInt*)src1 >= *(ByteInt*)src2) result = true;
749 else result = false;
750 break;
751 }
752 return result;
753 }
754
755 bool AllDataType::compareDoubleVal(void* src1, void *src2, ComparisionOp op)
756 {
757 bool result = false;
758 switch(op)
759 {
760 case OpEquals:
761 if (*(double*)src1 == *(double*)src2) result = true;
762 else result = false;
763 break;
764 case OpNotEquals:
765 if (*(double*)src1 != *(double*)src2) result = true;
766 else result = false;
767 break;
768 case OpLessThan:
769 if (*(double*)src1 < *(double*)src2) result = true;
770 else result = false;
771 break;
772 case OpLessThanEquals:
773 if (*(double*)src1 <= *(double*)src2) result = true;
774 else result = false;
775 break;
776 case OpGreaterThan:
777 if (*(double*)src1 > *(double*)src2) result = true;
778 else result = false;
779 break;
780 case OpGreaterThanEquals:
781 if (*(double*)src1 >= *(double*)src2) result = true;
782 else result = false;
783 break;
784 }
785 return result;
786 }
787
788 bool AllDataType::compareFloatVal(void* src1, void *src2, ComparisionOp op)
789 {
790 bool result = false;
791 switch(op)
792 {
793 case OpEquals:
794 if (*(float*)src1 == *(float*)src2) result = true;
795 else result = false;
796 break;
797 case OpNotEquals:
798 if (*(float*)src1 != *(float*)src2) result = true;
799 else result = false;
800 break;
801 case OpLessThan:
802 if (*(float*)src1 < *(float*)src2) result = true;
803 else result = false;
804 break;
805 case OpLessThanEquals:
806 if (*(float*)src1 <= *(float*)src2) result = true;
807 else result = false;
808 break;
809 case OpGreaterThan:
810 if (*(float*)src1 > *(float*)src2) result = true;
811 else result = false;
812 break;
813 case OpGreaterThanEquals:
814 if (*(float*)src1 >= *(float*)src2) result = true;
815 else result = false;
816 break;
817 }
818 return result;
819 }
820
821 bool AllDataType::compareDateVal(void* src1, void *src2, ComparisionOp op)
822 {
823 bool result = false;
824 switch(op)
825 {
826 case OpEquals:
827 if (*(Date*)src1 == *(Date*)src2) result = true;
828 else result = false;
829 break;
830 case OpNotEquals:
831 if (*(Date*)src1 != *(Date*)src2) result = true;
832 else result = false;
833 break;
834 case OpLessThan:
835 if (*(Date*)src1 < *(Date*)src2) result = true;
836 else result = false;
837 break;
838 case OpLessThanEquals:
839 if (*(Date*)src1 <= *(Date*)src2) result = true;
840 else result = false;
841 break;
842 case OpGreaterThan:
843 if (*(Date*)src1 > *(Date*)src2) result = true;
844 else result = false;
845 break;
846 case OpGreaterThanEquals:
847 if (*(Date*)src1 >= *(Date*)src2) result = true;
848 else result = false;
849 break;
850 }
851 return result;
852 }
853
854 bool AllDataType::compareTimeVal(void* src1, void *src2, ComparisionOp op)
855 {
856 bool result = false;
857 switch(op)
858 {
859 case OpEquals:
860 if (*(Time*)src1 == *(Time*)src2) result = true;
861 else result = false;
862 break;
863 case OpNotEquals:
864 if (*(Time*)src1 != *(Time*)src2) result = true;
865 else result = false;
866 break;
867 case OpLessThan:
868 if (*(Time*)src1 < *(Time*)src2) result = true;
869 else result = false;
870 break;
871 case OpLessThanEquals:
872 if (*(Time*)src1 <= *(Time*)src2) result = true;
873 else result = false;
874 break;
875 case OpGreaterThan:
876 if (*(Time*)src1 > *(Time*)src2) result = true;
877 else result = false;
878 break;
879 case OpGreaterThanEquals:
880 if (*(Time*)src1 >= *(Time*)src2) result = true;
881 else result = false;
882 break;
883 }
884 return result;
885 }
886
887 bool AllDataType::compareTimeStampVal(void* src1, void *src2, ComparisionOp op)
888 {
889 bool result = false;
890 switch(op)
891 {
892 case OpEquals:
893 if (*(TimeStamp*)src1 == *(TimeStamp*)src2) result = true;
894 else result = false;
895 break;
896 case OpNotEquals:
897 if (*(TimeStamp*)src1 != *(TimeStamp*)src2) result = true;
898 else result = false;
899 break;
900 case OpLessThan:
901 if (*(TimeStamp*)src1 < *(TimeStamp*)src2) result = true;
902 else result = false;
903 break;
904 case OpLessThanEquals:
905 if (*(TimeStamp*)src1 <= *(TimeStamp*)src2) result = true;
906 else result = false;
907 break;
908 case OpGreaterThan:
909 if (*(TimeStamp*)src1 > *(TimeStamp*)src2) result = true;
910 else result = false;
911 break;
912 case OpGreaterThanEquals:
913 if (*(TimeStamp*)src1 >= *(TimeStamp*)src2) result = true;
914 else result = false;
915 break;
916 }
917 return result;
918 }
919
920 bool AllDataType::compareStringVal(void* src1, void *src2, ComparisionOp op)
921 {
922 bool result = false;
923 int ret = strcmp((char*)src1, (char*)src2);
924 switch(op)
925 {
926 case OpEquals:
927 if (ret == 0 ) result= true; else result = false;
928 break;
929 case OpNotEquals:
930 if (ret != 0 ) result= true; else result = false;
931 break;
932 case OpLessThan:
933 if (ret < 0 ) result= true; else result = false;
934 break;
935 case OpLessThanEquals:
936 printf("Illegal Operator:Not Supported for String\n");
937 break;
938 case OpGreaterThan:
939 if (ret > 0 ) result= true; else result = false;
940 break;
941 case OpGreaterThanEquals:
942 printf("Illegal Operator:Not Supported for String\n");
943 break;
944 }
945 return result;
946 }
947
948 bool AllDataType::compareBinaryVal(void* src1, void *src2,
949 ComparisionOp op, int length)
950 {
951 bool result = false;
952 int ret = os::memcmp(src1, src2, length);
953 switch(op)
954 {
955 case OpEquals:
956 if (ret == 0 ) result= true; else result = false;
957 break;
958 case OpNotEquals:
959 if (ret != 0 ) result= true; else result = false;
960 break;
961 case OpLessThan:
962 if (ret < 0 ) result= true; else result = false;
963 break;
964 case OpLessThanEquals:
965 printf("Illegal Operator:Not Supported for Binary\n");
966 break;
967 case OpGreaterThan:
968 if (ret > 0 ) result= true; else result = false;
969 break;
970 case OpGreaterThanEquals:
971 printf("Illegal Operator:Not Supported for Binary\n");
972 break;
973 }
974 return result;
975 }
976
977
978
979 ComparisionOp AllDataType::getComparisionOperator(char *str)
980 {
981 ComparisionOp op;
982 if (strcmp(str, "<=") == 0)
983 op = OpLessThanEquals;
984 else if (strcmp(str, ">=") == 0)
985 op = OpGreaterThanEquals;
986 else if (strcmp(str, "<") == 0)
987 op = OpLessThan;
988 else if (strcmp(str, ">") == 0)
989 op = OpGreaterThan;
990 else if (strcmp(str, "=") == 0)
991 op = OpEquals;
992 else if (strcmp(str, "!=") == 0 || strcmp(str, "<>") == 0 )
993 op = OpNotEquals;
994 else
995 op = OpInvalidComparisionOp;
996 return op;
997 }
998
999 void* AllDataType::alloc(DataType type, int length)
1000 {
1001 void *dest;
1002 switch(type)
1003 {
1004 case typeInt:
1005 dest = malloc(sizeof(int));
1006 break;
1007 case typeLong:
1008 dest = malloc(sizeof(long));
1009 break;
1010 case typeLongLong:
1011 dest = malloc(sizeof(long long));
1012 break;
1013 case typeShort:
1014 dest = malloc(sizeof(short));
1015 break;
1016 case typeByteInt:
1017 dest = malloc(sizeof(char));
1018 break;
1019 case typeDouble:
1020 dest = malloc(sizeof(double));
1021 break;
1022 case typeFloat:
1023 dest = malloc(sizeof(float));
1024 break;
1025 case typeDecimal:
1026 //TODO::for porting
1027 //fldDef.length_ = sizeof(long double);
1028 break;
1029 case typeString:
1030 if (length == 0 ) return NULL;
1031 dest = malloc(length);
1032 break;
1033 case typeDate:
1034 dest = malloc(sizeof(Date));
1035 break;
1036 case typeTime:
1037 dest = malloc(sizeof(Time));
1038 break;
1039 case typeTimeStamp:
1040 dest = malloc(sizeof(TimeStamp));
1041 break;
1042 }
1043 return dest;
1044 }
1045 void AllDataType::strToValue(void* dest, char *src, DataType type, int length)
1046 {
1047 switch(type)
1048 {
1049 case typeInt: {
1050 int val;
1051 sscanf( src, "%d", &val);
1052 *(int*)dest = val;
1053 break; }
1054 case typeLong: {
1055 long val;
1056 sscanf( src, "%ld", &val);
1057 *(long*)dest = val;
1058 break; }
1059 case typeLongLong: {
1060 long long val;
1061 sscanf( src, "%lld", &val);
1062 *(long long*)dest = val;
1063 break; }
1064 case typeShort: {
1065 short val;
1066 sscanf( src, "%hd", &val);
1067 *(short*)dest = val;
1068 break; }
1069 case typeByteInt: {
1070 char val;
1071 sscanf( src, "%c", &val);
1072 *(char*)dest = val;
1073 break; }
1074 case typeDouble: {
1075 double val;
1076 sscanf( src, "%lg", &val);
1077 *(double*)dest = val;
1078 break; }
1079 case typeFloat: {
1080 float val;
1081 sscanf( src, "%f", &val);
1082 *(float*)dest = val;
1083 break; }
1084 case typeDecimal:
1085 //TODO::for porting
1086 case typeString: {
1087 strncpy((char*)dest, (char*)src, length);
1088 char *d =(char*)dest;
1089 d[length-1] = '\0';
1090 break;}
1091 case typeDate: {
1092 int d,m,y,res=0;
1093 res = sscanf( src, "%d-%d-%d", &y, &m, &d );
1094 if( res != 3 )
1095 res = sscanf( src, "%d/%d/%d", &y, &m, &d );
1096 if( res != 3 )
1097 {
1098 fprintf(stderr,"Error reading date. yyyy{-/}mm{-/}dd is the valid format.");
1099 d=m=y=0;
1100 }
1101 Date dateObj(y,m,d);
1102 *(Date*)dest = dateObj;
1103 break; }
1104 case typeTime: {
1105 int h,m,s,res=0;
1106 res = sscanf( src, "%d:%d:%d", &h, &m, &s );
1107 if( res != 3 )
1108 {
1109 fprintf(stderr, "Error reading time, hh:mm:ss is the valid format.");
1110 h=m=s=0;
1111 }
1112 Time timeObj(h,m,s);
1113 *(Time*)dest = timeObj;
1114 break; }
1115 case typeTimeStamp: {
1116 int d,m,y, h,mn,s, res=0;
1117 res = sscanf( src, "%d-%d-%d %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1118 if( res != 6 )
1119 res = sscanf( src, "%d-%d-%d, %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1120 if( res != 6 )
1121 res = sscanf( src, "%d/%d/%d %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1122 if( res != 6 )
1123 res = sscanf( src, "%d/%d/%d, %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1124 if( res != 6 )
1125 {
1126 fprintf(stderr, "Error reading timestamp, yyyy{-/}mm{-/}dd[,] hh:mm:ss is the valid format.");
1127 d=m=y=h=mn=s=0;
1128 }
1129 TimeStamp timeStampObj(y,m,d,h,mn,s);
1130 *(TimeStamp*)dest = timeStampObj;
1131 break; }
1132 default:
1133 break;
1134 }
1135 }
1136
1137
1138 void AllDataType::convert(DataType srcType, void *src,
1139 DataType destType, void *dest)
1140 {
1141 switch ((DataType) destType )
1142 {
1143 case typeInt: convertToInt(dest, src, srcType); break;
1144 case typeLong: convertToLong(dest, src, srcType); break;
1145 case typeLongLong: convertToLongLong(dest, src, srcType); break;
1146 case typeShort: convertToShort(dest, src, srcType); break;
1147 case typeByteInt: convertToByteInt(dest, src, srcType); break;
1148
1149 case typeFloat: convertToFloat(dest, src, srcType); break;
1150 case typeDouble: convertToDouble(dest, src, srcType); break;
1151
1152 //TODO
1153 case typeDecimal: convertToDouble(dest, src, srcType); break;
1154
1155 case typeString: convertToString(dest, src, srcType); break;
1156
1157 case typeBinary:
1158 case typeDate: convertToDate(dest, src, srcType); break;
1159 case typeTime: convertToTime(dest, src, srcType); break;
1160 case typeTimeStamp: convertToTimeStamp(dest, src, srcType); break;
1161 default: return;
1162 }
1163 }
1164
1165 void AllDataType::convertToInt( void* dest, void* src, DataType srcType )
1166 {
1167 switch(srcType)
1168 {
1169 case typeInt: *(int *)dest = *(int *)src; break;
1170 case typeLong: *(int *)dest =(int) *(long *)src; break;
1171 case typeLongLong: *(int *)dest =(int) *(long long *)src; break;
1172 case typeShort: *(int *)dest =(int) *(short *)src; break;
1173 case typeByteInt: *(int *)dest =(int) *(char *)src; break;
1174
1175 case typeFloat: *(int *)dest = (int) *(float *)src; break;
1176 case typeDouble: *(int *)dest =(int) *(double *)src; break;
1177
1178 case typeString: sscanf((const char*)src, "%d", (int*) dest); break;
1179
1180 case typeDate:
1181 case typeTime:
1182 case typeTimeStamp:
1183 case typeBinary:
1184 default: *(int *)dest = (int) 0;
1185 }
1186 }
1187
1188 void AllDataType::convertToLong( void* dest, void* src, DataType srcType )
1189 {
1190 switch(srcType)
1191 {
1192 case typeInt: *(long *)dest =(long) *(int *)src; break;
1193 case typeLong: *(long *)dest = *(long *)src; break;
1194 case typeLongLong: *(long *)dest =(long) *(long long *)src; break;
1195 case typeShort: *(long *)dest =(long) *(short *)src; break;
1196 case typeByteInt: *(long *)dest =(long) *(char *)src; break;
1197
1198 case typeFloat: *(long *)dest = (long) *(float *)src; break;
1199 case typeDouble: *(long *)dest =(long) *(double *)src; break;
1200
1201 case typeString: sscanf((const char*)src, "%ld", (long*) dest); break;
1202
1203 case typeDate:
1204 case typeTime:
1205 case typeTimeStamp:
1206 case typeBinary:
1207 default: *(long *)dest = (long) 0;
1208 }
1209 }
1210
1211
1212 void AllDataType::convertToLongLong( void* dest, void* src, DataType srcType )
1213 {
1214 switch(srcType)
1215 {
1216 case typeInt: *(long long *)dest =(long long) *(int *)src; break;
1217 case typeLong: *(long long *)dest = (long long) *(long *)src; break;
1218 case typeLongLong: *(long long *)dest = *(long long *)src; break;
1219 case typeShort: *(long long *)dest =(long long) *(short *)src; break;
1220 case typeByteInt: *(long long *)dest =(long long) *(char *)src; break;
1221
1222 case typeFloat: *(long long *)dest = (long long) *(float *)src; break;
1223 case typeDouble: *(long long *)dest =(long long) *(double *)src; break;
1224
1225 case typeString: sscanf((const char*)src, "%lld", (long long*) dest); break;
1226
1227 case typeDate:
1228 case typeTime:
1229 case typeTimeStamp:
1230 case typeBinary:
1231 default: *(long long *)dest = (long long) 0;
1232 }
1233 }
1234
1235 void AllDataType::convertToShort( void* dest, void* src, DataType srcType )
1236 {
1237 switch(srcType)
1238 {
1239 case typeInt: *(short*)dest =(short) *(int*)src; break;
1240 case typeLong: *(short*)dest = (short) *(long*)src; break;
1241 case typeLongLong: *(short*)dest = (short) *(long long*)src; break;
1242 case typeShort: *(short*)dest = *(short*)src; break;
1243 case typeByteInt: *(short*)dest =(short) *(char *)src; break;
1244
1245 case typeFloat: *(short*)dest = (short) *(float *)src; break;
1246 case typeDouble: *(short*)dest =(short) *(double *)src; break;
1247
1248 case typeString: sscanf((const char*)src, "%hd", (short*) dest); break;
1249
1250 case typeDate:
1251 case typeTime:
1252 case typeTimeStamp:
1253 case typeBinary:
1254 default: *(short*)dest = (short) 0;
1255 }
1256 }
1257
1258 void AllDataType::convertToByteInt( void* dest, void* src, DataType srcType )
1259 {
1260 switch(srcType)
1261 {
1262 case typeInt: *(char*)dest = (char) *(int*)src; break;
1263 case typeLong: *(char*)dest = (char) *(long*)src; break;
1264 case typeLongLong: *(char*)dest = (char) *(long long*)src; break;
1265 case typeShort: *(char*)dest = (char) *(short*)src; break;
1266 case typeByteInt: *(char*)dest = *(char *)src; break;
1267
1268 case typeFloat: *(char*)dest = (char) *(float *)src; break;
1269 case typeDouble: *(char*)dest =(char) *(double *)src; break;
1270
1271 case typeString: sscanf((const char*)src, "%c", (char*) dest); break;
1272
1273 case typeDate:
1274 case typeTime:
1275 case typeTimeStamp:
1276 case typeBinary:
1277 default: *(char*)dest = (char) 0;
1278 }
1279 }
1280
1281 void AllDataType::convertToFloat( void* dest, void* src, DataType srcType )
1282 {
1283 switch(srcType)
1284 {
1285 case typeInt: *(float *)dest =(float) *(int *)src; break;
1286 case typeLong: *(float *)dest =(float) *(long *)src; break;
1287 case typeLongLong: *(float *)dest =(float) *(long long *)src; break;
1288 case typeShort: *(float *)dest =(float) *(short *)src; break;
1289 case typeByteInt: *(float *)dest =(float) *(char *)src; break;
1290
1291 case typeFloat: *(float *)dest = *(float *)src; break;
1292 case typeDouble: *(float *)dest =(float) *(double *)src; break;
1293
1294 case typeString: sscanf((const char*)src, "%f", (float*) dest); break;
1295
1296 case typeDate:
1297 case typeTime:
1298 case typeTimeStamp:
1299 case typeBinary:
1300 default: *(float *)dest = (float) 0;
1301 }
1302 }
1303
1304 void AllDataType::convertToDouble( void* dest, void* src, DataType srcType )
1305 {
1306 switch(srcType)
1307 {
1308 case typeInt: *(double *)dest =(double) *(int *)src; break;
1309 case typeLong: *(double *)dest =(double) *(long *)src; break;
1310 case typeLongLong: *(double *)dest =(double) *(long long *)src; break;
1311 case typeShort: *(double *)dest =(double) *(short *)src; break;
1312 case typeByteInt: *(double *)dest =(double) *(char *)src; break;
1313
1314 case typeFloat: *(double *)dest =(double) *(float *)src; break;
1315 case typeDouble: *(double *)dest = *(double *)src; break;
1316
1317 case typeString: sscanf((const char*)src, "%lf", (double*) dest); break;
1318
1319 case typeDate:
1320 case typeTime:
1321 case typeTimeStamp:
1322 case typeBinary:
1323 default: *(double *)dest = (double) 0;
1324 }
1325 }
1326
1327 void AllDataType::convertToString( void* dest, void* src, DataType srcType )
1328 {
1329 switch(srcType)
1330 {
1331 case typeInt:
1332 {
1333 sprintf ((char *)dest, "%d", *(int *)src);
1334 break;
1335 }
1336 case typeLong:
1337 {
1338 sprintf ((char *)dest, "%ld", *(long *)src);
1339 break;
1340 }
1341 case typeLongLong:
1342 {
1343 sprintf ((char *)dest, "%lld", *(long long *)src);
1344 break;
1345 }
1346 case typeShort:
1347 {
1348 sprintf ((char *)dest, "%hd", *(short *)src);
1349 break;
1350 }
1351 case typeByteInt:
1352 {
1353 sprintf ((char *)dest, "%hd", *(char *)src);
1354 break;
1355 }
1356
1357 case typeFloat:
1358 {
1359 sprintf ((char *)dest, "%f", *(float *)src);
1360 break;
1361 }
1362 case typeDouble:
1363 {
1364 sprintf ((char *) dest, "%lf", *(double *)src);
1365 break;
1366 }
1367
1368 case typeString:
1369 {
1370 strcpy((char*)dest, (char*)src);
1371 break;
1372 }
1373 case typeDate:
1374 {
1375 Date* dt = (Date*)src;
1376 sprintf((char*) dest, "%d/%d/%d", dt->year(),
1377 dt->month(), dt->dayOfMonth());
1378 break;
1379 }
1380 case typeTime:
1381 {
1382 Time* tm = (Time*)src;
1383 sprintf((char*)dest,"%d:%d:%d.%d", tm->hours(), tm->minutes(), tm->seconds(), 0);
1384 break;
1385 }
1386 case typeTimeStamp:
1387 {
1388 TimeStamp* tm = (TimeStamp*)src;
1389 sprintf((char*)dest, "%d/%d/%d %d:%d:%d.%d", tm->year(),
1390 tm->month(), tm->dayOfMonth(), tm->hours(),
1391 tm->minutes(), tm->seconds(), 0 );
1392 break;
1393 }
1394 default: ((char*)dest)[0] = '\0';
1395 }
1396
1397 }
1398 void AllDataType::convertToDate( void* dest, void* src, DataType srcType )
1399 {
1400 switch(srcType)
1401 {
1402 case typeInt:
1403 case typeLong:
1404 case typeLongLong:
1405 case typeShort:
1406 case typeByteInt:
1407 case typeFloat:
1408 case typeDouble:
1409 case typeDate:
1410 case typeTime:
1411 case typeTimeStamp:
1412 case typeString:
1413 {
1414 Date *dt = (Date*) dest;
1415 dt->parseFrom((char*)src);
1416 break;
1417 }
1418 default: ((char*)dest)[0] = '\0';
1419 }
1420 }
1421
1422 void AllDataType::convertToTime( void* dest, void* src, DataType srcType )
1423 {
1424 switch(srcType)
1425 {
1426 case typeInt:
1427 case typeLong:
1428 case typeLongLong:
1429 case typeShort:
1430 case typeByteInt:
1431 case typeFloat:
1432 case typeDouble:
1433 case typeDate:
1434 case typeTime:
1435 case typeTimeStamp:
1436 case typeString:
1437 {
1438 Time *dt = (Time*) dest;
1439 dt->parseFrom((char*)src);
1440 break;
1441 }
1442 default: ((char*)dest)[0] = '\0';
1443 }
1444 }
1445
1446 void AllDataType::convertToTimeStamp( void* dest, void* src, DataType srcType )
1447 {
1448 switch(srcType)
1449 {
1450 case typeInt:
1451 case typeLong:
1452 case typeLongLong:
1453 case typeShort:
1454 case typeByteInt:
1455 case typeFloat:
1456 case typeDouble:
1457 case typeDate:
1458 case typeTime:
1459 case typeTimeStamp:
1460 case typeString:
1461 {
1462 TimeStamp *dt = (TimeStamp*) dest;
1463 dt->parseFrom((char*)src);
1464 break;
1465 }
1466 default: ((char*)dest)[0] = '\0';
1467 }
1468 }
1469
1470 void AllDataType::printVal(void* src, DataType srcType, int length )
1471 {
1472 switch(srcType)
1473 {
1474 case typeInt:
1475 {
1476 printf ("%d", *(int *)src);
1477 break;
1478 }
1479 case typeLong:
1480 {
1481 printf ("%ld", *(long *)src);
1482 break;
1483 }
1484 case typeLongLong:
1485 {
1486 printf ("%lld", *(long long *)src);
1487 break;
1488 }
1489 case typeShort:
1490 {
1491 printf("%hd", *(short *)src);
1492 break;
1493 }
1494 case typeByteInt:
1495 {
1496 printf("%hd", *(char *)src);
1497 break;
1498 }
1499
1500 case typeFloat:
1501 {
1502 printf("%f", *(float *)src);
1503 break;
1504 }
1505 case typeDouble:
1506 {
1507 printf("%lf", *(double *)src);
1508 break;
1509 }
1510
1511 case typeString:
1512 {
1513 printf("%s", (char*)src);
1514 break;
1515 }
1516 case typeDate:
1517 {
1518 Date* dt = (Date*)src;
1519 printf("%d/%d/%d", dt->year(),
1520 dt->month(), dt->dayOfMonth());
1521 break;
1522 }
1523 case typeTime:
1524 {
1525 Time* tm = (Time*)src;
1526 printf("%d:%d:%d.%d", tm->hours(), tm->minutes(), tm->seconds(), 0);
1527 break;
1528 }
1529 case typeTimeStamp:
1530 {
1531 TimeStamp* tm = (TimeStamp*)src;
1532 printf("%d/%d/%d %d:%d:%d.%d", tm->year(),
1533 tm->month(), tm->dayOfMonth(), tm->hours(),
1534 tm->minutes(), tm->seconds(), 0 );
1535 break;
1536 }
1537 default: { printf("DataType not supported\n"); break; }
1538 }
1539
1540 }
1541
1542
1543
Main memory database SQL engine (cvs import)