?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Recover cache tables from target database
[csql.git] / src / server / DataType.cxx
blobfa0622ed85833d487e94c5eb5d4412e2fdb06caf
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",&month,&day,&year);
32 if (count < 3) return -1;
33
34 if (year < 100) year += 1900;
35
36 if (!isValidDate(year, month, day))
37 return -1;
38
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
293 int operator< (const TimeStamp &d1, const TimeStamp &d2)
294 { return (d1.date != d2.date) ? d1.date < d2.date : d1.time < d2.time; }
295 int operator> (const TimeStamp &d1, const TimeStamp &d2)
296 { return (d1.date != d2.date) ? d1.date > d2.date : d1.time > d2.time; }
297 int operator<=(const TimeStamp &d1, const TimeStamp &d2)
298 { return (d1.date != d2.date) ? d1.date < d2.date : d1.time <= d2.time; }
299 int operator>=(const TimeStamp &d1, const TimeStamp &d2)
300 { return (d1.date != d2.date) ? d1.date > d2.date : d1.time >= d2.time; }
301 int operator==(const TimeStamp &d1, const TimeStamp &d2)
302 { return d1.date == d2.date && d1.time == d2.time; }
303 int operator!=(const TimeStamp &d1, const TimeStamp &d2)
304 { return d1.date != d2.date && d1.time != d2.time; }
305
306
307 long AllDataType::size(DataType type)
308 {
309 long size = 0;
310 switch(type)
311 {
312 case typeInt:
313 size = sizeof(int);
314 break;
315 case typeLong:
316 size = sizeof(long);
317 break;
318 case typeLongLong:
319 size = sizeof(long long);
320 break;
321 case typeShort:
322 size = sizeof(short);
323 break;
324 case typeByteInt:
325 size = sizeof(char);
326 break;
327 case typeDouble:
328 size = sizeof(double);
329 break;
330 case typeFloat:
331 size = sizeof(float);
332 break;
333 case typeDecimal:
334 //TODO::for porting
335 //fldDef.length_ = sizeof(long double);
336 break;
337 case typeDate:
338 size = sizeof(Date);
339 break;
340 case typeTime:
341 size = sizeof(Time);
342 break;
343 case typeTimeStamp:
344 size = sizeof(TimeStamp);
345 break;
346 default:
347 size = 0;
348 break;
349 }
350 return size;
351 }
352
353 SQLSMALLINT AllDataType::convertToSQLType(DataType type)
354 {
355 switch(type)
356 {
357 case typeInt:
358 return SQL_INTEGER;
359 case typeLong:
360 return SQL_INTEGER;
361 case typeLongLong:
362 //TODO
363 return SQL_INTEGER;
364 case typeShort:
365 return SQL_SMALLINT;
366 case typeByteInt:
367 //TODO
368 return SQL_INTEGER;
369 case typeDouble:
370 return SQL_DOUBLE;
371 case typeFloat:
372 return SQL_REAL;
373 case typeDecimal:
374 //TODO
375 return SQL_INTEGER;
376 case typeDate:
377 return SQL_TYPE_DATE;
378 case typeTime:
379 return SQL_TYPE_TIME;
380 case typeTimeStamp:
381 return SQL_TYPE_TIMESTAMP;
382 case typeString:
383 return SQL_CHAR;
384 }
385 return SQL_INTEGER;
386 }
387 DataType AllDataType::convertFromSQLType(SQLSMALLINT type)
388 {
389 switch(type)
390 {
391 case SQL_INTEGER :
392 return typeInt;
393 case SQL_SMALLINT:
394 return typeShort;
395 case SQL_DOUBLE:
396 return typeDouble;
397 case SQL_FLOAT:
398 case SQL_REAL:
399 return typeFloat;
400 case SQL_TYPE_DATE:
401 return typeDate;
402 case SQL_TYPE_TIME :
403 return typeTime;
404 case SQL_TYPE_TIMESTAMP :
405 return typeTimeStamp;
406 case SQL_CHAR :
407 return typeString;
408 }
409 return typeInt;
410 }
411 void AllDataType::copyVal(void* dest, void *src, DataType type, int length)
412 {
413 switch(type)
414 {
415 case typeInt:
416 *(int*)dest = *(int*)src;
417 break;
418 case typeLong:
419 *(long*)dest = *(long*)src;
420 break;
421 case typeLongLong:
422 *(long long*)dest = *(long long*)src;
423 break;
424 case typeShort:
425 *(short*)dest = *(short*)src;
426 break;
427 case typeByteInt:
428 *(char*)dest = *(char*)src;
429 break;
430 case typeDouble:
431 *(double*)dest = *(double*)src;
432 break;
433 case typeFloat:
434 *(float*)dest = *(float*)src;
435 break;
436 case typeDecimal:
437 //TODO::for porting
438 case typeDate:
439 *(Date*)dest = *(Date*)src;
440 break;
441 case typeTime:
442 *(Time*)dest = *(Time*)src;
443 break;
444 case typeTimeStamp:
445 *(TimeStamp*)dest = *(TimeStamp*)src;
446 break;
447 case typeString:
448 {
449 strncpy((char*)dest, (char*)src, length);
450 char *d =(char*)dest;
451 d[length-1] = '\0';
452 break;
453 }
454 case typeBinary:
455 os::memcpy((char*)dest, (char*)src, length);
456 break;
457 default:
458 break;
459 }
460 }
461
462 bool AllDataType::compareVal(void *val1, void *val2, ComparisionOp op,
463 DataType type, long length)
464 {
465 bool result = false;
466 switch(type)
467 {
468 case typeInt:
469 result = AllDataType::compareIntVal(val1, val2, op );
470 break;
471 case typeLong:
472 result = AllDataType::compareLongVal(val1, val2, op);
473 break;
474 case typeLongLong:
475 result = AllDataType::compareLongLongVal(val1, val2, op);
476 break;
477 case typeShort:
478 result = AllDataType::compareShortVal(val1, val2, op);
479 break;
480 case typeByteInt:
481 result = AllDataType::compareByteIntVal(val1, val2, op);
482 break;
483 case typeDouble:
484 result = AllDataType::compareDoubleVal(val1, val2, op);
485 break;
486 case typeFloat:
487 result = AllDataType::compareFloatVal(val1, val2, op);
488 break;
489 case typeDecimal:
490 //TODO::for porting
491 break;
492 case typeDate:
493 result = AllDataType::compareDateVal(val1, val2, op);
494 break;
495 case typeTime:
496 result = AllDataType::compareTimeVal(val1, val2, op);
497 break;
498 case typeTimeStamp:
499 result = AllDataType::compareTimeStampVal(val1, val2, op);
500 break;
501 case typeString:
502 result = AllDataType::compareStringVal(val1, val2, op);
503 break;
504 case typeBinary:
505 result = AllDataType::compareBinaryVal(val1, val2, op, length);
506 break;
507 }
508 return result;
509 }
510
511 bool AllDataType::compareIntVal(void* src1, void *src2, ComparisionOp op)
512 {
513 bool result = false;
514 switch(op)
515 {
516 case OpEquals:
517 if (*(int*)src1 == *(int*)src2) result = true;
518 else result = false;
519 break;
520 case OpNotEquals:
521 if (*(int*)src1 != *(int*)src2) result = true;
522 else result = false;
523 break;
524 case OpLessThan:
525 if (*(int*)src1 < *(int*)src2) result = true;
526 else result = false;
527 break;
528 case OpLessThanEquals:
529 if (*(int*)src1 <= *(int*)src2) result = true;
530 else result = false;
531 break;
532 case OpGreaterThan:
533 if (*(int*)src1 > *(int*)src2) result = true;
534 else result = false;
535 break;
536 case OpGreaterThanEquals:
537 if (*(int*)src1 >= *(int*)src2) result = true;
538 else result = false;
539 break;
540 }
541 return result;
542 }
543
544 bool AllDataType::compareLongVal(void* src1, void *src2, ComparisionOp op)
545 {
546 bool result = false;
547 switch(op)
548 {
549 case OpEquals:
550 if (*(long*)src1 == *(long*)src2) result = true;
551 else result = false;
552 break;
553 case OpNotEquals:
554 if (*(long*)src1 != *(long*)src2) result = true;
555 else result = false;
556 break;
557 case OpLessThan:
558 if (*(long*)src1 < *(long*)src2) result = true;
559 else result = false;
560 break;
561 case OpLessThanEquals:
562 if (*(long*)src1 <= *(long*)src2) result = true;
563 else result = false;
564 break;
565 case OpGreaterThan:
566 if (*(long*)src1 > *(long*)src2) result = true;
567 else result = false;
568 break;
569 case OpGreaterThanEquals:
570 if (*(long*)src1 >= *(long*)src2) result = true;
571 else result = false;
572 break;
573 }
574 return result;
575 }
576
577 bool AllDataType::compareLongLongVal(void* src1, void *src2,
578 ComparisionOp op)
579 {
580 bool result = false;
581 switch(op)
582 {
583 case OpEquals:
584 if (*(long long*)src1 == *(long long*)src2) result = true;
585 else result = false;
586 break;
587 case OpNotEquals:
588 if (*(long long*)src1 != *(long long*)src2) result = true;
589 else result = false;
590 break;
591 case OpLessThan:
592 if (*(long long*)src1 < *(long long*)src2) result = true;
593 else result = false;
594 break;
595 case OpLessThanEquals:
596 if (*(long long*)src1 <= *(long long*)src2) result = true;
597 else result = false;
598 break;
599 case OpGreaterThan:
600 if (*(long long*)src1 > *(long long*)src2) result = true;
601 else result = false;
602 break;
603 case OpGreaterThanEquals:
604 if (*(long long*)src1 >= *(long long*)src2) result = true;
605 else result = false;
606 break;
607 }
608 return result;
609 }
610
611 bool AllDataType::compareShortVal(void* src1, void *src2, ComparisionOp op)
612 {
613 bool result = false;
614 switch(op)
615 {
616 case OpEquals:
617 if (*(short*)src1 == *(short*)src2) result = true;
618 else result = false;
619 break;
620 case OpNotEquals:
621 if (*(short*)src1 != *(short*)src2) result = true;
622 else result = false;
623 break;
624 case OpLessThan:
625 if (*(short*)src1 < *(short*)src2) result = true;
626 else result = false;
627 break;
628 case OpLessThanEquals:
629 if (*(short*)src1 <= *(short*)src2) result = true;
630 else result = false;
631 break;
632 case OpGreaterThan:
633 if (*(short*)src1 > *(short*)src2) result = true;
634 else result = false;
635 break;
636 case OpGreaterThanEquals:
637 if (*(short*)src1 >= *(short*)src2) result = true;
638 else result = false;
639 break;
640 }
641 return result;
642 }
643
644 bool AllDataType::compareByteIntVal(void* src1, void *src2, ComparisionOp op)
645 {
646 bool result = false;
647 switch(op)
648 {
649 case OpEquals:
650 if (*(ByteInt*)src1 == *(ByteInt*)src2) result = true;
651 else result = false;
652 break;
653 case OpNotEquals:
654 if (*(ByteInt*)src1 != *(ByteInt*)src2) result = true;
655 else result = false;
656 break;
657 case OpLessThan:
658 if (*(ByteInt*)src1 < *(ByteInt*)src2) result = true;
659 else result = false;
660 break;
661 case OpLessThanEquals:
662 if (*(ByteInt*)src1 <= *(ByteInt*)src2) result = true;
663 else result = false;
664 break;
665 case OpGreaterThan:
666 if (*(ByteInt*)src1 > *(ByteInt*)src2) result = true;
667 else result = false;
668 break;
669 case OpGreaterThanEquals:
670 if (*(ByteInt*)src1 >= *(ByteInt*)src2) result = true;
671 else result = false;
672 break;
673 }
674 return result;
675 }
676
677 bool AllDataType::compareDoubleVal(void* src1, void *src2, ComparisionOp op)
678 {
679 bool result = false;
680 switch(op)
681 {
682 case OpEquals:
683 if (*(double*)src1 == *(double*)src2) result = true;
684 else result = false;
685 break;
686 case OpNotEquals:
687 if (*(double*)src1 != *(double*)src2) result = true;
688 else result = false;
689 break;
690 case OpLessThan:
691 if (*(double*)src1 < *(double*)src2) result = true;
692 else result = false;
693 break;
694 case OpLessThanEquals:
695 if (*(double*)src1 <= *(double*)src2) result = true;
696 else result = false;
697 break;
698 case OpGreaterThan:
699 if (*(double*)src1 > *(double*)src2) result = true;
700 else result = false;
701 break;
702 case OpGreaterThanEquals:
703 if (*(double*)src1 >= *(double*)src2) result = true;
704 else result = false;
705 break;
706 }
707 return result;
708 }
709
710 bool AllDataType::compareFloatVal(void* src1, void *src2, ComparisionOp op)
711 {
712 bool result = false;
713 switch(op)
714 {
715 case OpEquals:
716 if (*(float*)src1 == *(float*)src2) result = true;
717 else result = false;
718 break;
719 case OpNotEquals:
720 if (*(float*)src1 != *(float*)src2) result = true;
721 else result = false;
722 break;
723 case OpLessThan:
724 if (*(float*)src1 < *(float*)src2) result = true;
725 else result = false;
726 break;
727 case OpLessThanEquals:
728 if (*(float*)src1 <= *(float*)src2) result = true;
729 else result = false;
730 break;
731 case OpGreaterThan:
732 if (*(float*)src1 > *(float*)src2) result = true;
733 else result = false;
734 break;
735 case OpGreaterThanEquals:
736 if (*(float*)src1 >= *(float*)src2) result = true;
737 else result = false;
738 break;
739 }
740 return result;
741 }
742
743 bool AllDataType::compareDateVal(void* src1, void *src2, ComparisionOp op)
744 {
745 bool result = false;
746 switch(op)
747 {
748 case OpEquals:
749 if (*(Date*)src1 == *(Date*)src2) result = true;
750 else result = false;
751 break;
752 case OpNotEquals:
753 if (*(Date*)src1 != *(Date*)src2) result = true;
754 else result = false;
755 break;
756 case OpLessThan:
757 if (*(Date*)src1 < *(Date*)src2) result = true;
758 else result = false;
759 break;
760 case OpLessThanEquals:
761 if (*(Date*)src1 <= *(Date*)src2) result = true;
762 else result = false;
763 break;
764 case OpGreaterThan:
765 if (*(Date*)src1 > *(Date*)src2) result = true;
766 else result = false;
767 break;
768 case OpGreaterThanEquals:
769 if (*(Date*)src1 >= *(Date*)src2) result = true;
770 else result = false;
771 break;
772 }
773 return result;
774 }
775
776 bool AllDataType::compareTimeVal(void* src1, void *src2, ComparisionOp op)
777 {
778 bool result = false;
779 switch(op)
780 {
781 case OpEquals:
782 if (*(Time*)src1 == *(Time*)src2) result = true;
783 else result = false;
784 break;
785 case OpNotEquals:
786 if (*(Time*)src1 != *(Time*)src2) result = true;
787 else result = false;
788 break;
789 case OpLessThan:
790 if (*(Time*)src1 < *(Time*)src2) result = true;
791 else result = false;
792 break;
793 case OpLessThanEquals:
794 if (*(Time*)src1 <= *(Time*)src2) result = true;
795 else result = false;
796 break;
797 case OpGreaterThan:
798 if (*(Time*)src1 > *(Time*)src2) result = true;
799 else result = false;
800 break;
801 case OpGreaterThanEquals:
802 if (*(Time*)src1 >= *(Time*)src2) result = true;
803 else result = false;
804 break;
805 }
806 return result;
807 }
808
809 bool AllDataType::compareTimeStampVal(void* src1, void *src2, ComparisionOp op)
810 {
811 bool result = false;
812 switch(op)
813 {
814 case OpEquals:
815 if (*(TimeStamp*)src1 == *(TimeStamp*)src2) result = true;
816 else result = false;
817 break;
818 case OpNotEquals:
819 if (*(TimeStamp*)src1 != *(TimeStamp*)src2) result = true;
820 else result = false;
821 break;
822 case OpLessThan:
823 if (*(TimeStamp*)src1 < *(TimeStamp*)src2) result = true;
824 else result = false;
825 break;
826 case OpLessThanEquals:
827 if (*(TimeStamp*)src1 <= *(TimeStamp*)src2) result = true;
828 else result = false;
829 break;
830 case OpGreaterThan:
831 if (*(TimeStamp*)src1 > *(TimeStamp*)src2) result = true;
832 else result = false;
833 break;
834 case OpGreaterThanEquals:
835 if (*(TimeStamp*)src1 >= *(TimeStamp*)src2) result = true;
836 else result = false;
837 break;
838 }
839 return result;
840 }
841
842 bool AllDataType::compareStringVal(void* src1, void *src2, ComparisionOp op)
843 {
844 bool result = false;
845 int ret = strcmp((char*)src1, (char*)src2);
846 switch(op)
847 {
848 case OpEquals:
849 if (ret == 0 ) result= true; else result = false;
850 break;
851 case OpNotEquals:
852 if (ret != 0 ) result= true; else result = false;
853 break;
854 case OpLessThan:
855 if (ret < 0 ) result= true; else result = false;
856 break;
857 case OpLessThanEquals:
858 printf("Illegal Operator:Not Supported for String\n");
859 break;
860 case OpGreaterThan:
861 if (ret > 0 ) result= true; else result = false;
862 break;
863 case OpGreaterThanEquals:
864 printf("Illegal Operator:Not Supported for String\n");
865 break;
866 }
867 return result;
868 }
869
870 bool AllDataType::compareBinaryVal(void* src1, void *src2,
871 ComparisionOp op, int length)
872 {
873 bool result = false;
874 int ret = os::memcmp(src1, src2, length);
875 switch(op)
876 {
877 case OpEquals:
878 if (ret == 0 ) result= true; else result = false;
879 break;
880 case OpNotEquals:
881 if (ret != 0 ) result= true; else result = false;
882 break;
883 case OpLessThan:
884 if (ret < 0 ) result= true; else result = false;
885 break;
886 case OpLessThanEquals:
887 printf("Illegal Operator:Not Supported for Binary\n");
888 break;
889 case OpGreaterThan:
890 if (ret > 0 ) result= true; else result = false;
891 break;
892 case OpGreaterThanEquals:
893 printf("Illegal Operator:Not Supported for Binary\n");
894 break;
895 }
896 return result;
897 }
898
899
900
901 ComparisionOp AllDataType::getComparisionOperator(char *str)
902 {
903 ComparisionOp op;
904 if (strcmp(str, "<=") == 0)
905 op = OpLessThanEquals;
906 else if (strcmp(str, ">=") == 0)
907 op = OpGreaterThanEquals;
908 else if (strcmp(str, "<") == 0)
909 op = OpLessThan;
910 else if (strcmp(str, ">") == 0)
911 op = OpGreaterThan;
912 else if (strcmp(str, "=") == 0)
913 op = OpEquals;
914 else if (strcmp(str, "!=") == 0 || strcmp(str, "<>") == 0 )
915 op = OpNotEquals;
916 else
917 op = OpInvalidComparisionOp;
918 return op;
919 }
920
921 void* AllDataType::alloc(DataType type, int length)
922 {
923 void *dest;
924 switch(type)
925 {
926 case typeInt:
927 dest = malloc(sizeof(int));
928 break;
929 case typeLong:
930 dest = malloc(sizeof(long));
931 break;
932 case typeLongLong:
933 dest = malloc(sizeof(long long));
934 break;
935 case typeShort:
936 dest = malloc(sizeof(short));
937 break;
938 case typeByteInt:
939 dest = malloc(sizeof(char));
940 break;
941 case typeDouble:
942 dest = malloc(sizeof(double));
943 break;
944 case typeFloat:
945 dest = malloc(sizeof(float));
946 break;
947 case typeDecimal:
948 //TODO::for porting
949 //fldDef.length_ = sizeof(long double);
950 break;
951 case typeString:
952 if (length == 0 ) return NULL;
953 dest = malloc(length);
954 break;
955 case typeDate:
956 dest = malloc(sizeof(Date));
957 break;
958 case typeTime:
959 dest = malloc(sizeof(Time));
960 break;
961 case typeTimeStamp:
962 dest = malloc(sizeof(TimeStamp));
963 break;
964 }
965 return dest;
966 }
967 void AllDataType::strToValue(void* dest, char *src, DataType type, int length)
968 {
969 switch(type)
970 {
971 case typeInt: {
972 int val;
973 sscanf( src, "%d", &val);
974 *(int*)dest = val;
975 break; }
976 case typeLong: {
977 long val;
978 sscanf( src, "%ld", &val);
979 *(long*)dest = val;
980 break; }
981 case typeLongLong: {
982 long long val;
983 sscanf( src, "%lld", &val);
984 *(long long*)dest = val;
985 break; }
986 case typeShort: {
987 short val;
988 sscanf( src, "%hd", &val);
989 *(short*)dest = val;
990 break; }
991 case typeByteInt: {
992 char val;
993 sscanf( src, "%c", &val);
994 *(char*)dest = val;
995 break; }
996 case typeDouble: {
997 double val;
998 sscanf( src, "%lg", &val);
999 *(double*)dest = val;
1000 break; }
1001 case typeFloat: {
1002 float val;
1003 sscanf( src, "%f", &val);
1004 *(float*)dest = val;
1005 break; }
1006 case typeDecimal:
1007 //TODO::for porting
1008 case typeString: {
1009 strncpy((char*)dest, (char*)src, length);
1010 char *d =(char*)dest;
1011 d[length-1] = '\0';
1012 break;}
1013 case typeDate: {
1014 int d,m,y,res=0;
1015 res = sscanf( src, "%d-%d-%d", &d, &m, &y );
1016 if( res != 3 )
1017 res = sscanf( src, "%d/%d/%d", &d, &m, &y );
1018 if( res != 3 )
1019 {
1020 fprintf(stderr,"Error reading date. dd{-/}mm{-/}yyyy is the valid format.");
1021 d=m=y=0;
1022 }
1023 Date dateObj(y,m,d);
1024 *(Date*)dest = dateObj;
1025 break; }
1026 case typeTime: {
1027 int h,m,s,res=0;
1028 res = sscanf( src, "%d:%d:%d", &h, &m, &s );
1029 if( res != 3 )
1030 {
1031 fprintf(stderr, "Error reading time, hh:mm:ss is the valid format.");
1032 h=m=s=0;
1033 }
1034 Time timeObj(h,m,s);
1035 *(Time*)dest = timeObj;
1036 break; }
1037 case typeTimeStamp: {
1038 int d,m,y, h,mn,s, res=0;
1039 res = sscanf( src, "%d-%d-%d %d:%d:%d", &d, &m, &y, &h, &mn, &s );
1040 if( res != 6 )
1041 res = sscanf( src, "%d-%d-%d, %d:%d:%d", &d, &m, &y, &h, &mn, &s );
1042 if( res != 6 )
1043 res = sscanf( src, "%d/%d/%d %d:%d:%d", &d, &m, &y, &h, &mn, &s );
1044 if( res != 6 )
1045 res = sscanf( src, "%d/%d/%d, %d:%d:%d", &d, &m, &y, &h, &mn, &s );
1046 if( res != 6 )
1047 {
1048 fprintf(stderr, "Error reading timestamp, dd{-/}mm{-/}yyyy[,] hh:mm:ss is the valid format.");
1049 d=m=y=h=mn=s=0;
1050 }
1051 TimeStamp timeStampObj(y,m,d,h,mn,s);
1052 *(TimeStamp*)dest = timeStampObj;
1053 break; }
1054 default:
1055 break;
1056 }
1057 }
1058
1059
1060 void AllDataType::convert(DataType srcType, void *src,
1061 DataType destType, void *dest)
1062 {
1063 switch ((DataType) destType )
1064 {
1065 case typeInt: convertToInt(dest, src, srcType); break;
1066 case typeLong: convertToLong(dest, src, srcType); break;
1067 case typeLongLong: convertToLongLong(dest, src, srcType); break;
1068 case typeShort: convertToShort(dest, src, srcType); break;
1069 case typeByteInt: convertToByteInt(dest, src, srcType); break;
1070
1071 case typeFloat: convertToFloat(dest, src, srcType); break;
1072 case typeDouble: convertToDouble(dest, src, srcType); break;
1073
1074 //TODO
1075 case typeDecimal: convertToDouble(dest, src, srcType); break;
1076
1077 case typeString: convertToString(dest, src, srcType); break;
1078
1079 case typeBinary:
1080 case typeDate:
1081 case typeTime:
1082 case typeTimeStamp:
1083 default: return;
1084 }
1085 }
1086
1087 void AllDataType::convertToInt( void* dest, void* src, DataType srcType )
1088 {
1089 switch(srcType)
1090 {
1091 case typeInt: *(int *)dest = *(int *)src; break;
1092 case typeLong: *(int *)dest =(int) *(long *)src; break;
1093 case typeLongLong: *(int *)dest =(int) *(long long *)src; break;
1094 case typeShort: *(int *)dest =(int) *(short *)src; break;
1095 case typeByteInt: *(int *)dest =(int) *(char *)src; break;
1096
1097 case typeFloat: *(int *)dest = (int) *(float *)src; break;
1098 case typeDouble: *(int *)dest =(int) *(double *)src; break;
1099
1100 case typeString: sscanf((const char*)src, "%d", (int*) dest); break;
1101
1102 case typeDate:
1103 case typeTime:
1104 case typeTimeStamp:
1105 case typeBinary:
1106 default: *(int *)dest = (int) 0;
1107 }
1108 }
1109
1110 void AllDataType::convertToLong( void* dest, void* src, DataType srcType )
1111 {
1112 switch(srcType)
1113 {
1114 case typeInt: *(long *)dest =(long) *(int *)src; break;
1115 case typeLong: *(long *)dest = *(long *)src; break;
1116 case typeLongLong: *(long *)dest =(long) *(long long *)src; break;
1117 case typeShort: *(long *)dest =(long) *(short *)src; break;
1118 case typeByteInt: *(long *)dest =(long) *(char *)src; break;
1119
1120 case typeFloat: *(long *)dest = (long) *(float *)src; break;
1121 case typeDouble: *(long *)dest =(long) *(double *)src; break;
1122
1123 case typeString: sscanf((const char*)src, "%ld", (long*) dest); break;
1124
1125 case typeDate:
1126 case typeTime:
1127 case typeTimeStamp:
1128 case typeBinary:
1129 default: *(long *)dest = (long) 0;
1130 }
1131 }
1132
1133
1134 void AllDataType::convertToLongLong( void* dest, void* src, DataType srcType )
1135 {
1136 switch(srcType)
1137 {
1138 case typeInt: *(long long *)dest =(long long) *(int *)src; break;
1139 case typeLong: *(long long *)dest = (long long) *(long *)src; break;
1140 case typeLongLong: *(long long *)dest = *(long long *)src; break;
1141 case typeShort: *(long long *)dest =(long long) *(short *)src; break;
1142 case typeByteInt: *(long long *)dest =(long long) *(char *)src; break;
1143
1144 case typeFloat: *(long long *)dest = (long long) *(float *)src; break;
1145 case typeDouble: *(long long *)dest =(long long) *(double *)src; break;
1146
1147 case typeString: sscanf((const char*)src, "%lld", (long long*) dest); break;
1148
1149 case typeDate:
1150 case typeTime:
1151 case typeTimeStamp:
1152 case typeBinary:
1153 default: *(long long *)dest = (long long) 0;
1154 }
1155 }
1156
1157 void AllDataType::convertToShort( void* dest, void* src, DataType srcType )
1158 {
1159 switch(srcType)
1160 {
1161 case typeInt: *(short*)dest =(short) *(int*)src; break;
1162 case typeLong: *(short*)dest = (short) *(long*)src; break;
1163 case typeLongLong: *(short*)dest = (short) *(long long*)src; break;
1164 case typeShort: *(short*)dest = *(short*)src; break;
1165 case typeByteInt: *(short*)dest =(short) *(char *)src; break;
1166
1167 case typeFloat: *(short*)dest = (short) *(float *)src; break;
1168 case typeDouble: *(short*)dest =(short) *(double *)src; break;
1169
1170 case typeString: sscanf((const char*)src, "%hd", (short*) dest); break;
1171
1172 case typeDate:
1173 case typeTime:
1174 case typeTimeStamp:
1175 case typeBinary:
1176 default: *(short*)dest = (short) 0;
1177 }
1178 }
1179
1180 void AllDataType::convertToByteInt( void* dest, void* src, DataType srcType )
1181 {
1182 switch(srcType)
1183 {
1184 case typeInt: *(char*)dest = (char) *(int*)src; break;
1185 case typeLong: *(char*)dest = (char) *(long*)src; break;
1186 case typeLongLong: *(char*)dest = (char) *(long long*)src; break;
1187 case typeShort: *(char*)dest = (char) *(short*)src; break;
1188 case typeByteInt: *(char*)dest = *(char *)src; break;
1189
1190 case typeFloat: *(char*)dest = (char) *(float *)src; break;
1191 case typeDouble: *(char*)dest =(char) *(double *)src; break;
1192
1193 case typeString: sscanf((const char*)src, "%c", (char*) dest); break;
1194
1195 case typeDate:
1196 case typeTime:
1197 case typeTimeStamp:
1198 case typeBinary:
1199 default: *(char*)dest = (char) 0;
1200 }
1201 }
1202
1203 void AllDataType::convertToFloat( void* dest, void* src, DataType srcType )
1204 {
1205 switch(srcType)
1206 {
1207 case typeInt: *(float *)dest =(float) *(int *)src; break;
1208 case typeLong: *(float *)dest =(float) *(long *)src; break;
1209 case typeLongLong: *(float *)dest =(float) *(long long *)src; break;
1210 case typeShort: *(float *)dest =(float) *(short *)src; break;
1211 case typeByteInt: *(float *)dest =(float) *(char *)src; break;
1212
1213 case typeFloat: *(float *)dest = *(float *)src; break;
1214 case typeDouble: *(float *)dest =(float) *(double *)src; break;
1215
1216 case typeString: sscanf((const char*)src, "%f", (float*) dest); break;
1217
1218 case typeDate:
1219 case typeTime:
1220 case typeTimeStamp:
1221 case typeBinary:
1222 default: *(float *)dest = (float) 0;
1223 }
1224 }
1225
1226 void AllDataType::convertToDouble( void* dest, void* src, DataType srcType )
1227 {
1228 switch(srcType)
1229 {
1230 case typeInt: *(double *)dest =(double) *(int *)src; break;
1231 case typeLong: *(double *)dest =(double) *(long *)src; break;
1232 case typeLongLong: *(double *)dest =(double) *(long long *)src; break;
1233 case typeShort: *(double *)dest =(double) *(short *)src; break;
1234 case typeByteInt: *(double *)dest =(double) *(char *)src; break;
1235
1236 case typeFloat: *(double *)dest =(double) *(float *)src; break;
1237 case typeDouble: *(double *)dest = *(double *)src; break;
1238
1239 case typeString: sscanf((const char*)src, "%lf", (double*) dest); break;
1240
1241 case typeDate:
1242 case typeTime:
1243 case typeTimeStamp:
1244 case typeBinary:
1245 default: *(double *)dest = (double) 0;
1246 }
1247 }
1248
1249 void AllDataType::convertToString( void* dest, void* src, DataType srcType )
1250 {
1251 switch(srcType)
1252 {
1253 case typeInt:
1254 {
1255 sprintf ((char *)dest, "%d", *(int *)src);
1256 break;
1257 }
1258 case typeLong:
1259 {
1260 sprintf ((char *)dest, "%ld", *(long *)src);
1261 break;
1262 }
1263 case typeLongLong:
1264 {
1265 sprintf ((char *)dest, "%lld", *(long long *)src);
1266 break;
1267 }
1268 case typeShort:
1269 {
1270 sprintf ((char *)dest, "%hd", *(short *)src);
1271 break;
1272 }
1273 case typeByteInt:
1274 {
1275 sprintf ((char *)dest, "%hd", *(char *)src);
1276 break;
1277 }
1278
1279 case typeFloat:
1280 {
1281 sprintf ((char *)dest, "%f", *(float *)src);
1282 break;
1283 }
1284 case typeDouble:
1285 {
1286 sprintf ((char *) dest, "%lf", *(double *)src);
1287 break;
1288 }
1289
1290 case typeString:
1291 {
1292 strcpy((char*)dest, (char*)src);
1293 break;
1294 }
1295 case typeDate:
1296 {
1297 Date* dt = (Date*)src;
1298 sprintf((char*) dest, "%d/%d/%d", dt->dayOfMonth(),
1299 dt->month(), dt->year());
1300 break;
1301 }
1302 case typeTime:
1303 {
1304 Time* tm = (Time*)src;
1305 sprintf((char*)dest,"%d:%d:%d.%d", tm->hours(), tm->minutes(), tm->seconds(), 0);
1306 break;
1307 }
1308 case typeTimeStamp:
1309 {
1310 TimeStamp* tm = (TimeStamp*)src;
1311 sprintf((char*)dest, "%d/%d/%d %d:%d:%d.%d", tm->dayOfMonth(),
1312 tm->month(), tm->year(), tm->hours(),
1313 tm->minutes(), tm->seconds(), 0 );
1314 break;
1315 }
1316 default: ((char*)dest)[0] = '\0';
1317 }
1318
1319 }
1320
1321 void AllDataType::printVal(void* src, DataType srcType, int length )
1322 {
1323 switch(srcType)
1324 {
1325 case typeInt:
1326 {
1327 printf ("%d\t", *(int *)src);
1328 break;
1329 }
1330 case typeLong:
1331 {
1332 printf ("%ld\t", *(long *)src);
1333 break;
1334 }
1335 case typeLongLong:
1336 {
1337 printf ("%lld\t", *(long long *)src);
1338 break;
1339 }
1340 case typeShort:
1341 {
1342 printf("%hd\t", *(short *)src);
1343 break;
1344 }
1345 case typeByteInt:
1346 {
1347 printf("%hd\t", *(char *)src);
1348 break;
1349 }
1350
1351 case typeFloat:
1352 {
1353 printf("%f\t", *(float *)src);
1354 break;
1355 }
1356 case typeDouble:
1357 {
1358 printf("%lf\t", *(double *)src);
1359 break;
1360 }
1361
1362 case typeString:
1363 {
1364 printf("%s\t", (char*)src);
1365 break;
1366 }
1367 case typeDate:
1368 {
1369 Date* dt = (Date*)src;
1370 printf("%d/%d/%d\t", dt->dayOfMonth(),
1371 dt->month(), dt->year());
1372 break;
1373 }
1374 case typeTime:
1375 {
1376 Time* tm = (Time*)src;
1377 printf("%d:%d:%d.%d\t", tm->hours(), tm->minutes(), tm->seconds(), 0);
1378 break;
1379 }
1380 case typeTimeStamp:
1381 {
1382 TimeStamp* tm = (TimeStamp*)src;
1383 printf("%d/%d/%d %d:%d:%d.%d\t", tm->dayOfMonth(),
1384 tm->month(), tm->year(), tm->hours(),
1385 tm->minutes(), tm->seconds(), 0 );
1386 break;
1387 }
1388 default: { printf("DataType not supported\n"); break; }
1389 }
1390
1391 }
1392
1393
1394
Main memory database SQL engine (cvs import)